986 lines
31 KiB
Plaintext
986 lines
31 KiB
Plaintext
--[[
|
|
scheme_type: generic
|
|
author: Alundaio
|
|
modified_by:
|
|
--]]
|
|
|
|
--------------------
|
|
evaid = 188113
|
|
actid = 188113
|
|
--------------------
|
|
--------------------
|
|
local alife, math_random, tonumber = alife, math.random, tonumber
|
|
--------------------
|
|
local xr_weight_torch_detection = false -- DONT ENABLE
|
|
|
|
local ini = ini_file("ai_tweaks\\xr_danger.ltx")
|
|
DangerInertion = utils_data.collect_section(ini,"danger_inertion",true)
|
|
DangerInertionActor = utils_data.collect_section(ini,"danger_inertion_actor",true)
|
|
DangerIgnore = utils_data.collect_section(ini,"danger_object",true)
|
|
DangerIgnoreActor = utils_data.collect_section(ini,"danger_object_actor",true)
|
|
ini = nil
|
|
|
|
|
|
--[[
|
|
danger:perceive_type()
|
|
[danger_object.hit] = "hit",
|
|
[danger_object.sound] = "sound",
|
|
[danger_object.visual] = "visual"
|
|
--]]
|
|
|
|
local script_danger = {}
|
|
local bd_types = {
|
|
[danger_object.grenade] = "grenade",
|
|
[danger_object.entity_corpse] = "entity_corpse",
|
|
[danger_object.entity_attacked] = "entity_attacked",
|
|
[danger_object.attacked] = "attacked",
|
|
[danger_object.bullet_ricochet] = "bullet_ricochet",
|
|
[danger_object.enemy_sound] = "enemy_sound",
|
|
[danger_object.attack_sound] = "attack_sound",
|
|
[danger_object.entity_death] = "entity_death",
|
|
}
|
|
-----------------------------------------------------------------------------
|
|
-- PUBLIC
|
|
-----------------------------------------------------------------------------
|
|
function set_script_danger(npc,time,who_id,pos)
|
|
local id = npc:id()
|
|
if not (script_danger[id]) then
|
|
script_danger[id] = {danger_time = time_global(), danger_inertion = time, id = who_id, position = pos}
|
|
else
|
|
script_danger[id].danger_time = time_global()
|
|
script_danger[id].danger_inertion = time
|
|
script_danger[id].id = who_id
|
|
script_danger[id].position = pos
|
|
end
|
|
end
|
|
|
|
function has_danger(npc)
|
|
local id = npc:id()
|
|
local st = db.storage[id]
|
|
return st and st.danger_flag == true
|
|
end
|
|
-----------------------------------------------------------------------------
|
|
-- PRIVATE
|
|
-----------------------------------------------------------------------------
|
|
local function get_danger_name(best_danger)
|
|
local best_danger_object = best_danger:object()
|
|
local bd_type = best_danger:type()
|
|
|
|
if bd_type ~= danger_object.grenade and best_danger:dependent_object() ~= nil then
|
|
best_danger_object = best_danger:dependent_object()
|
|
end
|
|
|
|
if best_danger_object == nil then
|
|
return "none"
|
|
end
|
|
return best_danger_object:name()
|
|
end
|
|
|
|
function get_danger_time(danger,npc)
|
|
if (danger:type() == danger_object.entity_corpse) then
|
|
local corpse_object = danger:object()
|
|
return corpse_object and IsStalker(corpse_object) and corpse_object:death_time() or 0
|
|
end
|
|
|
|
return danger:time()
|
|
end
|
|
|
|
|
|
local npc_update_time = 0
|
|
|
|
local function npc_on_update(npc)
|
|
if not xr_weight_torch_detection then return end
|
|
if (npc:see(db.actor)) then return end
|
|
|
|
if (npc_update_time > time_global()) then return end
|
|
npc_update_time = time_global()+100
|
|
|
|
if not (IsStalker(npc)) then
|
|
return
|
|
end
|
|
|
|
if (has_danger(npc)) then
|
|
return
|
|
end
|
|
|
|
if (npc:best_enemy()) then
|
|
return
|
|
end
|
|
|
|
if (IsWounded(npc) or npc:character_community() == "zombied" or xr_combat_ignore.npc_in_safe_zone(npc)) then
|
|
return
|
|
end
|
|
|
|
local dist = npc:position():distance_to_sqr(db.actor:position())
|
|
|
|
local actor_weight = (db.actor:get_total_weight() - 25)*6
|
|
|
|
local diff = actor_weight/dist
|
|
if (diff > 1) and (dist < 200) then
|
|
npc:make_object_visible_somewhen(db.actor)
|
|
--printf("DETECT ACTOR WEIGHT:"..diff)
|
|
end
|
|
|
|
if (itms_manager.Torch2) and (dist < 80) and (npc:get_luminocity() < 0.3) then
|
|
npc:make_object_visible_somewhen(db.actor)
|
|
--printf("DETECT ACTOR TORCH")
|
|
end
|
|
|
|
end
|
|
|
|
local function npc_on_hear_callback(npc,who_id,s_type,dist,sound_power,sound_position)
|
|
if not (IsStalker(npc)) then
|
|
return
|
|
end
|
|
|
|
if (has_danger(npc)) then
|
|
return
|
|
end
|
|
|
|
if (npc:best_enemy()) then
|
|
return
|
|
end
|
|
|
|
--utils_data.debug_write("xr_danger:hear_callback",true)
|
|
|
|
if (IsWounded(npc) or character_community(npc) == "zombied" or xr_combat_ignore.npc_in_safe_zone(npc)) then
|
|
return
|
|
end
|
|
|
|
if (s_type == "WPN_hit" or s_type == "MST_attack" or s_type == "MST_damage") and dist < 900 then
|
|
local who = who_id and (db.storage[who_id] and db.storage[who_id].object)
|
|
if not (who) then
|
|
return
|
|
end
|
|
|
|
if not (IsStalker(who) or IsMonster(who)) then
|
|
return
|
|
end
|
|
|
|
if (xr_combat_ignore.ignore_enemy_by_overrides(npc,who)) then
|
|
return
|
|
end
|
|
|
|
if (who_id == AC_ID or npc:relation(who) >= 2) then
|
|
set_script_danger(npc,7000,who_id,vec_set(sound_position))
|
|
end
|
|
end
|
|
end
|
|
|
|
local function npc_on_death_callback(npc,who)
|
|
if (IsStalker(npc) and character_community(npc) ~= "zombied") then
|
|
--save_var(npc,"death_by_id",who:id())
|
|
local st = db.storage[npc:id()]
|
|
if (st) then
|
|
st.killer_last_known_position = vector():set(who:position())
|
|
end
|
|
end
|
|
end
|
|
|
|
-- xcvb this one looks weird, need testing because npcs should hear the body sound anyway
|
|
--[[
|
|
local function npc_on_hit_callback(npc,amount,local_direction,who,bone_index)
|
|
if (bone_index == "from_death_callback") then
|
|
return
|
|
end
|
|
|
|
set_script_danger(npc,7000,who_id,who and vector():set(who:position()))
|
|
end
|
|
--]]
|
|
|
|
local function get_rand_vertex(npc,vo)
|
|
local dir = npc:position():sub(vo:position())
|
|
dir = vector_rotate_y(dir,math_random(MinVectorRotateY,MaxVectorRotateY))
|
|
return vo:vertex_in_direction(vo:level_vertex_id(),dir,math_random(MinDistance,MaxDistance))
|
|
end
|
|
|
|
function danger_in_radius(npc,best_danger,bd_type)
|
|
|
|
local from_actor = (best_danger:object() and (best_danger:object():id() == db.actor:id()))
|
|
|
|
local src = (from_actor and DangerIgnoreActor[bd_types[bd_type]]) or DangerIgnore[bd_types[bd_type]]
|
|
local condlist = xr_logic.parse_condlist(npc,bd_types[bd_type],"danger_object",src)
|
|
local ignore_distance = condlist and tonumber(xr_logic.pick_section_from_condlist(db.actor,npc,condlist)) or 0
|
|
|
|
if (ignore_distance == 0) then
|
|
return false
|
|
end
|
|
|
|
if (best_danger:position():distance_to_sqr(npc:position()) < ignore_distance) then
|
|
return true
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
local function is_danger(npc,best_danger,script)
|
|
if xr_wounded.is_heavy_wounded_by_id(npc:id()) then
|
|
return false
|
|
end
|
|
|
|
if (xrs_kill_wounded and axr_task_manager.hostages_by_id[npc:id()]) then
|
|
return false
|
|
end
|
|
|
|
local best_danger_object = best_danger:object()
|
|
local bd_type = best_danger:type()
|
|
|
|
--if (bd_type == danger_object.entity_corpse) then
|
|
--return false
|
|
--end
|
|
|
|
if (bd_type == danger_object.grenade) then
|
|
if not (best_danger:dependent_object() and character_community(npc) ~= "zombied") then
|
|
return false
|
|
end
|
|
|
|
return danger_in_radius(npc,best_danger,bd_type)
|
|
end
|
|
|
|
if (xr_combat_ignore.npc_in_safe_zone(npc)) then
|
|
return false
|
|
end
|
|
|
|
if (bd_type == danger_object.entity_corpse) then
|
|
if (best_danger_object and IsStalker(best_danger_object) and character_community(best_danger_object) == character_community(npc)) then
|
|
local corpse_st = db.storage[best_danger_object:id()]
|
|
|
|
if not (corpse_st and corpse_st.death_time and corpse_st.death_by_id) then
|
|
return false
|
|
end
|
|
|
|
local killer = db.storage[corpse_st.death_by_id] and db.storage[corpse_st.death_by_id].object
|
|
if not (killer and (IsMonster(killer) or IsStalker(killer)) and killer:alive() and npc:relation(killer) > 0 and character_community(killer) ~= character_community(npc)) then
|
|
return false
|
|
end
|
|
|
|
if (xr_combat_ignore.ignore_enemy_by_overrides(npc,killer)) then
|
|
return false
|
|
end
|
|
|
|
if (game.get_game_time():diffSec(corpse_st.death_time) > 120000) then
|
|
return false
|
|
end
|
|
return danger_in_radius(npc,best_danger,bd_type)
|
|
end
|
|
return false
|
|
end
|
|
|
|
--if (db.storage[npc:id()].active_scheme == "camper") then
|
|
--return false
|
|
--end
|
|
|
|
if (best_danger:dependent_object()) then
|
|
best_danger_object = best_danger:dependent_object()
|
|
end
|
|
|
|
if (best_danger_object and (best_danger:perceive_type() == danger_object.hit)) then -- bypass combat ignore radius for attacked, entity_attacked, ricochet
|
|
return danger_in_radius(npc,best_danger,bd_type)
|
|
end
|
|
|
|
--if not (best_danger_object and (IsMonster(best_danger_object) or IsStalker(best_danger_object)) and npc:relation(best_danger_object) >= 2) then
|
|
if not (best_danger_object and (IsMonster(best_danger_object) or IsStalker(best_danger_object)) and ((best_danger:object():id() == db.actor:id()) or (npc:relation(best_danger_object) >= 2))) then
|
|
return false
|
|
end
|
|
|
|
if (xr_corpse_detection.is_under_corpse_detection(npc) or xr_help_wounded.is_under_help_wounded(npc)) then
|
|
return false
|
|
elseif (xrs_kill_wounded and xrs_kill_wounded.is_under_kill_wounded(npc)) then
|
|
return false
|
|
end
|
|
|
|
if (best_danger_object and (IsMonster(best_danger_object) or IsStalker(best_danger_object))) then
|
|
if not (best_danger_object:alive() and xr_combat_ignore.is_enemy(npc, best_danger_object,true)) then
|
|
return false
|
|
end
|
|
end
|
|
|
|
return danger_in_radius(npc,best_danger,bd_type)
|
|
end
|
|
|
|
local function check_script_danger(id)
|
|
if (script_danger[id]) then
|
|
if (time_global() < script_danger[id].danger_time + script_danger[id].danger_inertion) then
|
|
return true
|
|
else
|
|
script_danger[id] = nil
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- ON GAME START
|
|
-----------------------------------------------------------------------------
|
|
function on_game_start()
|
|
RegisterScriptCallback("npc_on_update",npc_on_update)
|
|
-- RegisterScriptCallback("npc_on_hit_callback",npc_on_hit_callback)
|
|
RegisterScriptCallback("npc_on_hear_callback",npc_on_hear_callback)
|
|
RegisterScriptCallback("npc_on_death_callback",npc_on_death_callback)
|
|
end
|
|
|
|
----------------------------------------------------------------------------------------------------------------------
|
|
-- EVALUATORS
|
|
----------------------------------------------------------------------------------------------------------------------
|
|
class "evaluator_danger" (property_evaluator)
|
|
function evaluator_danger:__init(name, storage, npc) super (nil, name)
|
|
self.a = storage
|
|
end
|
|
|
|
local function eval_danger(self)
|
|
local npc = self.object
|
|
local danger = npc:best_danger()
|
|
|
|
local flags = {ret_value = true}
|
|
SendScriptCallback("npc_on_eval_danger", self.object, flags)
|
|
if flags.ret_value == false then return false end
|
|
|
|
if not (danger) then
|
|
return false
|
|
end
|
|
|
|
local from_actor = (danger:object() and (danger:object():id() == db.actor:id()))
|
|
|
|
local tg = time_global()
|
|
local bd_type = danger:type()
|
|
|
|
if (self.a.inertion) then
|
|
if (self.a.type == bd_type) then
|
|
if (tg < self.a.danger_time + self.a.inertion) then
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
|
|
self.a.inertion = nil
|
|
|
|
--[[
|
|
if (bd_types[bd_type] == "entity_corpse") then
|
|
printf("%s %s %s",npc:name(),danger:object():name(),bd_types[bd_type])
|
|
end
|
|
--]]
|
|
|
|
local src = (from_actor and DangerInertionActor[bd_types[bd_type]]) or DangerInertion[bd_types[bd_type]]
|
|
local inertion = tonumber(xr_logic.pick_section_from_condlist(db.actor,npc,xr_logic.parse_condlist(npc,bd_types[bd_type],"danger_inertion_time",src))) or 0
|
|
|
|
local new_danger_time = get_danger_time(danger,npc)
|
|
if (tg >= new_danger_time + inertion) then
|
|
return false
|
|
end
|
|
|
|
if not(is_danger(npc,danger)) then
|
|
return false
|
|
end
|
|
|
|
--[[
|
|
local sim = alife()
|
|
local se_obj = sim:object(id)
|
|
if (se_obj and se_obj.m_smart_terrain_id ~= 65535) then
|
|
sim:object(se_obj.m_smart_terrain_id):set_alarm()
|
|
end
|
|
--]]
|
|
|
|
self.a.danger_time = new_danger_time
|
|
self.a.inertion = inertion
|
|
self.a.type = bd_type
|
|
|
|
return true
|
|
end
|
|
|
|
function evaluator_danger:evaluate()
|
|
--utils_data.debug_write("eva_danger")
|
|
local danger = eval_danger(self) or false
|
|
db.storage[self.object:id()].danger_flag = danger
|
|
return danger
|
|
end
|
|
|
|
-----------------------------------------------------------------------
|
|
-- ACTION
|
|
-----------------------------------------------------------------------
|
|
class "action_danger" ( action_base )
|
|
function action_danger:__init( name, storage ) super ( nil, name )
|
|
self.a = storage
|
|
end
|
|
function action_danger:initialize()
|
|
action_base.initialize( self )
|
|
self.a.stage = 1
|
|
self.object:set_path_type(game_object.level_path)
|
|
self.object:set_detail_path_type(move.line)
|
|
self.object:set_desired_direction()
|
|
self.a.last_state = state_mgr.get_state(self.object)
|
|
end
|
|
|
|
local function script_action_danger_scripted(npc,st)
|
|
--utils_data.debug_write("script_action_danger_scripted")
|
|
local id = npc:id()
|
|
local bdo = script_danger[id].id and db.storage[script_danger[id].id] and db.storage[script_danger[id].id].object
|
|
|
|
local bdo_pos = script_danger[id].position
|
|
local dist = bdo_pos and npc:position():distance_to_sqr(bdo_pos)
|
|
local tg = time_global()
|
|
|
|
|
|
local who_dist = bdo and bdo:position():distance_to_sqr(bdo_pos)
|
|
|
|
--[[
|
|
if (dist and dist >= 70) then
|
|
if (bdo and npc:relation(bdo) > 0 and npc:see(bdo)) then
|
|
state_mgr.set_state(npc,"hide_na",nil,nil,{look_object = bdo})
|
|
if (not utils_obj.squad_in_los(npc,bdo)) then
|
|
local wpn = npc:best_weapon()
|
|
if (wpn) then
|
|
local relation = npc:relation(bdo)
|
|
local look_pos = vector():set(bdo:position())
|
|
|
|
look_pos.y = relation >= 2 and look_pos.y + 1 or look_pos.y - (math_random(25,35)/100)
|
|
npc:set_sight(look.fire_point,look_pos)
|
|
|
|
if (npc:target_body_state() == move.crouch) then
|
|
st.__warning_shot_tmr = not st.__warning_shot_tmr and tg+500 or st.__warning_shot_tmr
|
|
if (tg < st.__warning_shot_tmr) then
|
|
npc:set_item(object.fire1,wpn,1,1)
|
|
xr_sound.set_sound_play(npc:id(),"tolls")
|
|
end
|
|
end
|
|
end
|
|
end
|
|
st.lvid = utils_obj.send_to_nearest_accessible_vertex(npc,npc:level_vertex_id())
|
|
end
|
|
end
|
|
--]]
|
|
|
|
if (st.stage == 1) then
|
|
local new_vid = random_choice(utils_obj.try_to_strafe(npc),utils_obj.try_go_backward(npc,6),utils_obj.try_go_cover(npc,bdo and bdo:position() or bdo_pos or npc:position()))
|
|
|
|
st.lvid = nil
|
|
|
|
if (new_vid and (not st.lvid or (new_vid ~= st.lvid and new_vid ~= npc:level_vertex_id())))then
|
|
st.lvid = new_vid
|
|
end
|
|
|
|
if not (new_vid) then
|
|
local dir = bdo_pos and vector():set(npc:position()):sub(bdo_pos) or npc:direction()
|
|
dir = vector_rotate_y(dir,math_random(-20,20))
|
|
|
|
local node = position_node(5)
|
|
node = node:select_best_vertex_id(npc,dir,npc:level_vertex_id(),20,35)
|
|
|
|
if (node and node.vertex_id and node.vertex_id ~= npc:level_vertex_id()) then
|
|
st.lvid = node.vertex_id
|
|
end
|
|
end
|
|
|
|
if (st.lvid and st.lvid ~= npc:level_vertex_id()) then
|
|
st.lvid = utils_obj.send_to_nearest_accessible_vertex(npc,st.lvid)
|
|
st.stage = 2
|
|
|
|
local sm = db.storage[npc:id()].state_mgr
|
|
if (sm and sm.target_state ~= "assault") then
|
|
npc:clear_animations()
|
|
sm:set_state("assault",nil,nil,{look_position = who_dist and who_dist < 22500 and bdo and bdo:position() or bdo_pos}, {fast_set = true})
|
|
sm.animation:set_state(nil, true)
|
|
sm.animation:set_control()
|
|
sm.animstate:set_state(nil,true)
|
|
sm.animstate:set_control()
|
|
end
|
|
|
|
return
|
|
end
|
|
|
|
state_mgr.set_state(npc,"hide_na",nil,nil,{look_position = who_dist and who_dist < 22500 and bdo and bdo:position() or bdo_pos})
|
|
elseif (st.stage == 2) then
|
|
if (npc:level_vertex_id() == st.lvid) then
|
|
local tg = time_global()
|
|
st.__dtimer = not st.__dtimer and tg + math_random(5000,15000) or st.__dtimer
|
|
if (tg > st.__dtimer) then
|
|
st.stage = 1
|
|
return
|
|
end
|
|
state_mgr.set_state(npc,"threat_danger",nil,nil,{look_position = who_dist and who_dist < 22500 and bdo and bdo:position() or bdo_pos})
|
|
return
|
|
end
|
|
state_mgr.set_state(npc,"assault",nil,nil,{look_position = who_dist and who_dist < 22500 and bdo and bdo:position() or bdo_pos})
|
|
utils_obj.send_to_nearest_accessible_vertex(npc,st.lvid)
|
|
end
|
|
end
|
|
|
|
local function script_action_danger_grenade(npc,st,bd,best_danger_object,dependent_object,bd_type)
|
|
--utils_data.debug_write("script_action_danger_grenade")
|
|
-- In this case dependent_object should be actual grenade object; best_danger_object should be nade thrower
|
|
local bdo = dependent_object or best_danger_object
|
|
|
|
local bdo_pos = bdo and bdo:position()
|
|
local dist = bdo_pos and npc:position():distance_to_sqr(bdo_pos)
|
|
|
|
local be = npc:best_enemy() or best_danger_object and npc:relation(best_danger_object) > 0 and best_danger_object
|
|
|
|
local tg = time_global()
|
|
|
|
if (dist and dist >= 150) then
|
|
--[[
|
|
if (be and npc:see(be)) then
|
|
state_mgr.set_state(npc,"hide_na",nil,nil,{look_object = be})
|
|
if (not utils_obj.squad_in_los(npc,be)) then
|
|
local wpn = npc:best_weapon()
|
|
if (wpn) then
|
|
local relation = npc:relation(be)
|
|
local look_pos = vector():set(be:position())
|
|
|
|
look_pos.y = relation >= 2 and look_pos.y + 1 or look_pos.y - (math_random(25,35)/100)
|
|
npc:set_sight(look.fire_point,look_pos)
|
|
|
|
if (npc:target_body_state() == move.crouch) then
|
|
st.__warning_shot_tmr = not st.__warning_shot_tmr and tg+500 or st.__warning_shot_tmr
|
|
if (tg < st.__warning_shot_tmr) then
|
|
npc:set_item(object.fire1,wpn,1,1)
|
|
xr_sound.set_sound_play(npc:id(),"tolls")
|
|
end
|
|
end
|
|
|
|
npc:set_body_state(move.crouch)
|
|
end
|
|
end
|
|
else
|
|
state_mgr.set_state(npc,"threat_danger",nil,nil,{look_position = bdo_pos})
|
|
end
|
|
--]]
|
|
local sm = db.storage[npc:id()].state_mgr
|
|
if (sm and sm.target_state ~= "threat_danger") then
|
|
npc:clear_animations()
|
|
sm:set_state("threat_danger",nil,nil,{look_position = bdo_pos}, {fast_set = true})
|
|
sm.animation:set_state(nil, true)
|
|
sm.animation:set_control()
|
|
sm.animstate:set_state(nil,true)
|
|
sm.animstate:set_control()
|
|
end
|
|
st.lvid = utils_obj.send_to_nearest_accessible_vertex(npc,npc:level_vertex_id())
|
|
return
|
|
end
|
|
|
|
if (st.stage == 1) then
|
|
local dir = bdo_pos and vector():set(npc:position()):sub(bdo_pos) or npc:direction()
|
|
dir = vector_rotate_y(dir,math_random(-20,20))
|
|
|
|
local new_vid = npc:vertex_in_direction(npc:level_vertex_id(),dir,math_random(20,35))
|
|
st.lvid = nil
|
|
|
|
if (new_vid and (not st.lvid or (new_vid ~= st.lvid and new_vid ~= npc:level_vertex_id())))then
|
|
st.lvid = new_vid
|
|
end
|
|
|
|
if not (new_vid) then
|
|
local node = position_node(5)
|
|
node = node:select_best_vertex_id(npc,dir,npc:level_vertex_id(),20,35)
|
|
|
|
if (node and node.vertex_id and node.vertex_id ~= npc:level_vertex_id()) then
|
|
st.lvid = node.vertex_id
|
|
end
|
|
end
|
|
|
|
if (st.lvid and st.lvid ~= npc:level_vertex_id()) then
|
|
st.lvid = utils_obj.send_to_nearest_accessible_vertex(npc,st.lvid)
|
|
st.stage = 2
|
|
|
|
local sm = db.storage[npc:id()].state_mgr
|
|
if (sm) then
|
|
npc:clear_animations()
|
|
sm:set_state("assault",nil,nil,{look_object = dist <= 100 and nil or bdo}, {fast_set = true})
|
|
sm.animation:set_state(nil, true)
|
|
sm.animation:set_control()
|
|
sm.animstate:set_state(nil,true)
|
|
sm.animstate:set_control()
|
|
end
|
|
|
|
return
|
|
end
|
|
|
|
state_mgr.set_state(npc,"hide_na",nil,nil,{look_object = be and npc:see(be) and be or bdo},{fast_set = true})
|
|
elseif (st.stage == 2) then
|
|
if (npc:level_vertex_id() == st.lvid) then
|
|
st.stage = 1
|
|
return
|
|
end
|
|
state_mgr.set_state(npc,"assault",nil,nil,{look_object = dist <= 100 and nil or bdo})
|
|
utils_obj.send_to_nearest_accessible_vertex(npc,st.lvid)
|
|
end
|
|
end
|
|
|
|
local function script_action_danger_corpse(npc,st,bd,best_danger_object,dependent_object,bd_type)
|
|
--utils_data.debug_write("script_action_danger_corpse")
|
|
-- In this case corpse is best_danger_object; dependent_object should be killer or it's probably nil
|
|
local bdo = best_danger_object or dependent_object
|
|
|
|
local dst = db.storage[bdo:id()]
|
|
local killer = dependent_object or dst and dst.death_by_id and (db.storage[dst.death_by_id] and db.storage[dst.death_by_id].object)
|
|
|
|
-- force hostile to killer
|
|
if (st.stage >= 2 and killer and killer:id() == 0 and killer:alive() and npc:relation(killer) >= game_object.neutral and npc:see(killer)) then
|
|
local squad = get_object_squad(npc)
|
|
if (squad) then
|
|
for k in squad:squad_members() do
|
|
npc = db.storage[k.id] and db.storage[k.id].object or level.object_by_id(k.id)
|
|
if(npc) then
|
|
npc:force_set_goodwill( -1000, killer)
|
|
end
|
|
end
|
|
else
|
|
npc:force_set_goodwill( -1000, killer)
|
|
end
|
|
--printf("xr_danger.script_action_danger_corpse: forced enemies %s and %s",npc:name(), killer:name())
|
|
elseif (killer and killer:id() == 0 and killer:alive() and npc:relation(killer) < game_object.neutral) then
|
|
npc:make_object_visible_somewhen(killer)
|
|
end
|
|
|
|
--printf("stage = %s",st.stage)
|
|
if (st.stage == 1) then
|
|
if (math.random(1,100) < 50) then
|
|
st.stage = 3
|
|
end
|
|
end
|
|
|
|
if (st.stage == 1) then
|
|
st.lvid = bdo:level_vertex_id()
|
|
st.lvid = utils_obj.send_to_nearest_accessible_vertex(npc,st.lvid)
|
|
|
|
state_mgr.set_state(npc,"assault",nil,nil,{look_object = bdo}, {fast_set = true})
|
|
st.rnd = math_random(30)
|
|
|
|
st.stage = 2
|
|
elseif (st.stage == 2) then
|
|
if not (st.rnd and st.lvid) then
|
|
st.stage = 1
|
|
return
|
|
end
|
|
|
|
local dist = bdo and bdo:position():distance_to_sqr(npc:position()) or 0
|
|
if (st.lvid == npc:level_vertex_id() or dist <= st.rnd) then
|
|
local rnd = math_random(100)
|
|
if (rnd <= 33) then
|
|
xr_sound.set_sound_play(npc:id(),"search")
|
|
state_mgr.set_state(npc,"threat_danger",nil,nil,{look_position = dst and dst.killer_last_known_position})
|
|
st.dtimer = time_global() + math_random(3000,5000)
|
|
elseif (dist <= 5 and not st.searched) then
|
|
st.searched = true
|
|
state_mgr.set_state(npc,"search")
|
|
st.dtimer = time_global() + math_random(3000,5000)
|
|
else
|
|
state_mgr.set_state(npc,"raid",nil,nil,{look_position = dst and dst.killer_last_known_position}, {fast_set = true})
|
|
end
|
|
|
|
st.stage = 3
|
|
return
|
|
end
|
|
st.lvid = utils_obj.send_to_nearest_accessible_vertex(npc,st.lvid)
|
|
state_mgr.set_state(npc,"assault",nil,nil,{look_position = dst and dst.killer_last_known_position}, {fast_set = true})
|
|
elseif (st.stage == 3) then
|
|
if (st.dtimer and time_global() < st.dtimer) then
|
|
return
|
|
end
|
|
|
|
local dist_to_killer = dst and dst.killer_last_known_position and npc:position():distance_to_sqr(dst.killer_last_known_position) or 30
|
|
|
|
local new_vid = random_choice(utils_obj.try_to_strafe(npc),utils_obj.try_go_backward(npc,6),utils_obj.try_go_cover(npc,dst and dst.killer_last_known_position or bdo and bdo:position() or npc:position()))
|
|
|
|
if (new_vid and (not st.lvid or new_vid ~= st.lvid))then
|
|
st.lvid = new_vid
|
|
end
|
|
|
|
if not (new_vid) then
|
|
local dir = dst and dst.killer_last_known_position and vector():set(dst.killer_last_known_position):sub(npc:position()) or killer and vector():set(killer:position()):sub(npc:position()) or npc:direction()
|
|
local node = position_node(3)
|
|
node = node:select_best_vertex_id(npc,dir,npc:level_vertex_id(),10,dist_to_killer/2)
|
|
|
|
if (node and node.vertex_id and node.vertex_id ~= npc:level_vertex_id()) then
|
|
st.lvid = node.vertex_id
|
|
end
|
|
end
|
|
|
|
if (st.lvid) then
|
|
st.lvid = utils_obj.send_to_nearest_accessible_vertex(npc,st.lvid)
|
|
state_mgr.set_state(npc,"assault",nil,nil,{look_position = dst and dst.killer_last_known_position}, {fast_set = true})
|
|
st.stage = 4
|
|
return
|
|
end
|
|
st.dtimer = time_global() + math_random(5000,7000)
|
|
st.stage = 5
|
|
state_mgr.set_state(npc,"threat_danger",nil,nil,{look_position = dst and dst.killer_last_known_position}, {fast_set = true})
|
|
return
|
|
elseif (st.stage == 4) then
|
|
if (npc:level_vertex_id() == st.lvid) then
|
|
st.dtimer = time_global() + math_random(5000,7000)
|
|
st.stage = 5
|
|
state_mgr.set_state(npc,"hide_na",nil,nil,{look_position = dst and dst.killer_last_known_position}, {fast_set = true})
|
|
return
|
|
end
|
|
st.lvid = utils_obj.send_to_nearest_accessible_vertex(npc,st.lvid)
|
|
elseif (st.stage == 5) then
|
|
if (st.dtimer and time_global() < st.dtimer) then
|
|
return
|
|
end
|
|
st.lvid = nil
|
|
st.stage = 6
|
|
elseif (st.stage == 6) then
|
|
local new_vid = utils_obj.try_go_cover(npc,dst and dst.killer_last_known_position or bdo and bdo:position() or npc:position())
|
|
if (new_vid) then
|
|
st.lvid = utils_obj.send_to_nearest_accessible_vertex(npc,st.lvid)
|
|
state_mgr.set_state(npc,"hide_na",nil,nil,{look_position = dst and dst.killer_last_known_position or dst.object and dst.object:position()}, {fast_set = true})
|
|
end
|
|
end
|
|
end
|
|
|
|
local function script_action_danger_attacked(npc,st,bd,best_danger_object,dependent_object,bd_type)
|
|
--utils_data.debug_write("script_action_danger_attacked")
|
|
local bdo = dependent_object or best_danger_object
|
|
local tg = time_global()
|
|
|
|
--printf("stage = %s",st.stage)
|
|
if (st.stage == 1) then
|
|
|
|
if not (st.last_pos) then
|
|
st.last_pos = bdo and vector():set(bdo:position())
|
|
end
|
|
|
|
local dir = st.last_pos and vector():set(st.last_pos):sub(npc:position()) or vector():set(npc:direction())
|
|
local dist_to_bdo = st.last_pos and npc:position():distance_to_sqr(st.last_pos) or 30
|
|
|
|
local target_vertex_id = random_choice(utils_obj.try_to_strafe(npc),utils_obj.try_go_backward(npc,6),utils_obj.try_go_cover(npc,st.last_pos or npc:position()))
|
|
|
|
if (target_vertex_id) then
|
|
st.lvid = utils_obj.send_to_nearest_accessible_vertex(npc,target_vertex_id)
|
|
state_mgr.set_state(npc,"assault",nil,nil,{look_position = st.last_pos})
|
|
st.stage = 2
|
|
return
|
|
end
|
|
|
|
st.dtimer = tg + math_random(5000,6000)
|
|
st.stage = 3
|
|
return
|
|
elseif (st.stage == 2) then
|
|
if (npc:level_vertex_id() == st.lvid) then
|
|
st.dtimer = tg + math_random(5000,7000)
|
|
st.stage = 3
|
|
return
|
|
end
|
|
st.lvid = utils_obj.send_to_nearest_accessible_vertex(npc,st.lvid)
|
|
elseif (st.stage == 3) then
|
|
if (st.dtimer and tg < st.dtimer) then
|
|
state_mgr.set_state(npc,"threat_danger",nil,nil,{look_position = st.last_pos})
|
|
return
|
|
end
|
|
st.stage = 1
|
|
end
|
|
end
|
|
|
|
function action_danger:execute()
|
|
action_base.execute(self)
|
|
|
|
--utils_data.debug_write("BEFORE scripted_danger_action_planner",true)
|
|
local npc = self.object
|
|
|
|
local best_danger = npc:best_danger()
|
|
if not (best_danger) then
|
|
return
|
|
end
|
|
|
|
if (check_script_danger(npc:id())) then
|
|
script_action_danger_scripted(npc,self.a)
|
|
return
|
|
end
|
|
|
|
if (npc:path_type() ~= game_object.level_path) then
|
|
npc:set_path_type(game_object.level_path)
|
|
end
|
|
|
|
local best_danger_object = best_danger:object()
|
|
local bd_type = best_danger:type()
|
|
local dependent_object = best_danger:dependent_object()
|
|
|
|
if (bd_type == danger_object.grenade) then
|
|
script_action_danger_grenade(npc,self.a,best_danger,best_danger_object,dependent_object,bd_type)
|
|
elseif (bd_type == danger_object.entity_corpse) then
|
|
script_action_danger_corpse(npc,self.a,best_danger,best_danger_object,dependent_object,bd_type)
|
|
elseif (bd_type == danger_object.attacked) then
|
|
script_action_danger_attacked(npc,self.a,best_danger,best_danger_object,dependent_object,bd_type)
|
|
end
|
|
--utils_data.debug_write("AFTER scripted_danger_action_planner")
|
|
end
|
|
|
|
function action_danger:finalize()
|
|
self.a.stage = 1
|
|
if (self.a.last_state) then
|
|
state_mgr.set_state(self.object,self.a.last_state)
|
|
end
|
|
|
|
for k,v in pairs(db.used_level_vertex_ids) do
|
|
db.used_level_vertex_ids[k] = nil
|
|
end
|
|
|
|
self.a.__warning_shot_tmr = nil
|
|
utils_obj.send_to_nearest_accessible_vertex(self.object,self.object:level_vertex_id())
|
|
action_base.finalize(self)
|
|
end
|
|
|
|
----------------------------------------------------------------------------------------------------------------------
|
|
-- false - engine danger, true - script danger
|
|
----------------------------------------------------------------------------------------------------------------------
|
|
class "evaluator_check_danger" (property_evaluator)
|
|
function evaluator_check_danger:__init(name, storage) super (nil, name)
|
|
self.a = storage
|
|
end
|
|
function evaluator_check_danger:evaluate()
|
|
--utils_data.debug_write("eva_check_danger")
|
|
|
|
if (self.a.disable) then
|
|
return false
|
|
end
|
|
|
|
if not (IsStalker(self.object)) then
|
|
return false
|
|
end
|
|
|
|
if not (self.object:alive()) then
|
|
return false
|
|
end
|
|
|
|
if (self.object:best_enemy()) then
|
|
return false
|
|
end
|
|
|
|
if (IsWounded(self.object)) then
|
|
return false
|
|
end
|
|
|
|
if (character_community(self.object) == "zombied") then
|
|
return false
|
|
end
|
|
|
|
local bd = self.object:best_danger()
|
|
if not (bd) then
|
|
return false
|
|
end
|
|
|
|
local id = self.object:id()
|
|
if not (db.storage[id].danger_flag) then
|
|
return false
|
|
end
|
|
|
|
if (check_script_danger(id)) then
|
|
return true
|
|
end
|
|
|
|
local bd_type = bd:type()
|
|
if (self.object:has_info("npcx_is_companion") and bd_type == danger_object.entity_corpse) then
|
|
return false
|
|
end
|
|
|
|
if not (bd_type == danger_object.attacked or bd_type == danger_object.entity_corpse or bd_type == danger_object.grenade) then
|
|
return false
|
|
end
|
|
|
|
return true
|
|
end
|
|
class "position_node"
|
|
function position_node:__init(amt)
|
|
self.node = {}
|
|
for i=1,amt do
|
|
self.node[i] = {}
|
|
end
|
|
end
|
|
|
|
function position_node:select_best_vertex_id(object,dir,lvid,min_dist,max_dist,find_furthest)
|
|
local close
|
|
min_dist = min_dist and (min_dist <= max_dist and min_dist or max_dist) or 10
|
|
max_dist = max_dist and (max_dist >= min_dist and max_dist or min_dist) or 30
|
|
for i=1, #self.node do
|
|
local direction = vector_rotate_y(vec_set(dir), math_random(-180,180))
|
|
|
|
self.node[i].vertex_id = level.vertex_in_direction(lvid, direction, math_random(min_dist,max_dist) )
|
|
|
|
if (self.node[i].vertex_id and utils_obj.accessible(object,self.node[i].vertex_id) and self.node[i].vertex_id ~= lvid) then
|
|
self.node[i].distance = self.node[i].vertex_id == lvid and -1 or object:position():distance_to_sqr(level.vertex_position(self.node[i].vertex_id))
|
|
|
|
if not (close) then
|
|
close = i --self.node[i].vertex_id
|
|
end
|
|
|
|
if (close) then
|
|
if (find_furthest) then
|
|
if (self.node[close] and self.node[close].distance < self.node[i].distance) then
|
|
close = i
|
|
end
|
|
else
|
|
if (self.node[close] and self.node[i].distance < self.node[close].distance) then
|
|
close = i
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return close and self.node[close]
|
|
end
|
|
|
|
----------------------------------------------------------------------------------------------------------------------
|
|
-- BINDER
|
|
----------------------------------------------------------------------------------------------------------------------
|
|
function setup_generic_scheme(npc,ini,scheme,section,stype,temp)
|
|
local st = xr_logic.assign_storage_and_bind(npc,ini,"danger","danger",temp)
|
|
db.storage[npc:id()].danger_flag = false
|
|
db.storage[npc:id()].danger_flag_scripted = nil
|
|
end
|
|
|
|
function add_to_binder(npc,ini,scheme,section,storage,temp)
|
|
local manager = npc:motivation_action_manager()
|
|
|
|
manager:remove_evaluator(stalker_ids.property_danger)
|
|
manager:add_evaluator(stalker_ids.property_danger,evaluator_danger("danger", storage, npc))
|
|
manager:add_evaluator(evaid,evaluator_check_danger("script_danger",storage,npc))
|
|
|
|
local danger_action = manager:action(stalker_ids.action_danger_planner)
|
|
local danger_action_planner = cast_planner(danger_action)
|
|
|
|
danger_action_planner:remove_evaluator(stalker_ids.property_danger)
|
|
danger_action_planner:add_evaluator(stalker_ids.property_danger,evaluator_danger("danger", storage, npc))
|
|
|
|
local wp = world_property
|
|
|
|
danger_action:add_precondition( wp(evaid, false) )
|
|
|
|
temp.action = action_danger("danger", storage)
|
|
|
|
temp.action:add_precondition( wp(evaid, true) )
|
|
temp.action:add_precondition( wp(stalker_ids.property_danger, true) )
|
|
temp.action:add_effect( wp(evaid,false) )
|
|
--temp.action:add_effect( wp(stalker_ids.property_danger, false) )
|
|
|
|
manager:add_action(actid,temp.action)
|
|
end
|
|
|
|
function configure_actions(npc,ini,scheme,section,stype,temp)
|
|
local wp = world_property
|
|
|
|
temp.action:add_precondition( wp(stalker_ids.property_alive, true) )
|
|
temp.action:add_precondition( wp(stalker_ids.property_enemy, false) )
|
|
temp.action:add_precondition( wp(stalker_ids.property_anomaly, false) )
|
|
|
|
local manager = npc:motivation_action_manager()
|
|
local action
|
|
local p = {
|
|
xr_actions_id.alife,
|
|
--xr_actions_id.state_mgr + 1,
|
|
xr_actions_id.state_mgr + 2
|
|
}
|
|
|
|
for i=1,#p do
|
|
action = manager:action(p[i])
|
|
if (action) then
|
|
action:add_precondition( wp(evaid,false) )
|
|
else
|
|
printf("xr_danger: no action id p[%s]",i)
|
|
end
|
|
end
|
|
end
|
|
|
|
function reset_generic_scheme(npc,scheme,section,stype,st)
|
|
|
|
end
|