Скриптование

[Zander_driver 10 166]

4 часа назад, aromatizer сказал:

который за время появления статика срабатывал бы только один раз.

А где гарантии?

Время видимости статика не нормировано ничем. Он может появиться на один фрейм, а может провисеть полчаса. Медленный апдейт в этом случае лишь повысит шанс НЕобнаружения факта появления статика. Т.е. фича будет "работать через раз". Или вообще не работать.

2 часа назад, I am Dead сказал:

Ну покажи уж

Показывалось много раз... просто в данном случае, этот инструмент "не в тему".

Пост десятилетней давности, и там же его обсуждение, с предложениями аналогов от других авторов.

[aromatizer 4 278]

 Теперь то уж точно оптимизация в некоторых проектах улучшится... 

Изменено 18 Октября 2021 пользователем aromatizer

[I am Dead 892]

@aromatizer оффтоп, оптимизация посредством урезания как то звучит не очень... 

 

P. S Если намёк был на мои проекты - то я по максимуму везде стараюсь не мучать апдейт, задействовав другие каллбеки ( которых на огср достаточно много) оставив лишь самое необходимое что требует постоянной проверки. 

Изменено 18 Октября 2021 пользователем I am Dead

[Colder 12]

Подскажите в чем проблема. Пытаюсь вывести прогресс бар для каждого слота но не могу выровнить шкалу. Пишу так:

Скрытый текст

    local slots = {

    [1] = {100, 190},
    [2] = {330, 190},
    [4] = {330, 440},
    [6] = {170, 400},

    }

 

    for num, xy in pairs(slots) do
        local item = db.actor:item_in_slot(num)

        if item then
        local item_sect = item:section()
        local x, y, width, height, y_fix, x_fix, w_fix = axr_base.icon_new_pos(item_sect, num)

 

        --// окно
        local weapon_tex = CUIStatic()
        self:AttachChild(weapon_tex)

        local wnd_x, wnd_y = unpack(xy)
        weapon_tex:Init(wnd_x + x_fix, wnd_y + y_fix, w_fix * f_size, height * f_size)

 

        --// текстура
        weapon_tex:InitTexture("ui\\ui_icon_equipment")
        weapon_tex:SetStretchTexture(true)
        weapon_tex:SetOriginalRect(x, y, width, height)

 

        --// прогресс
        local wpn_condition_progress = 0
        local bar = xml:InitProgressBar("bar_frame", weapon_tex)
        wpn_condition_progress = item:condition()*100
        bar:SetProgressPos(wpn_condition_progress)

 

        -- имя
        local wnd_name = "repair_wpn_" .. num

        self:Register(xml:Init3tButton(wnd_name, self), wnd_name)
        self:AddCallback("repair_wpn_" ..num, ui_events.BUTTON_CLICKED, function() self:repair_wpn(num) end, self)

Скрытый текст

    <bar_frame_ x="50" y="50" width="56" height="5" horz="1" min="0" max="100" pos="1">
        <background>
            <texture>ui_cop_Game_progress_efficiency_full</texture>
        </background>
        <min_color r="86" g="196" b="209"/>
        <middle_color r="86" g="196" b="209"/>
        <max_color r="86" g="196" b="209"/>
    <progress>
        <texture>ui_cop_item_cond</texture>
    </progress>
    </bar_frame>

Итог: https://yadi.sk/i/AH1ZOpH45nyQXQ

[ted.80 223]

@Colder Привет мне кажется что всё дело вот в чём:

ты задаёшь координаты слотов

9 часов назад, Colder сказал:

 local slots = {

    [1] = {100, 190},
    [2] = {330, 190},
    [4] = {330, 440},
    [6] = {170, 400},

    }

а уже к ним привязываешь координаты прогресса

9 часов назад, Colder сказал:

 <bar_frame_ x="50" y="50"

соответственно получается где-то так

9 часов назад, Colder сказал:

 local slots = {

    [1] = {100 + 50, 190 + 50},
    [2] = {330 + 50, 190 + 50},
    [4] = {330 + 50, 440 + 50},
    [6] = {170 + 50, 400 + 50},

    }

 

[Colder 12]

Не помогло

[naxac 2 372]

@Colder , ну всё правильно выводится: на 50 пикселей правее левого края и на 50 ниже верхнего. А ты как задумывал? То есть, где надо, чтобы была шкала?

Изменено 27 Октября 2021 пользователем naxac

[Colder 12]

@naxac  Мне нужно выровнить шкалу! А не иконку.

Изменено 27 Октября 2021 пользователем Colder

[ted.80 223]

3 часа назад, Colder сказал:

Не помогло

Что именно не помогло?

я же сказал, что координаты прогресса у тебя жостко привязаны к координатам иконки,

и выводятся на 50 пихелей правее и 50 ниже - от левого верхнего угла иконки,

а так как иконки имеют разные размеры - нужно это учитывать!

либо сдвигать прогресс на дополнительное количество пихелей - относительно иконки - для каждой иконки, 

либо выводить прогресс по своим собственным координатам - не привязанных к иконке,

 

[Colder 12]

Вот я и не могу сдвинуть сам прогресс

[ted.80 223]

3 часа назад, Colder сказал:

Вот я и не могу

Простейший вариант - чтоб не плодить костыли и не писать кучу проверок и функций

Скрытый текст

	<bar_frame_1 x="50" y="50" width="56" height="5" horz="1" min="0" max="100" pos="1">
		<background>
			<texture>ui_cop_Game_progress_efficiency_full</texture>
		</background>
		<min_color r="86" g="196" b="209"/>
		<middle_color r="86" g="196" b="209"/>
		<max_color r="86" g="196" b="209"/>
		<progress>
			<texture>ui_cop_item_cond</texture>
		</progress>
	</bar_frame_1>
	
	<bar_frame_2 x="50" y="50" width="56" height="5" horz="1" min="0" max="100" pos="1">
		<background>
			<texture>ui_cop_Game_progress_efficiency_full</texture>
		</background>
		<min_color r="86" g="196" b="209"/>
		<middle_color r="86" g="196" b="209"/>
		<max_color r="86" g="196" b="209"/>
		<progress>
			<texture>ui_cop_item_cond</texture>
		</progress>
	</bar_frame_2>
	
	<bar_frame_4 x="50" y="50" width="56" height="5" horz="1" min="0" max="100" pos="1">
		<background>
			<texture>ui_cop_Game_progress_efficiency_full</texture>
		</background>
		<min_color r="86" g="196" b="209"/>
		<middle_color r="86" g="196" b="209"/>
		<max_color r="86" g="196" b="209"/>
		<progress>
			<texture>ui_cop_item_cond</texture>
		</progress>
	</bar_frame_4>
	
	<bar_frame_6 x="50" y="50" width="56" height="5" horz="1" min="0" max="100" pos="1">
		<background>
			<texture>ui_cop_Game_progress_efficiency_full</texture>
		</background>
		<min_color r="86" g="196" b="209"/>
		<middle_color r="86" g="196" b="209"/>
		<max_color r="86" g="196" b="209"/>
		<progress>
			<texture>ui_cop_item_cond</texture>
		</progress>
	</bar_frame_6>

 

делаем 4 прогресса - так можно двигать их независимо

 

а чтоб это заработало 

 

Скрытый текст

        --// прогресс
        local wpn_condition_progress = 0
        local bar = xml:InitProgressBar("bar_frame_"..num, weapon_tex)        ---- измени эту строку вот так
        wpn_condition_progress = item:condition()*100
        bar:SetProgressPos(wpn_condition_progress)

 

100% уверенности в работоспособности нет - так как не могу проверить

но вроде должно работать 

[mole venomous 2 989]

Всем привет. Ознакомился с возможностями движка ОГСР, но видимо недостаточно хорошо. 

Есть ли на этом движке возможность определить предмет на поясе и далее производить с ним какие-либо действия?

Т.е. речь не о проверке

local item = inventory.belt["item"]

а именно о том, что бы заданный объект можно было хитануть, удалить и т.п.

Изменено 28 Октября 2021 пользователем mole venomous

[naxac 2 372]

@mole venomous , можно сделать так:

local obj = db.actor:object("item")
if obj and db.actor:is_on_belt(obj) then
-- хитануть, удалить и т.п.
end

Или так (это подойдёт, если у актера может быть несколько предметов с секцией "item"):

local obj
for i = 0, db.actor:belt_count()-1 do
  obj = db.actor:item_on_belt(i)
  if obj and obj:section() == "item" then
  -- хитануть, удалить и т.п.
  end
end

Изменено 28 Октября 2021 пользователем naxac

[bastor 132]

Всем привет! Помогите разобраться. Хочу поместить в динамический худ мод NLC статик показателей ГГ . При вызове худа cтатик создается все работает но вот при закрытии удалить его ни как не получается. На get_hud():RemoveCustomStatic ни как не реагирует.

Скрытый текст

local function getSt(text, alpha, red, green, blue)
    alpha = (alpha<0 and 0) or (alpha>10 and 10) or alpha
    local param = 10 - math.floor(alpha + 0.5)
    text = string.sub(text, 1) .. string.format("%1.0f%%", alpha*10)
    alpha = 250 - param*10
    return {text, alpha, red, green, blue}
end

    local function show()
    local hud = get_hud()
    local custom_static
    local tbl = {
["actor_health"]  =    getSt("Здоровье:", db.actor.health *10,  0, 255,   0),                            
["actor_psy_health"] =getSt("Психика:", db.actor.psy_health    *10,   0, 250, 255),
["actor_satiety"] =   getSt("Голод:", 10 - db.actor.satiety    *10, 255, 155,   0),
["actor_radiation"] = getSt("Облучение:", db.actor.radiation    *10, 255, 255,   0),
["actor_sleep"] =   getSt("Усталость:", nlc_vars.gg_need_sleep    /25, 255, 255, 255),}
    for k,v in pairs(tbl) do
        custom_static = hud:GetCustomStatic(k)
        if custom_static == nil then
                 hud:AddCustomStatic(k, true)
        elseif v then
                    custom_static:wnd():SetText(v[1])
            custom_static:wnd():SetTextColor(v[2],v[3],v[4],v[5])
          end
    end
end

 

[Black_Raven_03 29]

@bastor, из очевидного: не вижу кода удаления статика, только добавления (я ж не телепат и не "крутой хацкер"!); также, если у тебя GetCustomStatic(k), то и RemoveCustomStatic должен иметь параметр-указатель кого-что удалять (не всё же подряд и не случайный!)

Изменено 31 Октября 2021 пользователем Black_Raven_03

[bastor 132]

1 час назад, Black_Raven_03 сказал:

должен иметь параметр-указатель кого-что удалять

Разобрался уже статик не удалялся потому что выполнялся внутри функции  худа вынес его в отдельный скрипт и все заработало.

[Капрал Хикс 461]

В общем, домучил я скрипт боевой схемы БТРа от Мишаня_Лютый aka CRAZY_STALKER666 + правки Graff46, чтобы машины корректно ехали к 1-й точке пути и при запрокидывании набок пытались восстановиться.

Скрытый текст

-----------------------------------------------------------------------------------------------------------------------
-- Physic vehicle control
-----------------------------------------------------------------------------------------------------------------------
-- Исходный скрипт: Evgeniy Negrobov (Jon) jon@gsc-game.kiev.ua
-- Перевод на xr_logic: Andrey Fidrya (Zmey) af@svitonline.com
-- Доработка для БТР: Oleg Kreptul (Haron) haronk@ukr.net
-- Доработки чтобы машины корректно ехали к 1-й точке пути и при запрокидывании набок пытались восстановиться: Graff46
-- Обновлённая боевая схема БТР - Мишаня_Лютый aka CRAZY_STALKER666. Old Episodes - Epilogue
-- ВНИМАНИЕ! Для монстров и сталкеров используются db.monster_stock и db.creature соответственно
-- Второе при желании можно перевести и на перебор цифрами, ничего не поменяется, но лагов будет больше
-----------------------------------------------------------------------------------------------------------------------
function printf()
end

local pi_2 = math.pi / 3 -- 60 degree
local def_min_delta_per_sec = 0.02

local def_min_car_explode_time = 1000
local def_moving_speed = 10
--local def_arriving_factor = 0.4
local def_arriving_dist = 1.0
local def_not_rotating_angle = 0.4
local def_min_fire_time = 0
local def_update_time = 1.6
local def_fire_range = 50

local def_max_fc_upd_num = 1000 -- default maximum fastcall updates num
local def_arriving_koef = 3 --70

local delay_after_ignition = 500

local state_none = 0

local state_moving_fwd = 1
local state_moving_rot_left = 2
local state_moving_rot_right = 3
local state_moving_stop = 4
local state_moving_end = 5

local state_cannon_rotate = 1
local state_cannon_follow = 2
local state_cannon_delay = 3
local state_cannon_stop = 4

local state_shooting_on = 1

local state_firetarget_points = 1
local state_firetarget_enemy = 2

class "action_car"

function action_car:__init(obj, storage)
    self.object = obj
    self.car = self.object:get_car()
    self.st = storage
        --вставка1
    self.friends = {}
end

function action_car:reset_scheme(loading)
    self.destroyed = false
    self.object:set_nonscript_usable(false)

    self.object:set_tip_text("")
    self.show_tips = self.st.show_tips
    self.tip_use = self.st.tip_use
    self.tip_locked = self.st.tip_locked

    if self.st.invulnerable then
        self.def_health = self.object.health
    end

    self.headlights = object.deactivate
    if self.st.headlights == "on" then
        self.headlights = object.activate
    end

    xr_logic.mob_capture(self.object, true)
    action(self.object, object("left_light",  self.headlights), cond(cond.time_end, time_infinite))
    xr_logic.mob_capture(self.object, true)
    action(self.object, object("right_light", self.headlights), cond(cond.time_end, time_infinite))

    self.usable = self.st.usable

    --if self.usable ~= nil then
    --    self.car_holder = self.object.get_current_holder() --engaged()
    --else
    if self.usable == nil then
        self.car:SetExplodeTime(0) -- (-1)

        if self.car:HasWeapon() then
        self.car:Action(CCar.eWpnActivate,1)
        self.hasWeapon = true
        else
            self.hasWeapon = false
        end

        if loading then
            self.speed = xr_logic.pstor_retrieve(self.object, "speed")
            self.loop = xr_logic.pstor_retrieve(self.object, "loop")
            self.min_delta_per_sec = xr_logic.pstor_retrieve(self.object, "min_delta_per_sec")
            self.min_car_explode_time = xr_logic.pstor_retrieve(self.object, "min_car_explode_time")
            self.state_moving = xr_logic.pstor_retrieve(self.object, "state_moving")
        else
            self.speed = def_moving_speed
            self.loop = false
            self.min_delta_per_sec = def_min_delta_per_sec
            self.min_car_explode_time = def_min_car_explode_time
            self.state_moving = state_none
        end

        --xr_logic.mob_capture(self.object, true)
        self.st.signals = {}

        self.fc_upd_num = 0 -- fastcall updates num
        self.fc_upd_avg = 10 -- average time of the fastcall updates (in millisecond)
        self.fc_last_upd_tm = -1 -- fastcall last update time

        self.last_pos = nil
        self.last_pos_time = 0

        self.state_delaying = false

        --self.state_moving = state_none

        self.target_walk_pt = -2
        -- path_walk
        if self.st.path_walk then
            self.path_walk = patrol(self.st.path_walk)
            if not self.path_walk then
                abort("object '%s': unable to find path_walk '%s' on the map", self.object:name(), self.st.path_walk)
            end

            self:start_car()
            self.path_walk_count = self.path_walk:count()

            self.target_walk_pt = 0--self:get_nearest_walkpoint() --= -1
            --if not self.path_walk_info then
            self.path_walk_info = utils.path_parse_waypoints(self.st.path_walk)
            if not self.path_walk_info then
                abort("object '%s': path_walk ('%s'): unable to obtain path_walk_info from path",
                    self.object:name(), self.st.path_walk)
            end
            --end

            self.arrival_signalled = false
            self.target_dist = -1

            if loading then
                self.target_walk_pt = xr_logic.pstor_retrieve(self.object, "target_walk_pt")
                if self.target_walk_pt == -1 then
                    self.target_walk_pt = self:get_nearest_walkpoint()
                end
            else
                self.target_walk_pt = self:get_nearest_walkpoint()
            end

            if self:at_target_walkpoint() then
                self:walk_arrival_callback(self.target_walk_pt)
            end

            self:go_to_walkpoint(self.target_walk_pt)
        else
            self.target_walk_pt = -2
            self.state_moving = state_moving_stop
        end

        self.state_firetarget = state_none
        self.state_cannon = state_none
        self.state_shooting = state_none

        self.target_fire_pt = nil
        self.target_fire_pt_idx = 0
        self.target_obj = nil

        self.on_target_vis = nil
        self.on_target_nvis = nil

        if self.hasWeapon then
            --if loading then
            --self.state_cannon = xr_logic.pstor_retrieve(self.object, "state_cannon")
            --self.state_shooting = xr_logic.pstor_retrieve(self.object, "state_shooting")
            --end

            self:set_shooting(self.state_shooting)

            local n = 0
            if self.st.fire_target == "points" then
                self.state_firetarget = state_firetarget_points
            else
                if self.st.fire_target == "actor" and db.actor:alive() then
                    self.target_obj = db.actor
                    self.state_firetarget = state_firetarget_enemy
                else
                    n = tonumber(self.st.fire_target)
                    if n then
                        obj = level_object_by_sid(n)
                        if obj and obj:alive() then
                            self.target_obj = obj
                            self.state_firetarget = state_firetarget_enemy
                        end
                    end
                end
                --if self.target_obj then
                --    self.target_ph_shell = self.target_obj:get_physics_shell()
                --end
            end
            self.fire_track_target = self.st.fire_track_target

            if self.st.on_target_vis then
                vis = self.st.on_target_vis
                if vis.v1 == "actor" then
                    vis.v1 = db.actor
                    self.on_target_vis = vis
                else
                    n = tonumber(vis.v1)
                    if n then
                        obj = level_object_by_sid(n)
                        if obj and obj:alive() then
                            vis.v1 = obj
                            self.on_target_vis = vis
                        end
                    end
                end
            end
            if self.st.on_target_nvis then
                nvis = self.st.on_target_nvis
                if nvis.v1 == "actor" then
                    nvis.v1 = db.actor
                    self.on_target_nvis = nvis
                else
                    n = tonumber(nvis.v1)
                    if n then
                        obj = level_object_by_sid(n)
                        if obj and obj:alive() then
                            nvis.v1 = obj
                            self.on_target_nvis = nvis
                        end
                    end
                end
            end

            self.path_fire = nil
            self.path_fire_info = nil
            self.fire_pt_count = 0
            self.def_fire_time = self.st.fire_time
            if self.st.fire_rep then
                if self.st.fire_rep == "inf" then
                    self.def_fire_rep = -1
                else
                    local c = tonumber(self.st.fire_rep)
                    self.def_fire_rep = if_then_else(c > 0, c, 0)
                end
            else
                self.def_fire_rep = 0
            end

            self.fire_rep = self.def_fire_rep
            self.fire_range_sqr = self.st.fire_range * self.st.fire_range

            -- path_fire
            if self.state_firetarget == state_firetarget_points and self.st.path_fire then
                self.path_fire = patrol(self.st.path_fire)
                if not self.path_fire then
                    abort("object '%s': unable to find path_fire '%s' on the map",
                        self.object:name(), self.st.path_fire)
                end

                if not self.path_fire_info then
                    self.path_fire_info = utils.path_parse_waypoints(self.st.path_fire)
                    if not self.path_fire_info then
                        abort("object '%s': path_fire ('%s'): unable to obtain path_fire_info from path",
                            self.object:name(), self.st.path_fire)
                    end
                end

                -- точки прострела для первой точки движения
                self:change_fire_pts()

                if self.st.auto_fire then
                    self.car:Action(CCar.eWpnAutoFire, 1)
                else
                    self.car:Action(CCar.eWpnAutoFire, 0)
                end

                self:fire_arrival_callback(self.target_fire_pt_idx)
                --self:rot_to_firepoint(self.target_fire_pt)
                --self:set_shooting(self.state_shooting)
            elseif self.state_firetarget == state_firetarget_enemy then
                self.state_shooting = state_none
                self.state_cannon = state_cannon_follow
                --self.target_fire_pt = db.actor:position()
                --self:rot_to_firepoint(self.target_fire_pt)
            else
                self.state_firetarget = state_none
                self.state_cannon = state_none
                self.state_shooting = state_none
            end
            --self:set_shooting(self.state_shooting)
        end

        --if self.st.path_walk then
        --    if self:at_target_walkpoint() and self.state_firetarget == state_none then
        --        self:walk_arrival_callback(self.target_walk_pt)
        --    end
        --    
        --    self:go_to_walkpoint(self.target_walk_pt)
        --end
        --printf("car <move>: start target_pt2 = %d", self.target_walk_pt)
    end

    self.object:set_fastcall(self.fastcall, self)
end

function action_car:save()
    if self.usable == nil then
        xr_logic.pstor_store(self.object, "speed", self.speed)
        xr_logic.pstor_store(self.object, "loop", self.loop)
        xr_logic.pstor_store(self.object, "min_delta_per_sec", self.min_delta_per_sec)
        xr_logic.pstor_store(self.object, "min_car_explode_time", self.min_car_explode_time)
        xr_logic.pstor_store(self.object, "state_moving", self.state_moving)
        xr_logic.pstor_store(self.object, "target_walk_pt", self.target_walk_pt) -- or -2)
    end
end

function action_car:get_nearest_walkpoint()
    return utils.get_nearest_waypoint(self.object, self.st.path_walk,
         self.path_walk, self.path_walk_count)
end

function action_car:get_next_walkpoint()
    if self.target_walk_pt >= 0 and self.target_walk_pt < self.path_walk_count - 1 then
        --printf("car <move>: action_car:get_next_walkpoint(%d)", self.target_walk_pt + 1)
        return self.target_walk_pt + 1
    elseif self.target_walk_pt == -1 or self.loop then
        --printf("car <move>: action_car:get_next_walkpoint(0)")
        return 0
    end
    --printf("car <move>: action_car:get_next_walkpoint(-2)")
    return -2
end

function action_car:at_target_walkpoint()
    if self.target_walk_pt == -2 then return true end

    local curVel = self.car:CurrentVel():magnitude()
    local dist = self.object:position():distance_to(self.path_walk:point(self.target_walk_pt))

    --local arrived = 2 * dist < def_update_time * (curVel.x + self.speed) --def_update_time > 2 * dist / (curVel.x + self.speed)
    --local arrived = dist < curVel.x * def_arriving_factor --8

    -- def_arriving_koef * self.fc_upd_avg / 1000 > 2 * dist / (curVel.x + self.speed)
    local arrived = false --2000 * dist < def_arriving_koef * self.fc_upd_avg * (curVel + self.speed)

    if self.fc_upd_avg < 100 then
        arrived = 2000 * dist < def_arriving_koef * self.fc_upd_avg * (curVel + self.speed)
        --printf("car <move>: check formula (%f < %f)", 2000 * dist, def_arriving_koef * self.fc_upd_avg * (curVel + self.speed))
        if arrived then
            --printf("car <move>: at target pt by formula.")
        end
    end

    if not arrived then
        local diff_angle = angle_xz(self.object, self.path_walk:point(self.target_walk_pt))
        --printf("car <move>: dist(%f), angle(%f).", dist, diff_angle)
        arrived = dist < 2 or diff_angle >= math.pi
        if arrived then
            --printf("car <move>: at target pt by dist(%f) and angle(%f).", dist, diff_angle)
            --printf("car <move>: at target pt by dist and angle.")
        end
    end

    local diff = dist - self.target_dist
    --printf("car <move>: dist = %f, target = %f, diff = %f, curVel = %f, speed = %f", dist, self.target_dist, diff, curVel, self.speed)
    if self.target_dist ~= -1 and not arrived then
        if diff > 0 then
            if diff > def_arriving_dist then
                arrived = true
                --printf("car <move>: at target pt by diff(%f).", diff)
            end
        else
            self.target_dist = dist
        end
    else
        self.target_dist = dist
    end
--[[
    --printf("car <move>: action_car:at_target_walkpoint(self.target_walk_pt=%d) = %d (arrived = %s)",        self.target_walk_pt, dist, utils.to_str(arrived))
    --if arrived then
        --printf("car <move>: arrived = %f > %f, dist(%f), diff(%f), curSpd(%f), spd(%f)",
               --def_arriving_koef * self.fc_upd_avg / 1000,
               --2 * dist / (curVel.x + self.speed),
               def_arriving_koef * self.fc_upd_avg * (curVel + self.speed),
               2000 * dist,
               dist, diff, curVel, self.speed)
        --printf("car <move>: arrived = %f < (%f,%f,%f) * %f, spd(%f)", dist, curVel.x, curVel.y, curVel.z, def_arriving_factor, self.speed)
    --end
--]]
    if arrived then
        self.target_dist = -1
    end
    return arrived
end

function action_car:go_to_walkpoint(pt)
    --action(self.object, object("left_light", object.activate), cond(cond.time_end, 1000))
    --action(self.object, object("right_light", object.activate), cond(cond.time_end, 1000))

    if self.state_delaying then
        if time_global() - self.delay_time_start >= delay_after_ignition then
            --printf("car <state>: stop delaying after ignition")
            self.state_delaying = false
        else
            --printf("car <state>: delaying after ignition")
            self.state_moving = state_moving_stop
            return
        end
    end

    if pt == nil or pt < 0 then
        if self.state_cannon ~= state_cannon_stop then
            self:stop_car()
            self.state_moving = state_moving_end
        end
        --printf("car <state>: pt < 0 or pt == nil")
        return
    end

    local diff_angle = angle_xz(self.object, self.path_walk:point(pt))
    local accel = move.none
    local curVel = self.car:CurrentVel():magnitude()
    --printf("car <move>: curVel = %f, speed = %f", curVel, self.speed)
    if curVel < self.speed then
        accel = move.fwd
        --printf("car <move>: forward")
    elseif curVel > self.speed * 1.15 or diff_angle >= math.pi then
        accel = move.back
        --printf("car <move>: backward")
    end
    --printf("car <move>: diff_angle = %f, katet = %f", diff_angle, get_katet(self.object, self.path_walk:point(pt)))
    --if utils.no_need_to_rotate_xz(self.object, self.path_walk:point(pt)) then
    if diff_angle < def_not_rotating_angle then
        if self.state_moving ~= state_moving_fwd and accel ~= move.none then
            --printf("car <move>: no_need_to_rotate. speed = %f, time = %f", self.speed, self.fc_upd_avg)
               xr_logic.mob_capture(self.object, true)
            action(self.object,
                move(accel, self.speed), --move.on + 
                --object("right_light", self.headlights),
                --object("left_light", self.headlights),
                cond(cond.time_end, time_infinite)) --self.fc_upd_avg))
            self.state_moving = state_moving_fwd
        end
    else
        -- Поворачиваться нужно, но в какую сторону?
        local rotate_left = utils.angle_left_xz(self.object:direction(), 
                                                utils.vector_copy_by_val(self.path_walk:point(pt)
                                                                        ):sub(self.object:position()))
        --printf("car <move>: must rotate: left? %s. speed = %f, time = %f", utils.to_str(rotate_left), self.speed, self.fc_upd_avg)
        if rotate_left then
            if self.state_moving ~= state_moving_rot_left then 
                xr_logic.mob_capture(self.object, true)
                action(self.object,
                    move(accel + move.left, self.speed), --move.on + 
                    --object("right_light", self.headlights),
                    --object("left_light", self.headlights),
                    cond(cond.time_end, time_infinite)) --self.fc_upd_avg))
                self.state_moving = state_moving_rot_left
            end
        else
            if self.state_moving ~= state_moving_rot_right then
                xr_logic.mob_capture(self.object, true)
                action(self.object,
                    move(accel + move.right, self.speed), --move.on +
                    --object("right_light", self.headlights),
                    --object("left_light", self.headlights),
                    cond(cond.time_end, time_infinite)) --self.fc_upd_avg))
                self.state_moving = state_moving_rot_right
            end
        end
    end
end

function action_car:start_car()
    xr_logic.mob_capture(self.object, true)
    action(self.object, move(move.on
    --+ move.fwd
    , 100), cond(cond.time_end, 5000))
    --self.speed = 0
    self.state_delaying = true
    self.delay_time_start = time_global()
end

function action_car:stop_car()
    self.state_delaying = false
    self.speed = 0
    xr_logic.mob_capture(self.object, true)
    action(self.object, move(move.off + move.handbrake, 0), cond(cond.time_end, 3000)) --cond(cond.move_end))
    --self.target_walk_pt = -1
end

function action_car:walk_arrival_callback(index)
    if index == -2 then return end

    local suggested_explode = self.path_walk_info[index]["explode"]
    if suggested_explode == "true" then
        --self:car_explode()
        self.object.health = 0
        self.car:Action(CCar.eWpnActivate, 0)
    end

    local suggested_spd = self.path_walk_info[index]["spd"]
    if suggested_spd then
        self.speed = tonumber(suggested_spd)
    else
        self.speed = def_moving_speed
    end

    local suggested_loop = self.path_walk_info[index]["loop"]
    if suggested_loop == "true" then
        self.loop = true
    else
        self.loop = false
    end

    local suggested_dps = self.path_walk_info[index]["dps"]
    if suggested_dps then
        self.min_delta_per_sec = tonumber(suggested_dps)
    else
        self.min_delta_per_sec = def_min_delta_per_sec
    end

    local suggested_exptm = self.path_walk_info[index]["exptm"]
    if suggested_exptm then
        self.min_car_explode_time = tonumber(suggested_exptm)
    else
        self.min_car_explode_time = def_min_car_explode_time
    end

    local sig = self.path_walk_info[index]["sig"]

    if sig then
        --self.st.signals[sig] = true
        self:set_signal(sig)
    end

    if self.hasWeapon and self.state_firetarget == state_firetarget_points then
        local next_idx = self:get_next_walkpoint()
        --local next_idx = self.target_walk_pt
        if next_idx >= 0 then
            local fw = self.path_walk_info[next_idx]["fw"]
            if fw then
                self.fire_wait = if_then_else(fw == "true", true, false)
            else
                self.fire_wait = false
            end

            local fr = self.path_walk_info[next_idx]["fr"]
            if fr then
                if fr == "inf" then
                    self.fire_rep = -1
                else
                    local c = tonumber(fr)
                    self.fire_rep = if_then_else(c > 0, c, 0)
                end
            else
                self.fire_rep = self.def_fire_rep
            end
        else
            self.fire_wait = false
            self.fire_rep = self.def_fire_rep
        end
    end

    -- Выбрать следующую точку езды:
    self.target_walk_pt = self:get_next_walkpoint()
    --if not self.target_walk_pt then
    --    self:stop_car()
        -- Остановить машину
        --if self.state_cannon == state_cannon_stop then
        --    xr_logic.mob_capture(self.object, true)
        --end
        --action(self.object, move(move.off, 0), cond(cond.time_end, 1000))
        --self.state_moving = state_moving_end
    --    return
    --end

    if self.target_walk_pt >= 0 then
        -- Если эта точка рядом и уже приехали - не ждать апдейта, чтобы вызвать callback
        if self:at_target_walkpoint() then
            self:walk_arrival_callback(self.target_walk_pt)
        else
            --self.target_dist = -1
            self:go_to_walkpoint(self.target_walk_pt)
        end
    else
        self.target_walk_pt = -2
        if self.state_moving ~= state_moving_stop and self.state_moving ~= state_moving_end then
            self:stop_car()
            self.state_moving = state_moving_end
        end
    end
end

function action_car:change_fire_pts()
    self.state_cannon = state_none
    self.state_shooting = state_none
    self.fire_pt_arr = {}
    self.fire_pt_count = 0
    self.target_fire_pt_idx = 0
    self.target_fire_pt = nil
    self.fire_rot_dir = 1
    self.fire_start_time = 0

    if not self.path_fire then return end

    local fire_idx
    if self.target_walk_pt >= 0 then
        -- Значение флагов огневых точек, котые будем искать:
        local fire_flags = self.path_walk_info[self.target_walk_pt].flags

        if fire_flags:get() == 0 then
            return
        end

        local this_val
        for fire_idx = 0, self.path_fire:count() - 1 do
            this_val = self.path_fire_info[fire_idx].flags
            if this_val:equal(fire_flags) then
                table.insert(self.fire_pt_arr, fire_idx)
                self.fire_pt_count = self.fire_pt_count + 1
            end
        end
    else
        for fire_idx = 0, self.path_fire:count() - 1 do
            table.insert(self.fire_pt_arr, fire_idx)
        end
        self.fire_pt_count = self.path_fire:count()
    end

    print_table(self.fire_pt_arr)

    if self.fire_pt_count == 0 then
        self.state_cannon = state_cannon_stop
        return
    end

    --if self.fire_pt_count > 0 then
    --    self.target_fire_pt_idx = 0
    --    self.target_fire_pt = self.path_fire:point(self.fire_pt_arr[0])
    --end
end

function action_car:get_next_firepoint()
    if self.fire_pt_count < 1 then return nil end

    local pt_idx
    if self.target_fire_pt_idx > 0 then -- not first time
        if self.fire_pt_count > 1 then -- we have at least 2 point to switch
            pt_idx = self.target_fire_pt_idx + self.fire_rot_dir
            if (pt_idx < 1 or pt_idx > self.fire_pt_count) then
                self.fire_rot_dir = -self.fire_rot_dir -- change rotate direction [-1,1]
                --printf("car <fire>: changing direction")
                if self.fire_rep == -1 then
                    pt_idx = self.target_fire_pt_idx + self.fire_rot_dir
                elseif self.fire_rep > 0 then
                    pt_idx = self.target_fire_pt_idx + self.fire_rot_dir
                    self.fire_rep = self.fire_rep - 1
                else
                    pt_idx = 0
                end
            end
        elseif self.fire_rep == -1 then -- left same point in the infinity loop
            pt_idx = 1
        elseif self.fire_rep > 0 then -- left same point if loop defined
            pt_idx = 1
            self.fire_rep = self.fire_rep - 1
        end
    else
        pt_idx = 1
    end
    --self.target_fire_pt_idx = pt_idx

    if pt_idx > 0 then
        return pt_idx, self.path_fire:point(self.fire_pt_arr[pt_idx])
    end

    self.state_firetarget = state_none
    return pt_idx, nil
end

function action_car:rot_to_firepoint(pt)
--[[
    if pt then
        self.car:SetParam(CCar.eWpnDesiredPos, pt)
    end
    --printf("car <fire>: action_car:rot_to_firepoint(%d)", shooting)
    self.car:Action(CCar.eWpnFire, shooting)
--]]
    if self.target_fire_pt then
    --    self.state_cannon = state_cannon_rotate
        self.car:SetParam(CCar.eWpnDesiredPos, self.target_fire_pt)
        --printf("car <fire>: action_car:rot_to_firepoint(%d)", self.target_fire_pt_idx)
    --else
    --    self.state_cannon = state_cannon_stop
    end
end

function action_car:set_shooting(shooting)
    self.car:Action(CCar.eWpnFire, shooting)
end

function action_car:fire_arrival_callback(cur_index)
    if self.fire_pt_count < 1 or self.state_cannon == state_cannon_stop then return end

    if self.state_cannon == state_cannon_delay then
        -- Выбрать следующую точку езды:
        self.target_fire_pt_idx, self.target_fire_pt = self:get_next_firepoint()

        if self.target_fire_pt then
            self.state_cannon = state_cannon_rotate
            if self.fire_rot_dir == 1  and self.fire_forward or
               self.fire_rot_dir == -1 and self.fire_backward then
               self.state_shooting = state_shooting_on
            else
                self.state_shooting = state_none
            end
            self:rot_to_firepoint(self.target_fire_pt)
            self:set_shooting(self.state_shooting)
        else
            self.state_cannon = state_cannon_stop
            if self.state_shooting ~= state_none then
                self.state_shooting = state_none
                self:set_shooting(self.state_shooting)
                self:set_signal("fire_end")
            end
        end
        return
    end

    if cur_index > 0 then
        local idx = self.fire_pt_arr[cur_index]

        local ff = self.path_fire_info[idx]["ff"]
        if ff then
            self.fire_forward = if_then_else(ff == "true", true, false)
        else
            self.fire_forward = false
        end

        local fb = self.path_fire_info[idx]["fb"]
        if fb then
            self.fire_backward = if_then_else(fb == "true", true, false)
        else
            self.fire_backward = false
        end

        local f = self.path_fire_info[idx]["f"]
        if f then
            self.state_shooting = if_then_else(f == "true", state_shooting_on, state_none)
        else
            self.state_shooting = if_then_else(self.st.auto_fire, state_shooting_on, state_none)
        end

        local ft = self.path_fire_info[idx]["ft"]
        if ft then
            self.fire_time = tonumber(ft)
        else
            self.fire_time = self.def_fire_time
        end
    else
            self.fire_forward = false
            self.fire_backward = false
            self.state_shooting = if_then_else(self.st.auto_fire, state_shooting_on, state_none)
            self.fire_time = def_min_fire_time
    end

    if self.fire_time > 0 then

    self.state_cannon = state_cannon_delay
        self.fire_start_time = time_global()
        --self:rot_to_firepoint(nil)
        self:set_shooting(self.state_shooting)
    else
        -- Выбрать следующую точку стрельбы:
        self.target_fire_pt_idx, self.target_fire_pt = self:get_next_firepoint()

        -- Если мы уже целимся в эту точку - не ждать апдейта, чтобы вызвать callback
        if self.target_fire_pt then
            self.state_cannon = state_cannon_rotate
            if self.fire_rot_dir == 1  and self.fire_forward or
               self.fire_rot_dir == -1 and self.fire_backward then
                self.state_shooting = state_shooting_on
            else
                self.state_shooting = state_none
            end
            self:rot_to_firepoint(self.target_fire_pt)
            self:set_shooting(self.state_shooting)
        else
            self.state_cannon = state_cannon_stop
            if self.state_shooting ~= state_none then
                self.state_shooting = state_none
                self:set_shooting(self.state_shooting)
                self:set_signal("fire_end")
            end
        end
    end
end

function action_car:set_signal(sig)
    local stor = db.storage[self.object:id()]
    stor[stor.active_scheme].signals[sig] = true
end

function angle_xz(npc, target_pos)
    local dir1 = npc:direction()
    dir1.y = 0
    local dir2 = utils.vector_copy_by_val(target_pos):sub(npc:position())
    dir2.y = 0
    local dp = dir1:dotproduct(dir2)
    if dp < 0 then
        return math.pi - yaw(dir1, dir2)
    end
    return yaw(dir1, dir2)
end

function get_katet(npc, target_pos)
    local p = utils.vector_copy_by_val(target_pos):sub(npc:position())
    local q = npc:direction()
    local k = p.x * q.x + p.y * q.y
    if k ~= 0 then
        return target_pos:distance_to(npc:position()) * (p.x * q.y - p.y * q.x) / k
    end
    return -1
end

function action_car:fastcall()
    if db.storage[self.object:id()].active_scheme ~= "ph_car" then
        -- Если активная схема - не машина, снять быстрый апдейт
        return true
    end

    if self.usable ~= nil then
        local cu = xr_logic.pick_section_from_condlist(db.actor, self.object, self.usable.condlist)
        local u = (cu == "true" or cu == "")

        if u then
            if self.show_tips and self.tip_use then
                self.object:set_tip_text(self.st.tip_use)
            end
        elseif self.show_tips and self.tip_locked then
            self.object:set_tip_text(self.st.tip_locked)
        end

        self.object:set_nonscript_usable(u)

        return false
    end

    return self:fast_update()
end

function action_car:update(delta)
        --вставка2
    self:update_friends_and_target()

    if xr_logic.try_switch_to_another_section(self.object, self.st, db.actor) then
        return
    end

    if self.destroyed then
        xr_logic.switch_to_section(self.object, self.st, "nil")
        return
    end

    if self.st.invulnerable then
        self.object.health = self.def_health
    end
end

function action_car:destroy_car()
    self.state_moving = state_moving_end
    self:stop_car()
    self.state_cannon = state_none
    self.state_firetarget = state_none
    self.state_shooting = state_none
    self.car:Action(CCar.eWpnAutoFire, 0)
    self:set_shooting(self.state_shooting)

        --turn off lights
    xr_logic.mob_capture(self.object, true)
    action(self.object, object("left_light",  object.deactivate), cond(cond.time_end, time_infinite))
    xr_logic.mob_capture(self.object, true)
    action(self.object, object("right_light", object.deactivate), cond(cond.time_end, time_infinite))

    xr_logic.mob_release(self.object)
    if self.st.on_death_info ~= nil then
        db.actor:give_info_portion(self.st.on_death_info)
    end
        --вставка3
    if self.st.on_death_func then
        loadstring(self.st.on_death_func)()
    end
        --вставка3
    self.destroyed = true
end

-- Вернуть true, если апдейты больше не нужны
function action_car:fast_update()
    --if not self.object:action() then
    --printf("_pc: CAR EXPLODE")
    --self.object:explode(0)
    --self.object:Explode()
    --end

    if self.car:GetfHealth() <= 0 then
        --printf("car <state>: killed.")
        --self:car_explode()
        self:destroy_car()
        return true
    end

    local cur_time = time_global()

    if self.fc_upd_num < def_max_fc_upd_num then
        local last_upd = self.fc_last_upd_tm
        if last_upd ~= -1 then
            local n = self.fc_upd_num
            if n < 3000 then
                self.fc_upd_avg = (self.fc_upd_avg * n + (cur_time - last_upd))/(n + 1)
                self.fc_upd_num = n + 1
            else
                self.fc_upd_num = 1
            end
        end
        self.fc_last_upd_tm = cur_time
    end

    if self.state_moving == state_moving_end and
       self.state_cannon == state_cannon_stop and
       self.state_firetarget == state_none
    then
        if xr_logic.mob_captured(self.object) and not self.object:action() then
            xr_logic.mob_release(self.object)
            if self.st.on_death_info ~= nil then
                db.actor:give_info_portion(self.st.on_death_info)
            end

            self:destroy_car()
            return true -- апдейты больше не нужны
        end
        return false
    end

    if self.state_moving ~= state_moving_end and
       self.state_moving ~= state_moving_stop and 
       cur_time >= self.last_pos_time + self.min_car_explode_time
    then
        if not self.last_pos then
            self.last_pos = self.object:position()
            self.last_pos_time = cur_time
        else
            local cur_pos = self.object:position()
            local diff = self.last_pos:distance_to(cur_pos)
            if diff < self.min_delta_per_sec then -- застряли?
                if math.abs(self.object:direction().y) > 0.35 then
                    if self.object:direction().x < 0 then self.turn = move.right else self.turn = move.left end

                    xr_logic.mob_capture(self.object, true)
                    action(self.object,
                        move(move.fwd + self.turn, self.speed), 
                        cond(cond.time_end, time_infinite))
                    self.state_moving = state_moving_rot_right
                else
                    self:stop_car()
                    --self:car_explode()
                    self.state_moving = state_moving_end
                    --return false
                    end
            else
                self.last_pos = cur_pos
            end
            self.last_pos_time = cur_time
        end
    end

    if self.state_moving ~= state_moving_end and
       self.state_moving ~= state_none
    then
        --printf("car <move>: try")
        if self.target_walk_pt >= 0 then
            if self:at_target_walkpoint() then
                --printf("car <move>: at target point")
                -- если нет флага ожидания стрельбы или мы уже отстрелялись или пошли в цикле обратно
                if not self.fire_wait or self.state_cannon == state_cannon_stop then --self.fire_rot_dir == -1 then
                        --printf("car <move>: car go to the new point.")
                        -- Прибыли, выбрать новую точку
                        self:walk_arrival_callback(self.target_walk_pt)
                        --printf("car <move>: new target = %s", utils.to_str(self.target_walk_pt))
                        -- меняем точки отстрела
                        self:change_fire_pts()
                else
                    --printf("car <move>: 1.car stopped.")
                    if self.state_moving ~= state_moving_stop then
                        self:stop_car()
                    end
                    self.state_moving = state_moving_stop
                end
            else
                --printf("car <move>: car keep going.")
                --get_console():execute(self.object:direction().z.."_"..self.object:direction().x.."_"..self.object:direction().y)
                if math.abs(self.object:direction().y) < 0.35 then
                    self:go_to_walkpoint(self.target_walk_pt)-- Продолжать ехать, или поворачиваться
                end
            end
        else
            --printf("car <move>: 2.car stopped.")
            if self.state_cannon ~= state_cannon_stop then
                self:stop_car()
                self.state_moving = state_moving_stop
            end
        end
    end

    if self.hasWeapon then
        --printf("car <fire>: target(%d)", self.state_firetarget)
        if self.on_target_vis and self.on_target_vis.v1:alive() and self.car:IsObjectVisible(self.on_target_vis.v1) then
            --printf("car <vis>: try")
            local new_section = xr_logic.pick_section_from_condlist(db.actor, self.object, self.on_target_vis.condlist)
            if new_section then
                --printf("car <vis>: switch to section [%s]", new_section)
                xr_logic.switch_to_section(self.object, self.st, new_section)
            end
        end

        if self.on_target_nvis and self.on_target_nvis.v1:alive() and not self.car:IsObjectVisible(self.on_target_nvis.v1) then
            --printf("car <nvis>: try")
            local new_section = xr_logic.pick_section_from_condlist(db.actor, self.object, self.on_target_nvis.condlist)
            if new_section then
                --printf("car <nvis>: switch to section [%s]", new_section)
                xr_logic.switch_to_section(self.object, self.st, new_section)
            end
        end

        if self.state_firetarget == state_firetarget_points then
            if self.fire_pt_count > 0 and self.state_cannon ~= state_cannon_stop then
                --printf("car <fire>: shooting points")
                if self.state_cannon == state_cannon_delay then
                    if self.fire_start_time + self.fire_time < cur_time then
                        --printf("car <fire>: stop delaying(%.2f + %.2f < %.2f)", self.fire_start_time, self.fire_time, time_global())
                        --printf("car <fire>: 1.new fire point.")
                        self:fire_arrival_callback(self.target_fire_pt_idx)
                    else
                        --printf("car <fire>: delaying(%.2f + %.2f < %.2f)", self.fire_start_time, self.fire_time, cur_time)
                    end
                else
                    if self.car:CanHit() or self.target_fire_pt_idx == 0 then
                        --printf("car <fire>: 2.new fire point.")
                        -- Прибыли, выбрать новую точку
                        self:fire_arrival_callback(self.target_fire_pt_idx)
                    end
                end
            end
        elseif self.state_firetarget == state_firetarget_enemy then
                        --вставка4
            local target_dist = self.object:position():distance_to_sqr(self.target_obj:position())
            local has_friends_on_fire_line = self:check_friends_on_fire_line()

            if self.target_obj:alive() and
               target_dist <= self.fire_range_sqr and
               self.car:IsObjectVisible(self.target_obj) and
                not has_friends_on_fire_line
            then
                self.target_fire_pt = self:extrapolate_pos(self.target_obj)
                self:rot_to_firepoint(self.target_fire_pt)
                        --вставка4

                if self.car:CanHit() then
                    if self.state_shooting == state_none then
                        self.state_shooting = state_shooting_on
                        self:set_shooting(self.state_shooting)
                        --self:set_signal("fire_start")
                    end

                else
                    if self.state_shooting ~= state_none then
                        self.state_shooting = state_none
                        self:set_shooting(self.state_shooting)
                        --self:set_signal("fire_end")
                    end
                end
            else
                if self.state_shooting ~= state_none then
                    self.state_shooting = state_none
                    self:set_shooting(self.state_shooting)
                    --self:set_signal("fire_end")
                end

                if self.fire_track_target then
                self.target_fire_pt = self:extrapolate_pos(self.target_obj)
                    self:rot_to_firepoint(self.target_fire_pt)
                end
            end
        end
    end
    return false
end

--вставка5
function action_car:extrapolate_pos(obj)
    local mypos = self.object:position()
    if not self.prev_pos then
    self.prev_pos = obj:bone_position("bip01_spine1")
    self.prev_delta = vector():set(0,0,0)
  end
    local curpos = obj:bone_position("bip01_spine1")
    local hcorr = mypos:distance_to_sqr(curpos)/180/180*1.3
    local delta = obj:bone_position("bip01_spine1"):sub(self.prev_pos)
    self.prev_delta:mul(1):add(delta):mul(0.5)
    local extrapos = vector():set(self.prev_delta.x,self.prev_delta.y,self.prev_delta.z):mul(10):add(curpos):add(vector():set(0,hcorr,0))
    self.prev_pos = curpos
    return extrapos
end
--вставка5

function action_car:car_explode()
    self.object:explode(time_global())
end

function action_car:net_destroy()
    --self:destroy_car()
    if self.object and xr_logic.mob_captured(self.object) then
        xr_logic.mob_release(self.object)
        if self.st.on_death_info ~= nil then
            db.actor:give_info_portion(self.st.on_death_info)
        end
            --вставка6
        if self.st.on_death_func then
            loadstring(self.st.on_death_func)()
        end
      end
            --вставка6
end

--вставка7
function action_car:check_friends_on_fire_line()
    if self.target_fire_pt then
        local pos = self.object:bone_position("mashine_gun_fire_point")
        local dir_aim = vector():set(self.target_fire_pt.x - pos.x, self.target_fire_pt.y - pos.y , self.target_fire_pt.z - pos.z)
        local target_dist = pos:distance_to(self.target_obj:position())
        --проверяем позиции солдат и текущего сектора обстрела
        for a,v in pairs(self.friends) do
            tmp = level.object_by_id(a)
            if tmp and tmp:alive() then
                local pos_soldier = tmp:position()
                local radius = 4
                if v=="vehicle_btr" then
                    radius = 4
                else
                    radius = 1.7
                end
                local friend_dist=self.object:position():distance_to(pos_soldier)-radius

                if friend_dist < target_dist then
                    --считаем попадает ли текущий солдат в сектор обстрела
                    local dir_soldier = vector():set(pos_soldier.x - pos.x, pos_soldier.y - pos.y , pos_soldier.z - pos.z)
                    local x = dir_soldier.x*dir_aim.x+dir_soldier.z*dir_aim.z
                    local y = -dir_soldier.z*dir_aim.x+dir_soldier.x*dir_aim.z -- повернули систему координат
                    local angle = math.atan2(y,x) -- угол доворота от -180 до 180
                    local div = radius/friend_dist
                    if angle >= -div and angle <= div then return true end
                end
            end
        end
    end

    return false
end

function action_car:update_friends_and_target()
        if self.st.fire_target == "monsters" then
                for k in pairs(db.monster_stock) do
            local obj = level.object_by_id(k)
                if obj and IsMonster(obj) and obj:alive() and self.car:IsObjectVisible(obj) then
                    self.target_obj = obj
                    self.state_firetarget = state_firetarget_enemy
                        end
                    end
                end

               --изъят блок с вариантом стрельбы БТРов по ведролётам
        if self.st.fire_target == "stalker_group" then

        --for a=1,65534,1 do
        --local obj = level.object_by_id(a)
                for k in pairs(db.creature) do
            local obj = level.object_by_id(k)

            if obj and IsStalker(obj) and obj:alive()
                       and obj:character_community()=="stalker"
                       and self.car:IsObjectVisible(obj) then
                   self.target_obj = obj
                   self.state_firetarget = state_firetarget_enemy
                       end
                    end
                end
end
--вставка7

function add_to_binder(npc, ini, scheme, section, storage)
    local new_action = action_car(npc, storage)

    -- Зарегистрировать все actions, в которых должен быть вызван метод reset_scheme при изменении настроек схемы:
    xr_logic.subscribe_action_for_events(npc, storage, new_action)
end

function set_scheme(npc, ini, scheme, section, gulag_name)
    local st = xr_logic.assign_storage_and_bind(npc, ini, scheme, section)

    st.logic = xr_logic.cfg_get_switch_conditions(ini, section, npc)
    st.usable = xr_logic.cfg_get_condlist(ini, section, "usable", npc)
    if st.usable == nil then
        st.path_walk         = utils.cfg_get_string(ini, section, "path_walk",       npc, false, gulag_name)
        st.path_fire         = utils.cfg_get_string(ini, section, "path_fire",       npc, false, gulag_name, nil)
        st.auto_fire         = utils.cfg_get_bool(ini,   section, "auto_fire",       npc, false, false)
        st.fire_time         = utils.cfg_get_number(ini, section, "fire_time",       npc, false, def_min_fire_time)
        st.fire_rep          = utils.cfg_get_string(ini, section, "fire_repeat",     npc, false, gulag_name, nil)
        st.fire_range        = utils.cfg_get_number(ini, section, "fire_range",      npc, false, def_fire_range)
        st.fire_target       = utils.cfg_get_string(ini, section, "target",          npc, false, gulag_name, "points")
        st.fire_track_target = utils.cfg_get_bool(ini,   section, "track_target",    npc, false, false)

        st.on_target_vis    = xr_logic.cfg_get_string_and_condlist(ini, section, "on_target_vis", npc)
        st.on_target_nvis   = xr_logic.cfg_get_string_and_condlist(ini, section, "on_target_nvis", npc)

        st.path_walk_info   = nil -- Будут инициализированы в reset(), сейчас пути могут быть еще не загружены.
        st.path_fire_info   = nil
    else
        st.show_tips    = utils.cfg_get_bool(ini,   section, "show_tips",  npc, false, true)
        st.tip_use      = utils.cfg_get_string(ini, section, "tip_use",    npc, false, "", "tip_car_use")
        st.tip_locked   = utils.cfg_get_string(ini, section, "tip_locked", npc, false, "", "tip_car_locked")
    end

    st.invulnerable     = utils.cfg_get_bool(ini,   section, "invulnerable",    npc, false, false)
    st.headlights       = utils.cfg_get_string(ini, section, "headlights",      npc, false, gulag_name, "off")
    st.on_death_info    = utils.cfg_get_string(ini, section, "on_death_info",   npc, false, gulag_name, nil)
        --вставка8
    st.on_death_func    = utils.cfg_get_string(ini, section, "on_death_func",   npc, false, gulag_name, nil)
end

Ну и к нему:

Скрытый текст

--[[---------------------------------------------------------------
База данных живых онлайновых объектов, зон и рестрикторов, актёра
Чугай Александр
Апдейт под нужды R.M.A.
Апдейт под нужды логики работы БТР
-----------------------------------------------------------------]]
zone_by_name        = {}
sl_by_name          = {}
storage             = {}
sound               = {}
actor               = nil
actor_proxy         = actor_proxy.actor_proxy()
heli                = {}
camp_storage        = {}
story_by_id        = {}
smart_terrain_by_id = {}
trader            = nil
info_restr          = {}
strn_by_respawn     = {}
creature        = {}    -- true - человек, false - животное (исключая торговца)
monster_stock       = {}

FlagEsc = 0
Flag2 = 0
Dead2 = 0

function add_obj( obj )
    if IsStalker(obj) then
        creature[obj:id()] = true
    elseif IsMonster(obj) then
        monster_stock[obj:id()] = true
    end
end

function del_obj( obj )
    storage   [obj:id()] = nil
    if IsStalker(obj) then
        creature[obj:id()] = nil
    elseif IsMonster(obj) then
        monster_stock[obj:id()] = nil
    end
end

function add_zone( zone )
    zone_by_name[zone:name()] = zone
    add_obj( zone )
end

function del_zone( zone )
    zone_by_name[zone:name()] = nil
    del_obj( zone )
end

function add_sl( sl )
    sl_by_name[sl:name()] = sl
    add_obj( sl )
end

function del_sl( sl )
    sl_by_name[sl:name()] = nil
    del_obj( sl )
end

function add_actor( obj )
    actor = obj
    actor_proxy:net_spawn( obj )
    add_obj( obj )
end

function del_actor()
    del_obj( actor )
    actor_proxy:net_destroy()
    actor = nil
end

function add_heli(obj)
    heli[obj:id()] = obj
end

function del_heli(obj)
    heli[obj:id()] = nil
end

function add_smart_terrain( obj )
    smart_terrain_by_id[obj.id] = obj
end

function del_smart_terrain( obj )
    smart_terrain_by_id[obj.id] = nil
end

Знаю, что косо, криво, коряво и пр., но оно работает, вроде как без вылетов. БТР может стрелять по ГГ, монстрам или группировкам.

[Pir@t@s 33]

День добрый товарищи. У меня вопрос, вот какого плана: Как установить метку на предмет, если использовать «Рандомный спавн объектов» от тов. Singapur22?

Пример функции:

function my_spawn()
local tbl = {
{129.204,-6.337,-12.101,427496,133},
{101.002,-7.632,-4.966,398683,116},
{106.678,-7.494,8.702,406288,118}
}
local items = {
'af_medusa',
'af_vyvert',
'af_blood'
}       
xr_effects.uni_random_spawn(items, tbl, kol)
end

 

[I am Dead 892]

@Pir@t@s Функцию из xr_effects покажи

[Pir@t@s 33]

@I am Dead https://disk.yandex.ru/d/QTFcsaIC8tGV2g

И прощу прощения, забыл указать: Игра ТЧ 1.0006@I am Dead