Revive Teammates

Место свободно

Здесь вы сможете купить рекламу на данном форуме

Стоимость за 1 день 12 ₽

Установка: Разместите файлы согласно директории архива
Файлы с исходным кодом (что находятся в папке scripting/ их следует скомпилировать, чтобы получить .amxx файлы)
После чего разместите скомпилированные файлы в amxmodx/plugins/
В plugins.ini добавлять не нужно. Все плагины (+ описание к ним) находятся в plugins-revive_teammates.ini

Настройка

{
    "RT": "The last configuration auto-change was on 2026.08.20 - 21:12:28",
    "VERSION": "3.4.79",
    "AUTHOR": "@emmajule",
    "INFO": {
        "#": "Значение квара",
        "description": "Описание квара",
        "min": "Минимальное допустимое значение",
        "max": "Максимальное допустимое значение"
    },
    "rt_core.amxx": {
        "chat_prefix": {
            "#": "[!gRevive!n]",
            "description": [
                "Приставка для чат сообщений",
                "!n - Стандартный цвет",
                "!t - Цвет команды",
                "!g - Зеленый"
            ]
        },
        "duration": {
            "#": 3,
            "description": [
                "Время действия процесса воскрешения",
                "Используйте 0 для мнгновенного действия (достаточно только нажать кнопку)"
            ],
            "min": 0,
            "max": 10
        },
        "box_size": {
            "#": "-16.0 -16.0 -36.0 16.0 16.0 36.0",
            "description": [
                "Размер объекта (хитбокс)",
                "Созданная сущность в игре имеет размеры куба 6 проекций (сверху сбоку сзади спереди слева справо)",
                "Сам труп принимает свойство кнопки (радиус отлова 128 units)"
            ]
        }
    },
    "rt_misc.amxx": {
        "next_use": {
            "#": 0.7,
            "description": "Время после которого игрок вновь сможет использовать кнопку содействия с трупом (+use)",
            "min": 0.1,
            "max": 5
        },
        "catch_mode": {
            "#": 1,
            "description": [
                "Метод поиска трупа",
                "0 - Отлов первого попавшегося трупа в радиусе",
                "1 - Отлов трупа с максимально близкой дистанцией к игроку"
            ]
        },
        "fake_client": {
            "#": 0,
            "description": "Взаимодействие с ботами!"
        }
    },
    "rt_effects.amxx": {
        "progress_bar": {
            "#": 1,
            "description": "Процесс воскрешения будет сопровождатся полоской по центру эркана"
        },
        "observer_force_camera": {
            "#": 0,
            "description": "Камера автоматически перенаправит мертвого игрока на того, кто его воскрешает"
        },
        "dynamic_light": {
            "#": 0,
            "description": [
                "Подсветка трупа",
                "Может быть полезно в темных местах",
                "Внимание: может вызывать нагрузку из-за особенностей свечения движка!"
            ]
        },
        "alert_flags": {
            "#": "c",
            "description": [
                "Уведомления при поднятии",
                "a - в чат",
                "b - по центру экрана",
                "c - HUD (плавное сообщение)",
                "Примечание: можно использовать посовместно",
                "'' или 0 - отключено"
            ]
        },
        "respawn_sound": {
            "#": "",
            "description": "Звук когда игрок возродился"
        },
        "respawn_sound_listen": {
            "#": 0,
            "description": [
                "Кто будет слышать этот звук?",
                "0 - все игроки",
                "1 - только игрок",
                "2 - все кто в команде игрока"
            ]
        },
        "loot_start_sound": {
            "#": "",
            "description": "Звук при старте возрождения мертвого товарища"
        },
        "loot_start_sound_listen": {
            "#": 0,
            "description": [
                "Кто будет слышать этот звук?",
                "0 - все игроки",
                "1 - только игрок",
                "2 - все кто в команде игрока"
            ]
        },
        "loot_stop_sound": {
            "#": "",
            "description": "Звук прекращения связи с этим игроком"
        },
        "loot_stop_sound_listen": {
            "#": 0,
            "description": [
                "Кто будет слышать этот звук?",
                "0 - все игроки",
                "1 - только игрок",
                "2 - все кто в команде игрока"
            ]
        },
        "revive_notification": {
            "#": 1,
            "description": [
                "Уведомление о воскрешении товарища",
                "0 - Нет",
                "1 - Всем",
                "2 - Только команде",
                "3 - Только трупу и тому кто его поднимал"
            ]
        },
        "screenfade_loot": {
            "#": 0,
            "description": "Эффект свечения (блик) экрана в момент воскрешения"
        },
        "screenfade_loot_color": {
            "#": "50 200 75",
            "description": [
                "Цвет этого блика",
                "Используется формат RGB (пример: 250 250 0)"
            ]
        },
        "screenfade_loot_color_alpha": {
            "#": 150,
            "description": "Степень прозрачности блика",
            "min": 0,
            "max": 255
        },
        "screenfade_respawn": {
            "#": 0,
            "description": "Эффект свечения (блик) экрана для только воскрешенного игрока"
        },
        "screenfade_respawn_color": {
            "#": "0 200 0",
            "description": [
                "Цвет этого блика",
                "Используется формат RGB (пример: 250 250 0)"
            ]
        },
        "screenfade_respawn_alpha": {
            "#": 150,
            "description": "Степень прозрачности блика",
            "min": 0,
            "max": 255
        },
        "corpse_glow_t": {
            "#": 0,
            "description": "Все трупы команды TERRORIST покрыты цветной оболочкой"
        },
        "corpse_glow_t_color": {
            "#": "",
            "description": [
                "Цвет этой обводки",
                "Используется формат RGB (пример: 250 250 0)"
            ]
        },
        "corpse_glow_ct": {
            "#": 0,
            "description": "Все трупы команды CT покрыты цветной оболочкой"
        },
        "corpse_glow_ct_color": {
            "#": "",
            "description": [
                "Цвет этой обводки",
                "Используется формат RGB (пример: 250 250 0)"
            ]
        },
        "corpse_glow_loot": {
            "#": 0,
            "description": "При использовании трупа, в это время он будет иметь цветную оболочку!"
        },
        "corpse_glow_loot_color": {
            "#": "",
            "description": [
                "Цвет этой обводки",
                "Используется формат RGB (пример: 250 250 0)"
            ]
        }
    },
    "rt_bonuses.amxx": {
        "frags": {
            "#": 0,
            "description": "Фрагов за поднятие тиммейта (в статистику не зачтется!)"
        },
        "restore_deathpoint": {
            "#": 0,
            "description": "Обнулить очко смерти воскрешенному игроку (в статистике не изменится!)"
        },
        "spawn_health": {
            "#": 0,
            "description": [
                "Количество здоровья с которым появится воскрешенный игрок",
                "Используйте 0, тогда будет использоваться 100 как обычно"
            ],
            "min": 0
        },
        "give_kevlar": {
            "#": 0,
            "description": [
                "Выдавать броню?",
                "0 - Нет",
                "1 - Бронижелет",
                "2 - Бронижелет с каской"
            ],
            "min": 0,
            "max": 2
        },
        "health_limit": {
            "#": 0,
            "description": [
                "Новое здоровье не привысит максимальное здоровье игрока",
                "Допустим по умолчанию максимальное здоровье 100, бонусное здоровье не сможет привысить этот параметр",
                "Это также будет учитывать некоторые плагины по типу хилки, шприц.."
            ]
        },
        "give_health": {
            "#": 0,
            "description": "Количество бонусного здоровья за поднятие тиммейта"
        },
        "protection": {
            "#": 0,
            "description": [
                "Защита после спавна (в секундах)",
                "В этот период воскрешенного игрока не смогут убить!"
            ],
            "max": 5
        },
        "reward": {
            "#": 0,
            "description": [
                "Награда за поднятие тиммейта",
                "Вы можете также использовать значение с минусом, тогда это напротив будет считаться как оплатой за поднятие"
            ]
        },
        "reward_type": {
            "#": 0,
            "description": [
                "Выберите тип награды:",
                "0 - обычные деньги игры [$]",
                "1 - anew очки от BonusMenu RBS",
                "2 - anew очки от Army Ranks Ultimate",
                "3 - опыт от Army Ranks Ultimate",
                "4 - опыт от AES (fork Sonyx либо от serfreeman1337)",
                "5 - anew очки от AES (fork Sonyx либо от serfreeman1337)"
            ],
            "min": 0,
            "max": 5
        },
        "reward_message": {
            "#": 0,
            "description": "Игрок получит уведомление в чат, о том что он получил награду за воскрешение!"
        },
        "weapons": {
            "#": "",
            "description": [
                "Список оружий с которым заспавнится воскрешенный игрок",
                "Вводите через пробел и без weapon_",
                "При бездействии квара игрок получает по стандарту пистолет и нож как обычно.",
                "Имеется поддержка Ultimate Weapons (для этого указывайте оружия через ultimate_)"
            ]
        }
    },
    "rt_restrictions.amxx": {
        "flag": {
            "#": "",
            "description": [
                "Флаг(и) доступа к возрождению мертвых товарищей по команде!",
                "0 или '' - Для всех"
            ]
        },
        "corpse_flag": {
            "#": "",
            "description": [
                "Только игроки с этим флагом(ами) будет иметь кастомный труп",
                "В противном случае труп будет стандартным (недоступен для действий плагина)",
                "0 или '' - Все будут"
            ]
        },
        "team_allow": {
            "#": 0,
            "description": [
                "Какая команда получит доступ к возрождению товарищей по команде",
                "0 - могут все!",
                "1 - исключительно игроки команды TERRORIST",
                "2 - исключительно игроки команды CT"
            ],
            "max": 2
        },
        "max_spawns": {
            "#": 0,
            "description": "Если игрок уже возрождался более чем Х раз в этом раунде, тогда его уже нельзя будет возродить этим плагином!"
        },
        "max_usage": {
            "#": 2,
            "description": [
                "Сколько максимально 1 игрок может возродить союзников за раунд",
                "0 - неограниченное число раз."
            ]
        },
        "block_attack": {
            "#": 0,
            "description": "Игрок не сможет стрелять в момент содействия с трупом"
        },
        "min_round": {
            "#": 0,
            "description": "Использовать труп станет возможным только с Х раунда! (до этого будет спавнить обычные трупы)"
        },
        "round_ended": {
            "#": 0,
            "description": "Невозможно использовать труп после окончания раунда!"
        },
        "bomb": {
            "#": 0,
            "description": "Нельзя использовать труп когда бомба уже установленна"
        },
        "water_level": {
            "#": 0,
            "description": [
                "Нельзя использовать если уровень воды игрока",
                "0 - можно всегда",
                "1 - ноги в воде",
                "2 - по пояс в воде",
                "3 - полностью в воде"
            ]
        },
        "on_ladder": {
            "#": 0,
            "description": "Игрок не может использовать труп когда находится на лестнице"
        },
        "vip_person": {
            "#": 0,
            "description": [
                "VIP-персона не может использовать трупы",
                "Это работает на сценарии 'Спасти VIP' [as_* карты]"
            ]
        },
        "min_players": {
            "#": 0,
            "description": [
                "Сколько должно быть игроков на сервере для возможности возрождений!",
                "0 - работает всегда!"
            ]
        },
        "min_players_exclude": {
            "#": "",
            "description": [
                "Кого не стоит учитывать при подсчете игроков?!",
                "a - не считать зрителей",
                "b - не считать ботов"
            ]
        },
        "pvp": {
            "#": 0,
            "description": [
                "Игроки не могут использовать трупы когда остались 1 на 1",
                "0 - могут",
                "1 - не могут",
                "2 - не могут когда уже остался 1 игрок в любой из команд"
            ]
        },
        "players_difference": {
            "#": 0,
            "description": [
                "Нельзя использовать трупы если перевес живых игроков превышет этот квар",
                "Примечание: это не коснется команды которая в меньшинстве!",
                "0 - выключает эту возможность"
            ]
        },
        "domination": {
            "#": 0,
            "description": [
                "Доминирующая команда не может использовать трупы!",
                "Это касается сильной команды которая одерживает Х побед подряд!"
            ]
        },
        "time_expired": {
            "#": 0,
            "description": "Использование трупа работает, если от начала раунда прошло более чем Х сек.",
            "max": 60
        },
        "time_remaining": {
            "#": 0,
            "description": "Нельзя использовать труп за Х сек. до конца раунда",
            "max": 120
        },
        "can_jump": {
            "#": 1,
            "description": "Игрок может прыгать в момент использования трупа"
        },
        "can_duck": {
            "#": 1,
            "description": "Игрок может сидеть/присаживатся в момент использования трупа"
        },
        "maxspeed": {
            "#": 0,
            "description": [
                "Скорость игрока в момент использования трупа",
                "1 - стоит на месте",
                "0 - без изменений!"
            ],
            "min": 0
        },
        "maxspeed_force": {
            "#": 0,
            "description": [
                "Скорость игрока будет постоянно обновляться!",
                "Используйте если другие плагины могут мешать, меняя скорость игрока!"
            ]
        },
        "hold_use": {
            "#": 0,
            "description": [
                "Игрок должен удерживать E (+use) чтобы использовать труп",
                "0 - Достаточно просто нажать!"
            ]
        },
        "view_cone": {
            "#": 0,
            "description": "Игрок может взаимодействовать с трупом, только если он в зоне видимости его экрана"
        },
        "bad_hitzones": {
            "#": "0",
            "description": [
                "Игрок получит стандартный труп, если он был убит:",
                "a - по умолчанию (generic)",
                "b - в голову",
                "c - в грудь",
                "d - в живот",
                "e - в левую руку",
                "f - в правую руку",
                "g - в левую ногу",
                "h - в правую ногу",
                "Примечание: Буквы можно использовать совместно!"
            ]
        },
        "full_restrictions": {
            "#": 0,
            "description": "Некоторые запреты и ограничения будут действовать и на другие отношения по мимо командных!"
        }
    },
    "rt_respawn_features.amxx": {
        "spot": {
            "#": 1,
            "description": [
                "Место спавна воскрешенного игрока",
                "0 - На респе",
                "1 - На том месте где погиб (заспавнен труп)"
            ]
        },
        "unstuck": {
            "#": 0,
            "description": [
                "Автоматический поиск свободной точки, рядом с местом смерти!",
                "Используйте, если вы наблюдаете проблемы при спавне путем застревания в каком-нибудь обьекте"
            ]
        },
        "unstuck_ignore_monsters": {
            "#": 0,
            "description": [
                "Не считать монстров как за препятствующий обьект.",
                "Это может быть полезно, если у вас имеется возможность прохождения сквозь игроков"
            ]
        }
    },
    "rt_model_support.amxx": {
        "skin_support": {
            "#": 0,
            "description": [
                "Поддержка субмоделей",
                "Активируйте если вы используете субмодели (pev->skin) в моделях игроков"
            ]
        },
        "cl_minmodels_support": {
            "#": 0,
            "description": [
                "Поддержка клиентов с активным кваром cl_minmodels 1",
                "Обратите внимание что функция не совместима если вы спользуете эффект цветной оболочки у трупов!"
            ]
        },
        "CPM_support": {
            "#": 0,
            "description": [
                "Поддержка плагина Custom Player Models от BlackSignature (только от версии 0.0.24 и выше)",
                "Подробности: https://hlds.run/resources/182/"
            ]
        },
        "size_from_file": {
            "#": 0,
            "description": "Будет брать размеры объекта напрямую с файла модели, если это возможно"
        },
        "corpse_model_te": {
            "#": "",
            "description": [
                "Модель трупа для команды TERRORIST",
                "Все игроки этой команды будут иметь единую модель с этой настройки!"
            ]
        },
        "corpse_model_te_entity": {
            "#": 0,
            "description": [
                "Модель будет отдельно от трупа",
                "0 - Изменения будут на сам труп!"
            ]
        },
        "corpse_model_te_body": {
            "#": 0,
            "description": "Номер субмодели (pev->body)"
        },
        "corpse_model_te_skin": {
            "#": 0,
            "description": "Номер субмодели (pev->skin)"
        },
        "corpse_model_te_sequence": {
            "#": -1,
            "description": "Номер проигрываемой анимации модели (если используется)"
        },
        "corpse_model_te_sprite_frame": {
            "#": -1,
            "description": [
                "Номер кадра (pev->frame)",
                "Может быть полезно, если вы используете спрайт вместо модели."
            ]
        },
        "corpse_model_te_sprite_scale": {
            "#": 0,
            "description": "Размер спрайта"
        },
        "corpse_model_te_offset_Z": {
            "#": 0,
            "description": [
                "Поднятие модели согласно позиции Z",
                "Используйте отрицательное значение чтобы напротив опустить!"
            ]
        },
        "corpse_model_ct": {
            "#": "",
            "description": [
                "Модель трупа для команды CT",
                "Все игроки этой команды будут иметь единую модель с этой настройки!"
            ]
        },
        "corpse_model_ct_entity": {
            "#": 0,
            "description": [
                "Модель будет отдельно от трупа",
                "0 - Изменения будут на сам труп!"
            ]
        },
        "corpse_model_ct_body": {
            "#": 0,
            "description": "Номер субмодели (pev->body)"
        },
        "corpse_model_ct_skin": {
            "#": 0,
            "description": "Номер субмодели (pev->skin)"
        },
        "corpse_model_ct_sequence": {
            "#": -1,
            "description": "Номер проигрываемой анимации модели (если используется)"
        },
        "corpse_model_ct_sprite_frame": {
            "#": -1,
            "description": [
                "Номер кадра (pev->frame)",
                "Может быть полезно, если вы используете спрайт вместо модели."
            ]
        },
        "corpse_model_ct_sprite_scale": {
            "#": 0,
            "description": "Размер спрайта"
        },
        "corpse_model_ct_offset_Z": {
            "#": 0,
            "description": [
                "Поднятие модели согласно позиции Z",
                "Используйте отрицательное значение чтобы напротив опустить!"
            ]
        }
    },
    "rt_mined_enemies.amxx": {
        "flag": {
            "#": "",
            "description": [
                "Флаг(и) доступа к минированию врагов!",
                "0 или '' - Для всех"
            ]
        },
        "team_allow": {
            "#": 0,
            "description": [
                "Какая команда получит доступ к минированию вражеских трупов",
                "0 - могут все!",
                "1 - исключительно игроки команды TERRORIST",
                "2 - исключительно игроки команды CT"
            ],
            "max": 2
        },
        "max_usage": {
            "#": 2,
            "description": "Сколько максимально сможет минировать трупов 1 игрок за раунд"
        },
        "mined_mode": {
            "#": 0,
            "description": [
                "Режим активации взрыва:",
                "0 - после процесса (когда враг закончит процесс поднятия товарища)",
                "1 - моментально (сразу как враг начал поднимать товарища)",
                "2 - дистанционно (все заминированные трупы игрока взорвутся, после того как игрок нажал дважды E)"
            ]
        },
        "progress_bar": {
            "#": 1,
            "description": "Полоска прогресса минирования"
        },
        "progress_duration": {
            "#": 0,
            "description": [
                "Время минирования трупа",
                "Оставьте 0, если хотите чтоб оно было таким же как и время на поднятие товарища!"
            ]
        },
        "radius": {
            "#": 350,
            "description": "Максимальный допустимый радиус поражения",
            "min": 64
        },
        "damage": {
            "#": 250,
            "description": "Урон от взрыва",
            "min": 10
        },
        "pain_velmod": {
            "#": 0,
            "description": "'Болевой шок' если игрок выжил от полученного урона",
            "min": 0,
            "max": 1
        },
        "pain_knockback": {
            "#": 0,
            "description": "Сила отброса, если игрок выжил от полученного урона"
        },
        "gibs": {
            "#": 0,
            "description": [
                "Игроки которые умерли от взрыва заминированного игрока, превратятся в ошметки",
                "Примечание: при такой смерти труп игрока не создается, т.е его не смогут поднять вражеские товарищи.."
            ]
        },
        "damage_from_radius": {
            "#": 1,
            "description": "Урон будет зависить от радиуса, чем дальше игрок тем меньше урона он получит"
        },
        "mined_bypass": {
            "#": 0,
            "description": "Заминированный труп можно заминировать вновь, если тот, кто его заминировал - покинул сервер!"
        },
        "mined_owner": {
            "#": 0,
            "description": "Заминированный труп будет активен только, если на сервере присутствует тот, кто его заминировал"
        },
        "remove_corpse": {
            "#": 1,
            "description": [
                "Что делать с трупом после взрыва?",
                "1 - удалить",
                "0 - оставить как есть (он снова будет заминирован)",
                "-1 - оставить как есть и убрать метку минирования (он снова будет доступен для минирования/воскрешения)"
            ]
        },
        "mined_sound": {
            "#": "weapons/c4_disarm.wav",
            "description": "Звук при успешном минировании трупа!"
        },
        "explode_effects": {
            "#": 1,
            "description": "Эффекты взврыва при детонации заминированного трупа"
        },
        "explode_sprite": {
            "#": "sprites/fexplo.spr",
            "description": [
                "Спрайт взрыва!",
                "Используйте 0 или '' - если хотите полностью исключить звук!"
            ]
        },
        "sprite_count": {
            "#": 2,
            "description": "Количество спрайтов которые будут проиграны вокруг цели",
            "min": 1
        },
        "sprite_scale": {
            "#": 30,
            "description": "Размер спрайта"
        },
        "sprite_offset": {
            "#": 0,
            "description": [
                "Оффсет поднятия спрайта от стартовой позиции в мире",
                "Используйте отрицательное значение, тогда это будет напротив, опускать спрайт!"
            ]
        },
        "explode_sound": {
            "#": "",
            "description": [
                "Звук взрыва трупа!",
                "При пустом значении или '0' будет использоваться стандартный звук взрыва гранаты.",
                "Используйте 'off' - если хотите полностью исключить звук!"
            ]
        },
        "alert_flags": {
            "#": "c",
            "description": [
                "Уведомления при минировании",
                "a - в чат",
                "b - по центру экрана",
                "c - HUD (плавное сообщение)",
                "Примечание: можно использовать посовместно (abc)",
                "'' или 0 - отключено"
            ]
        }
    },
    "rt_life_time.amxx": {
        "file": {
            "#": "sprites/revive.spr",
            "description": [
                "Спрайт для показа",
                "В спрайте присутствуют кадры (frames) для показа количества секунд.",
                "Можно оставить пустым, тогда будет просто работать как отсчет времени до исчезновения!"
            ]
        },
        "spawn_time": {
            "#": 3,
            "description": [
                "Время, после которого начнет действовать таймер",
                "0 - сразу при создании трупа"
            ]
        },
        "destroy_time": {
            "#": 30,
            "description": [
                "Время через которое труп исчезнет!",
                "Плагин использует кадры (картинки) которые указанны в спрайте для показа отсчета посекундно"
            ]
        },
        "corpse_fade_effect": {
            "#": 0,
            "description": [
                "Труп будет плавно исчезать по истечению времени",
                "Обратите внимание, что могут быть конфликты если вы используете функцию подсветки трупов!"
            ]
        },
        "step_time": {
            "#": 1,
            "description": "Интервал между каждым новым кадром (то-есть это может быть не обязательно секунда)"
        },
        "offset_Z": {
            "#": 16,
            "description": [
                "На сколько юнит поднять спрайт над трупом",
                "Используйте отрицательное значение, если напротив хотите опустить"
            ]
        },
        "scale": {
            "#": 0.15,
            "description": "Размер спрайта"
        },
        "team": {
            "#": 0,
            "description": [
                "Действие команд",
                "0 - Работает для всех",
                "1 - Не работает для команды TERRORIST",
                "2 - Не работает для команды CT"
            ],
            "min": 0,
            "max": 2
        },
        "flag": {
            "#": "",
            "description": [
                "Игроки с этим флагом(ами) не будут подвержены действиям таймера!",
                "0 или '' - Плагин действует для всех!"
            ]
        }
    },
    "rt_ghost_mode.amxx": {
        "disable_scenario": {
            "#": 1,
            "description": "Этот плагин будет блокировать обычный способ взаимодействия с трупом через клавишу E"
        },
        "force_camera": {
            "#": 1,
            "description": [
                "Камера будет автоматически в режиме свободного полета",
                "Переключать режимы камеры будет невозможно!"
            ]
        },
        "max_invites": {
            "#": 0,
            "description": [
                "Сколько максимально раз за раунд можно вселятся в трупы",
                "0 - Неограниченное кол-во раз."
            ]
        },
        "frequency": {
            "#": 0.2,
            "description": "Частота времени между новым поиском трупов"
        },
        "screenfade": {
            "#": 1,
            "description": "Экран игрока будет подвсечен в режиме призрака!"
        },
        "fov": {
            "#": 120,
            "description": "Поле дальности зрения игрока в режиме призрака!",
            "max": 180
        },
        "speed": {
            "#": 800,
            "description": [
                "Скорость камеры в режиме призрака!",
                "0 - по стандарту! (согласно sv_spectatormaxspeed)"
            ]
        },
        "relationship": {
            "#": 4,
            "description": [
                "Призрак может вселится",
                "0 - только в свой труп",
                "1 - в любой труп своей команды",
                "2 - в любой труп своей команды, кроме своего",
                "3 - во все трупы",
                "4 - во все трупы, кроме своего"
            ]
        },
        "can_revive": {
            "#": 0,
            "description": "Не позволяет вселятся в трупы которые уже в процессе воскрешения"
        }
    }
}

Исходный код: [spoiler title=rt_core.sma][code]#include <amxmisc>
#include <fakemeta>
#include <hamsandwich>
#include <reapi>
#include <xs>

#include <revive_teammates_const>

// Cvars
new rt_prefix[48];
new rt_size[64];
new Float:rt_duration;

// Forwarsd
new g_iForward_Parse_File;
new g_iForward_Loot_Pre;
new g_iForward_Loot_Post;
new g_iForward_Loot_Ended;
new g_iForward_Loot_Think;
new g_iForward_StartSneaking;
new g_iForward_StopSneaking;
new g_iForward_Player_Spawn_Post;
new g_iForward_Relation_Conditions;
new g_iForward_Return;

// Vars
new Float:g_VecMins[3], Float:g_VecMaxs[3];
new g_pEntity[33], g_pCorpse[33];

// new Trie:g_tCvars;
new FreeForAll;
new g_fSpawned;

public plugin_natives()
{
register_library("revive_teammates");

register_native("RT_GetPrefix", "Native_RT_GetPrefix");
register_native("RT_GetCorpse", "Native_RT_GetCorpse");
register_native("RT_DeleteCorpse", "Native_RT_DeleteCorpse");
register_native("RT_Attachment", "Native_RT_Attachment");
register_native("RT_fSpawned", "Native_RT_fSpawned");

register_native("RT_GoAction", "Native_RT_GoAction");
register_native("RT_BreakAction", "Native_RT_BreakAction");

register_native("RT_RelationStatus", "Native_RT_RelationStatus");

// Backwards only
register_native("RT_Get_Relation", "Native_RT_Get_Relation");
register_native("RT_Set_Relation", "Native_RT_Set_Relation");
}

public plugin_precache()
{
register_plugin("[WIP] Revive Die Players", RT_VERSION_STR, "@emmajule");
register_dictionary("revive_teammates.txt");

// td: cvar controller
g_iForward_Parse_File = CreateMultiForward("RT_ParseConfigFile", ET_IGNORE, FP_CELL);

if (!parseJSON()) {
set_fail_state("Something went wrong! Check configuration file settings!");
}
}

public plugin_init()
{
register_event("TeamInfo", "Event_TeamInfo", "a", "1>0");
register_message(get_user_msgid("ClCorpse"), "Messsage_ClCorpse");
register_cvar("Revive Teammates", RT_VERSION_STR, FCVAR_SERVER | FCVAR_SPONLY);

RegisterHookChain(RG_CBasePlayer_Killed, "CBasePlayer_Killed", false);
// RegisterHam(Ham_ObjectCaps, "info_target", "CBaseEntity_ObjectCaps", false);
RegisterHam(Ham_StopSneaking, "info_target", "CPointEntity_StopSneaking", true);

DestroyForward(g_iForward_Parse_File);
g_iForward_Loot_Pre = CreateMultiForward("RT_StartLoot_Pre", ET_CONTINUE, FP_CELL, FP_CELL, FP_CELL);
g_iForward_Loot_Post = CreateMultiForward("RT_StartLoot_Post", ET_IGNORE, FP_CELL, FP_CELL, FP_CELL, FP_FLOAT);
g_iForward_Loot_Ended = CreateMultiForward("RT_StopLoot", ET_CONTINUE, FP_CELL, FP_CELL, FP_CELL, FP_CELL);
g_iForward_Loot_Think = CreateMultiForward("RT_ThinkLoot", ET_CONTINUE, FP_CELL, FP_CELL, FP_CELL, FP_FLOAT);
g_iForward_StartSneaking = CreateMultiForward("RT_StartSneaking", ET_CONTINUE, FP_CELL, FP_CELL, FP_STRING, FP_ARRAY);
g_iForward_StopSneaking = CreateMultiForward("RT_StopSneaking", ET_IGNORE, FP_CELL, FP_CELL);
g_iForward_Player_Spawn_Post = CreateMultiForward("RT_GotRespawn", ET_IGNORE, FP_CELL, FP_CELL);
g_iForward_Relation_Conditions = CreateMultiForward("RT_RelationConditions", ET_CONTINUE, FP_CELL, FP_CELL);

new pCvarFreeForAll = get_cvar_pointer("mp_freeforall");
bind_pcvar_num(pCvarFreeForAll, FreeForAll);
hook_cvar_change(pCvarFreeForAll, "cvar_change_callback");
}

public plugin_cfg()
{
new size[6][7];

if (
parse(rt_size,
size[0], 6,
size[1], 6,
size[2], 6,
size[3], 6,
size[4], 6,
size[5], 6
) == 6
)
{
for (new i; i < 3; i++)
{
if (
(g_VecMins[i] = str_to_float(size[i])) > 0.0
|| (g_VecMaxs[i] = str_to_float(size[i + 3])) < 0.0
) {
goto @defsize
}
}
}
else
{
@defsize:
g_VecMins = DEFAULT_CORPSE_MINS;
g_VecMaxs = DEFAULT_CORPSE_MAXS;
}
}

public Event_TeamInfo()
{
// CHalfLifeMultiplay::InitHUD
// CHalfLifeMultiplay::ClientDisconnected
// CBasePlayer::Spawn
// CBasePlayer::SwitchTeam
// CBasePlayer::GetIntoGame
UTIL_CorpseRemove(read_data(1));
}

// Прекращение взаимодействия при выходе из игры
public client_disconnected(id)
{
CloseAction(id);
}

// Прекращение взаимодействия при убийстве
public CBasePlayer_Killed(const id, pevAttacker, iGib)
{
CloseAction(id);
return HC_CONTINUE;
}

public CPointEntity_StopSneaking(const this)
{
if (!FClassnameIs(this, CORPSE_CLASSNAME)) {
return;
}

// Прекращение взаимодействия в случае удаления сущности с мира
new pClient = ptrActivator(this);
if (is_user_connected(pClient)) {
CloseAction(pClient);
}

// forward RT_StopSneaking(const corpse_id, const owner);
ExecuteForward(g_iForward_StopSneaking, _, this, ptrOwner(this));
}

public CCorpse_Think(id)
{
new pevActivator = ptrActivator(id);
new pevOwner = ptrOwner(id);

// Check player
if (!VALID_PLAYER(pevActivator) || g_pEntity[pevActivator] != id) {
return;
}

// Check time
new Float:timeEnd;
new Float:gameTime = get_gametime();
get_entvar(id, var_timer, timeEnd);
if ((timeEnd != 0.0 && gameTime >= timeEnd))
{
BreakAction(id, pevActivator, pevOwner, true);
return;
}

// forward RT_ThinkLoot(const corpse_id, const activator, const owner, Float:time_ending);
new Float:flNextThink = 0.05;
ExecuteForward(g_iForward_Loot_Think, g_iForward_Return, id, pevActivator, pevOwner, timeEnd); //, flNextThink);
if (g_iForward_Return >= RT_SUPERCEDE)
{
BreakAction(id, pevActivator, pevOwner, false);
return;
}

// Next think
set_entvar(id, var_nextthink, gameTime + flNextThink);
}

CloseAction(const id)
{
new corpse_id = g_pEntity[id];

g_pEntity[id] = 0;

// td: Safety checks
if (!is_nullent(corpse_id) && ptrActivator(corpse_id) == id) {
BreakAction(corpse_id, id, ptrOwner(corpse_id), false);
}
}

BreakAction(const corpse_id, const activator, const owner, const bool:complete)
{
// Clear mark
g_pEntity[activator] = 0;

// forward RT_StopLoot(const corpse_id, const activator, const owner, bool:complete);
ExecuteForward(g_iForward_Loot_Ended, g_iForward_Return, corpse_id, activator, owner, complete);

// Завершение процесса
if (complete && !g_iForward_Return)
{
g_fSpawned = true;
rg_round_respawn(owner);
g_fSpawned = false;

// forward RT_GotRespawn(const id, const friend);
ExecuteForward(g_iForward_Player_Spawn_Post, _, owner, activator);

// ForceClientDllUpdate()
rg_internal_cmd(owner, "fullupdate");
}

if (!is_nullent(corpse_id))
{
// Reset vars
set_entvar(corpse_id, var_nextthink, 0.0);
set_entvar(corpse_id, var_activator, 0);
set_entvar(corpse_id, var_timer, 0.0);
}
}

// Создание трупа
public Messsage_ClCorpse()
{
new corpse_id = rg_create_entity("info_target");

if (is_nullent(corpse_id)) {
return PLUGIN_CONTINUE;
}

static sModel[64];
static Float:VSrc[3], Float:VAngles[3];
new id = get_msg_arg_int(12);

for (new i; i < 3; i++)
{
VSrc[i] = float(get_msg_arg_int(2 + i)) / 128.0;
VAngles[i] = get_msg_arg_float(5 + i);
}

rh_update_user_info(id);
// get_msg_arg_string(1, sModel, charsmax(sModel));
get_user_info(id, "model", sModel, charsmax(sModel));
format(sModel, charsmax(sModel), "models/player/%s/%s.mdl", sModel, sModel);

set_entvar(corpse_id, var_classname, CORPSE_CLASSNAME);
set_entvar(corpse_id, var_angles, VAngles);
set_entvar(corpse_id, var_body, get_msg_arg_int(10));
set_entvar(corpse_id, var_animtime, 0.0);
set_entvar(corpse_id, var_framerate, 1.0);
set_entvar(corpse_id, var_sequence, get_msg_arg_int(9));
set_entvar(corpse_id, var_team, get_msg_arg_int(11));
set_entvar(corpse_id, var_owner, id);

SET_ORIGIN(corpse_id, VSrc);
SET_MODEL(corpse_id, sModel);
SET_SIZE(corpse_id, g_VecMins, g_VecMaxs);

// SetUse(corpse_id, "CCorpse_Use");
SetThink(corpse_id, "CCorpse_Think");
g_pCorpse[id] = corpse_id;

// forward RT_StartSneaking(const corpse_id, const owner, const model[], const Float:origin[3]);
ExecuteForward(g_iForward_StartSneaking, g_iForward_Return, corpse_id, id, sModel, PrepareArray(_:VSrc, 3, .copyback = 0));
switch (g_iForward_Return)
{
case CORPSE_CUSTOM: {

}
case CORPSE_DEFAULT: {
UTIL_CorpseRemove(id);
return PLUGIN_CONTINUE;
}

case CORPSE_BLOCK: {
UTIL_CorpseRemove(id);
}
}

// Hook original corpse
return PLUGIN_HANDLED;
}

// Удаление трупа
UTIL_CorpseRemove(const id)
{
new corpse_id = g_pCorpse[id];

g_pCorpse[id] = 0;

if (is_nullent(corpse_id)) {
return false;
}

rg_remove_entity(corpse_id);
return true;
}

parseJSON()
{
new path[128];
get_configsdir(path, charsmax(path));
strcat(path, "/plugins", charsmax(path));

if (!dir_exists(path) && mkdir(path) == -1) {
return false;
}

new JSON:json;
new JSON:json_copy;
new bool:bCreate;

strcat(path, "/revive_teammates.json", charsmax(path));
if (file_exists(path))
{
json = json_parse(path, true);
if (json == Invalid_JSON) {
return false;
}

json_copy = json_deep_copy(json);
bCreate = false;
}
else
{
json = json_init_object();
bCreate = true;
}

if (!json_object_has_value(json, RT_SUFFIX, JSONString)) {
json_object_set_string(json, RT_SUFFIX, NULL_STRING);
}

// Credits
json_object_set_string(json, "VERSION", RT_VERSION_STR);
json_object_set_string(json, "AUTHOR", "@emmajule");

if (!json_object_has_value(json, "INFO", JSONObject))
{
new JSON:json_info = json_init_object();
json_object_set_string(json_info, CM_VALUE_TAG, "Значение квара");
json_object_set_string(json_info, CM_DESCRIPTION_TAG, "Описание квара");
// json_object_set_string(json_info, CM_DEFAULT_TAG, "Значение по умолчанию");
json_object_set_string(json_info, CM_MIN_TAG, "Минимальное допустимое значение");
json_object_set_string(json_info, CM_MAX_TAG, "Максимальное допустимое значение");

json_object_set_value(json, "INFO", json_info);
json_free(json_info);
}

// TODO: Controll variables
json_cvar_string(json, "chat_prefix", "[!gRevive!n]", "Приставка для чат сообщений^n!n - Стандартный цвет^n!t - Цвет команды^n!g - Зеленый", .cvar = rt_prefix, .len = charsmax(rt_prefix));
json_cvar_float(json, "duration", 3.0, "Время действия процесса воскрешения^nИспользуйте 0 для мнгновенного действия (достаточно только нажать кнопку)", .has_min = true, .has_max = true, .max_val = 10.0, .cvar = rt_duration);
json_cvar_string(json, "box_size", "-16.0 -16.0 -36.0 16.0 16.0 36.0", "Размер объекта (хитбокс)^nСозданная сущность в игре имеет размеры куба 6 проекций (сверху сбоку сзади спереди слева справо)^nСам труп принимает свойство кнопки (радиус отлова 128 units)", .cvar = rt_size, .len = charsmax(rt_size));

// Support colored tags
replace_color_tag(rt_prefix, charsmax(rt_prefix));

// forward RT_ParseConfigFile(JSON:json);
ExecuteForward(g_iForward_Parse_File, _, json);

if (bCreate || !json_equals(json, json_copy)) {
new sTime[24];
get_time("%Y.%m.%d - %H:%M:%S", sTime, charsmax(sTime));
json_object_set_string(json, RT_SUFFIX, fmt("The last configuration auto-change was on %s", sTime));
json_serial_to_file(json, path, true);
}

// Print
server_print("[%s] Revive Teammates %s by @emmajule", RT_SUFFIX, RT_VERSION_STR);
server_print("[%s] Loaded %d configuration objects. Total size of serialized string: %d", RT_SUFFIX, json_object_get_count(json), json_serial_size(json, true));

json_free(json);

if (json_copy != Invalid_JSON) {
json_free(json_copy);
}

return true;
}

stock _:PlayerRelationship(const player, const target)
{
if (!is_user_connected(player) || !is_user_connected(target))
{
return RELATION_NONE;
}

// forward RT_RelationCheck(const player, const target);
new _:relationStatus;
ExecuteForward(g_iForward_Relation_Conditions, relationStatus, player, target);
if (relationStatus > RELATION_NONE /* && VALID_RELATION(relationStatus) */ )
{
return relationStatus;
}

if (FreeForAll)
{
// return RELATION_NONE;
}

if (!VALID_TEAM(target))
{
return RELATION_NONE;
}

// mp_friendlyfire shouldn't consider us an enemy
if (get_member(player, m_iTeam) == get_member(target, m_iTeam))
{
// Default scenario
return RELATION_TEAMMATE;
}

// return RT_ENEMY;
return RELATION_NONE;
}

public cvar_change_callback(pcvar, const old_value[], const new_value[])
{
FreeForAll = str_to_num(new_value);
}

/**
* Retrives a plugin prefix
*
* @param string String buffer to copy
* @param len Max buffer size
*
* @noreturn
*/
public Native_RT_GetPrefix(plugin, argc)
{
set_string(1, rt_prefix, get_param(2));
}

/**
* Get a entity index of player corpse
*
* @param id Player index
*
* @return Entity index of player corpse, 0 otherwise (player alive or switching team, etc..)
*/
public Native_RT_GetCorpse(plugin, argc)
{
new id = get_param(1);

return g_pCorpse[id];
}

/**
* Force delete a player corpse
*
* @param id Player index
*
* @return true if the deletion was successful, false otherwise
*/
public Native_RT_DeleteCorpse(plugin, argc)
{
new id = get_param(1);

return UTIL_CorpseRemove(id);
}

/**
* Get corpse entity index which player controlled
*
* @param id Player index
*
* @return Entity index of corpse, 0 otherwise
*/
public Native_RT_Attachment(plugin, argc)
{
new id = get_param(1);

// NULLENT? wtf
return g_pEntity[id];
}

/**
* Utility for checking the player's spawn
* Use it only in player Spawn forwards
*
* @return 1 on success, 0 otherwise
*/
public Native_RT_fSpawned(plugin, argc)
{
return g_fSpawned;
}

/**
* Force's a begin action of revive
*
* @param corpse_id Entity index of corpse
* @param activator Player index (corpse activator)
* @param skip_checks If true, the process cannot be stopped by other plugins
*
* @return true on success, false otherwise
*/
public Native_RT_GoAction(plugin, argc)
{
new corpse_id = get_param(1);
new activator = get_param(2);
new bool:skip_checks = bool:get_param(3);
new owner = ptrOwner(corpse_id);

// Non-valid entities
if (is_nullent(activator) || is_nullent(corpse_id)) {
return false;
}

// Do not to use!
if (ptrActivator(corpse_id) != 0 || g_pEntity[activator] != 0) {
return false;
}

// forward RT_StartLoot_Pre(const corpse_id, const activator, const owner);
ExecuteForward(g_iForward_Loot_Pre, g_iForward_Return, corpse_id, activator, owner);

if (g_iForward_Return >= RT_SUPERCEDE && !skip_checks) {
return false;
}

// Update entity properties
new Float:flGameTime = get_gametime();
set_entvar(corpse_id, var_timer, flGameTime + rt_duration);
set_entvar(corpse_id, var_activator, activator);
set_entvar(corpse_id, var_nextthink, flGameTime);

// Mark entity
g_pEntity[activator] = corpse_id;

// forward RT_StartLoot_Post(const corpse_id, const activator, const owner, Float:duration);
ExecuteForward(g_iForward_Loot_Post, _, corpse_id, activator, owner, rt_duration);
return true;
}

/**
* Instantly a break action of revive
*
* @param corpse_id Entity index of corpse
* @param activator Player index (corpse activator)
* @param owner Player index (owner of corpse)
* @param complete Complete status
*
* @return true on success, false otherwise
*/
public Native_RT_BreakAction(plugin, argc)
{
new corpse_id = get_param(1);
new activator = get_param(2);
new owner = get_param(3);
new bool:complete = bool:get_param(4);

if (is_nullent(corpse_id)) {
return false;
}

if (!is_user_connected(activator)) {
return false;
}

if (g_pEntity[activator] != corpse_id) {
return false;
}

BreakAction(corpse_id, activator, owner, complete);
return true;
}

/**
* Get a relationship status between two players
*
* @param player Player index (like a victim)
* @param target Player index (like a attacker)
*
* @return Relation status (see revive_teammates_const.inc)
*/
public any:Native_RT_RelationStatus(plugin, argc)
{
new player = get_param(1);
new target = get_param(2);

// See revive_teammates_const.inc
return PlayerRelationship(player, target);
}

public Native_RT_Get_Relation(plugin, argc)
{
// Not to use!! -- backwards only!!
return false;
}

public Native_RT_Set_Relation(plugin, argc)
{
// Not to use!! -- backwards only!!
return false;
}
[/code][/spoiler]

[spoiler title=rt_misc.sma][code]#include <amxmisc>
#include <reapi>
#include <xs>
#include <revive_teammates>

// Cvars
new Float:rt_misc_next_use;
new rt_misc_catch_mode;
new rt_misc_fake_client;

// Vars
new Float:g_flNextCorpseUsingTime[33];

public plugin_init()
{
register_plugin("RT: Misc", RT_VERSION_STR, "@emmajule");

RegisterHookChain(RG_CBasePlayer_UseEmpty, "CBasePlayer_UseEmpty", true);
}

// Register cvars
public RT_ParseConfigFile(JSON:json)
{
json_cvar_float(json, "next_use", 0.70, "Время после которого игрок вновь сможет использовать кнопку содействия с трупом (+use)", .has_min = true, .min_val = 0.1, .has_max = true, .max_val = 5.0, .cvar = rt_misc_next_use);
json_cvar_integer(json, "catch_mode", 1, "Метод поиска трупа^n0 - Отлов первого попавшегося трупа в радиусе^n1 - Отлов трупа с максимально близкой дистанцией к игроку", .cvar = rt_misc_catch_mode);
json_cvar_integer(json, "fake_client", 0, "Взаимодействие с ботами!", .cvar = rt_misc_fake_client);
}

public CBasePlayer_UseEmpty(const id)
{
new Float:gameTime = get_gametime();

if (g_flNextCorpseUsingTime[id] > gameTime) {
return;
}
else {
// "next_use":
g_flNextCorpseUsingTime[id] = gameTime + rt_misc_next_use;
}

if (RT_IsUsing(id)) {
return;
}

new aPlayers[32], iCount;
get_players_ex(aPlayers, iCount, GetPlayers_ExcludeAlive | GetPlayers_ExcludeHLTV);

if (iCount <= 0) {
return;
}

new corpse;
new corpse_id;
new Float:dist, Float:best_dist;

while (--iCount >= 0)
{
corpse_id = RT_GetCorpse(aPlayers[iCount]);
if (is_nullent(corpse_id)) {
continue;
}

if (RT_RelationStatus(aPlayers[iCount], id) == RELATION_NONE) {
continue;
}

dist = rg_entity_range(id, corpse_id);
if (dist > CORPSE_MAX_RANGE) {
continue;
}

if (!best_dist || dist < best_dist) {
best_dist = dist;
corpse = corpse_id;

// "catch_mode":
if (!rt_misc_catch_mode) {
break;
}
}
}

if (corpse > 0) {
RT_GoAction(corpse, id);
}
}

public RT_StartSneaking(const corpse_id, const owner, const model[], const Float:origin[3])
{
// "fake_client":
if (!rt_misc_fake_client && is_user_bot(owner)) {
return CORPSE_DEFAULT;
}

return CORPSE_CUSTOM;
}

// I'm really need this here ?
public RT_RelationConditions(const player, const target)
{
if (get_member(player, m_iTeam) == get_member(target, m_iTeam)) {
return RELATION_TEAMMATE;
}

return RELATION_NONE;
}

public RT_ThinkLoot(const corpse_id, const activator, const owner, Float:time_ending)
{
if (rg_entity_range(activator, corpse_id) > CORPSE_MAX_RANGE) {
return RT_SUPERCEDE;
}

return RT_CONTINUE;
}

[/code][/spoiler]

[spoiler title=rt_effects.sma][code]#include <amxmodx>
#include <fakemeta>
#include <reapi>
#include <revive_teammates>

const UNIT_SECOND = 1<<12;
const FFADE_IN = 0x0000;
const FFADE_OUT = 0x0001;
const FFADE_STAYOUT = 0x0004;

// Cvars
new rt_prefix[48];
new rt_effects_progress_bar;
new rt_effects_observer_camera;
new rt_effects_lighting;
new rt_effects_alertf[16];
new rt_effects_respawn_sound[64];
new rt_effects_respawn_sound_can_hear;
new rt_effects_loot_start_sound[64];
new rt_effects_loot_start_sound_can_hear;
new rt_effects_loot_stop_sound[64];
new rt_effects_loot_stop_sound_can_hear;
new rt_effects_revive_notification;
new rt_effects_screenfade_loot;
new rt_effects_screenfade_loot_color[16];
new rt_effects_screenfade_loot_alpha;
new rt_effects_screenfade_respawn;
new rt_effects_screenfade_respawn_color[16];
new rt_effects_screenfade_respawn_alpha;
new rt_effects_corpse_glow_t;
new rt_effects_corpse_glow_t_color[16];
new rt_effects_corpse_glow_ct;
new rt_effects_corpse_glow_ct_color[16];
new rt_effects_corpse_glow_loot;
new rt_effects_corpse_glow_loot_color[16];

enum {
RT_EFFECT_NOTIFICATION_NONE = 0,
RT_EFFECT_NOTIFICATION_ALL,
RT_EFFECT_NOTIFICATION_ONLY_TEAM,
RT_EFFECT_NOTIFICATION_ONLY_PLAYERS,
};

enum {
RT_EFFECT_SOUND_ANYONE = 0,
RT_EFFECT_SOUND_ONLY_PLAYER,
RT_EFFECT_SOUND_ONLY_PLAYER_TEAM,
};

enum (<<=1) {
RT_EFFECT_ALERT_OFF = 0,
RT_EFFECT_ALERT_CHAT = 1,
RT_EFFECT_ALERT_CENTER,
RT_EFFECT_ALERT_HUD,
};

// Vars
new g_Alert;
new g_ScreenFadeColorRespawn[3];
new g_ScreenFadeColorLoot[3];
new Float:g_GlowColorT[3];
new Float:g_GlowColorCT[3];
new Float:g_GlowColorLoot[3];

public plugin_init()
{
register_plugin("RT: Effects", RT_VERSION_STR, "@emmajule");
}

public RT_ParseConfigFile(JSON:json)
{
json_cvar_integer(json, "progress_bar", 1, "Процесс воскрешения будет сопровождатся полоской по центру эркана", .cvar = rt_effects_progress_bar);
json_cvar_integer(json, "observer_force_camera", 0, "Камера автоматически перенаправит мертвого игрока на того, кто его воскрешает", .cvar = rt_effects_observer_camera);
json_cvar_integer(json, "dynamic_light", 0, "Подсветка трупа^nМожет быть полезно в темных местах^nВнимание: может вызывать нагрузку из-за особенностей свечения движка!", .cvar = rt_effects_lighting);
json_cvar_string(json, "alert_flags", "c", "Уведомления при поднятии^na - в чат^nb - по центру экрана^nc - HUD (плавное сообщение)^nПримечание: можно использовать посовместно^n'' или 0 - отключено", .cvar = rt_effects_alertf, .len = charsmax(rt_effects_alertf));
json_cvar_string(json, "respawn_sound", "", "Звук когда игрок возродился", .cvar = rt_effects_respawn_sound, .len = charsmax(rt_effects_respawn_sound), .precache = true);
json_cvar_integer(json, "respawn_sound_listen", 0, "Кто будет слышать этот звук?^n0 - все игроки^n1 - только игрок^n2 - все кто в команде игрока", .cvar = rt_effects_respawn_sound_can_hear);
json_cvar_string(json, "loot_start_sound", "", "Звук при старте возрождения мертвого товарища", .cvar = rt_effects_loot_start_sound, .len = charsmax(rt_effects_loot_start_sound), .precache = true);
json_cvar_integer(json, "loot_start_sound_listen", 0, "Кто будет слышать этот звук?^n0 - все игроки^n1 - только игрок^n2 - все кто в команде игрока", .cvar = rt_effects_loot_start_sound_can_hear);
json_cvar_string(json, "loot_stop_sound", "", "Звук прекращения связи с этим игроком", .cvar = rt_effects_loot_stop_sound, .len = charsmax(rt_effects_loot_stop_sound), .precache = true);
json_cvar_integer(json, "loot_stop_sound_listen", 0, "Кто будет слышать этот звук?^n0 - все игроки^n1 - только игрок^n2 - все кто в команде игрока", .cvar = rt_effects_loot_stop_sound_can_hear);
json_cvar_integer(json, "revive_notification", 1, "Уведомление о воскрешении товарища^n0 - Нет^n1 - Всем^n2 - Только команде^n3 - Только трупу и тому кто его поднимал", .cvar = rt_effects_revive_notification);
json_cvar_integer(json, "screenfade_loot", 0, "Эффект свечения (блик) экрана в момент воскрешения", .cvar = rt_effects_screenfade_loot);
json_cvar_string(json, "screenfade_loot_color", "50 200 75", "Цвет этого блика^nИспользуется формат RGB (пример: 250 250 0)", .cvar = rt_effects_screenfade_loot_color, .len = charsmax(rt_effects_screenfade_loot_color));
json_cvar_integer(json, "screenfade_loot_color_alpha", 150, "Степень прозрачности блика", .has_min = true, .has_max = true, .max_val = 255, .cvar = rt_effects_screenfade_loot_alpha);
json_cvar_integer(json, "screenfade_respawn", 0, "Эффект свечения (блик) экрана для только воскрешенного игрока", .cvar = rt_effects_screenfade_respawn);
json_cvar_string(json, "screenfade_respawn_color", "0 200 0", "Цвет этого блика^nИспользуется формат RGB (пример: 250 250 0)", .cvar = rt_effects_screenfade_respawn_color, .len = charsmax(rt_effects_screenfade_respawn_color));
json_cvar_integer(json, "screenfade_respawn_alpha", 150, "Степень прозрачности блика", .has_min = true, .has_max = true, .max_val = 255, .cvar = rt_effects_screenfade_respawn_alpha);
json_cvar_integer(json, "corpse_glow_t", 0, "Все трупы команды TERRORIST покрыты цветной оболочкой", .cvar = rt_effects_corpse_glow_t);
json_cvar_string(json, "corpse_glow_t_color", "", "Цвет этой обводки^nИспользуется формат RGB (пример: 250 250 0)", .cvar = rt_effects_corpse_glow_t_color, .len = charsmax(rt_effects_corpse_glow_t_color));
json_cvar_integer(json, "corpse_glow_ct", 0, "Все трупы команды CT покрыты цветной оболочкой", .cvar = rt_effects_corpse_glow_ct);
json_cvar_string(json, "corpse_glow_ct_color", "", "Цвет этой обводки^nИспользуется формат RGB (пример: 250 250 0)", .cvar = rt_effects_corpse_glow_ct_color, .len = charsmax(rt_effects_corpse_glow_ct_color));
json_cvar_integer(json, "corpse_glow_loot", 0, "При использовании трупа, в это время он будет иметь цветную оболочку!", .cvar = rt_effects_corpse_glow_loot);
json_cvar_string(json, "corpse_glow_loot_color", "100 100 100", "Цвет этой обводки^nИспользуется формат RGB (пример: 250 250 0)", .cvar = rt_effects_corpse_glow_loot_color, .len = charsmax(rt_effects_corpse_glow_loot_color));
}

public plugin_cfg()
{
// Retrive plugin prefix (co.)
RT_GetPrefix(rt_prefix, 47);

string_to_array(rt_effects_corpse_glow_t_color, g_GlowColorT);
string_to_array(rt_effects_corpse_glow_ct_color, g_GlowColorCT);
string_to_array(rt_effects_corpse_glow_loot_color, g_GlowColorLoot);

new Float:flTemp[3];
string_to_array(rt_effects_screenfade_respawn_color, flTemp);
FVecIVec(flTemp, g_ScreenFadeColorRespawn);
string_to_array(rt_effects_screenfade_loot_color, flTemp);
FVecIVec(flTemp, g_ScreenFadeColorLoot);

// "alert_flags":
g_Alert = read_flags_ex(rt_effects_alertf);

// "observer_force_camera":
if (rt_effects_observer_camera && !CanTouchObserverCamera()) {
rt_effects_observer_camera = 0;
}
}

public RT_StartSneaking(const corpse_id, const owner, const model[], const Float:origin[3])
{
if (rt_effects_lighting) {
// "dynamic_light":
set_entvar(corpse_id, var_effects, get_entvar(corpse_id, var_effects) | EF_DIMLIGHT);
}

// Красим труп
rt_corpse_glow(corpse_id);
}

public RT_StartLoot_Post(const corpse_id, const activator, const owner, Float:duration)
{
// Смотрим на дружественно нравственные ценности
if (RT_RelationStatus(activator, owner) != RELATION_TEAMMATE) {
return;
}

// "observer_force_camera":
if (rt_effects_observer_camera)
{
set_member(owner, m_hObserverTarget, activator);
set_member(owner, m_flNextObserverInput, get_gametime() + 0.2);

#if REAPI_VERSION >= 522254
rg_set_observer_mode(owner, OBS_IN_EYE);
#else
// set_entvar(owner, var_iuser1, OBS_IN_EYE);
rg_internal_cmd(owner, "specmode", "4");
#endif
}

if (rt_effects_progress_bar && duration > 0.75) {
// "progress_bar":
rg_send_bartime(activator, floatround(duration), .observer = true);
}

// Уведомления
if (g_Alert & RT_EFFECT_ALERT_CHAT)
{
// RT_PRINT_CHAT_REVIVE1 = Вы воскрешаете^3 %n^1 (продержитесь^4 %.0f^1 сек.)
// RT_PRINT_CHAT_REVIVE2 = Вас поднимает^3 %n
client_print_color(activator, owner, "%s %l", rt_prefix, "RT_PRINT_CHAT_REVIVE1", owner, duration);
client_print_color(owner, activator, "%s %l", rt_prefix, "RT_PRINT_CHAT_REVIVE2", activator, duration);
}

if (g_Alert & RT_EFFECT_ALERT_CENTER)
{
// RT_PRINT_CENTER_REVIVE1 = Вы воскрешаете %n^rПродержитесь %.0f сек.
// RT_PRINT_CENTER_REVIVE2 = Вас поднимает %n
client_print(activator, print_center, "%l", "RT_PRINT_CENTER_REVIVE1", owner, duration);
client_print(owner, print_center, "%l", "RT_PRINT_CENTER_REVIVE2", activator, duration);
}

if (g_Alert & RT_EFFECT_ALERT_HUD)
{
// RT_PRINT_HUD_REVIVE1 = Вы воскрешаете %n^nПродержитесь %.0f сек.
set_dhudmessage(0, 160, 30, -1.0, 0.76, 2, 3.0, 2.0, 0.03, 0.4);
show_dhudmessage(activator, "%l", "RT_PRINT_HUD_REVIVE1", owner, duration);

// RT_PRINT_HUD_REVIVE2 = Вас поднимает %n..
set_dhudmessage(0, 160, 30, -1.0, 0.76, 2, 3.0, 2.0, 0.03, 0.4);
show_dhudmessage(owner, "%l", "RT_PRINT_HUD_REVIVE2", activator, duration);
}

// "loot_start_sound":
if (!FNullString(rt_effects_loot_start_sound)) {
// "loot_start_sound_listen":
rt_effects_sound(activator, rt_effects_loot_start_sound_can_hear, rt_effects_loot_start_sound, CHAN_VOICE);
}

// "screenfade":
if (rt_effects_screenfade_loot) {
// "screenfade_loot_color":
// "screenfade_loot_color_alpha":
UTIL_ScreenFade(activator, duration, 0.0, .color = g_ScreenFadeColorLoot, .alpha = rt_effects_screenfade_loot_alpha, .flags = FFADE_OUT);
}

// "corpse_glow_loot":
if (rt_effects_corpse_glow_loot) {
// "corpse_glow_loot_color":
rg_set_rendering(corpse_id, kRenderFxGlowShell, .color = g_GlowColorLoot, .amount = 10.0);
}
}

public RT_StopLoot(const corpse_id, const activator, const owner, bool:complete)
{
// Процесс взаимодействия завершен, труп удалён!
if (complete) {
return;
}

// BUG: Если рендер активен то нам нужно сбросить его после использования
if (rt_effects_corpse_glow_loot) {
rg_set_rendering(corpse_id);
}

// And again
rt_corpse_glow(corpse_id);

// Дальнейшие действия должны быть совместимы только между товарищами по команде
if (RT_RelationStatus(activator, owner) != RELATION_TEAMMATE) {
return;
}

// "progress_bar":
if (rt_effects_progress_bar) {
rg_send_bartime(activator, 0);
}

// "screenfade_loot":
if (rt_effects_screenfade_loot) {
UTIL_ScreenFade(activator, 0.001);
}

// "loot_stop_sound":
if (!FNullString(rt_effects_loot_stop_sound)) {
// "loot_stop_sound_listen":
rt_effects_sound(activator, rt_effects_loot_stop_sound_can_hear, rt_effects_loot_stop_sound, CHAN_VOICE);
}
}

// Успешное возрождение
public RT_GotRespawn(const id, const friend)
{
// "respawn_sound":
if (!FNullString(rt_effects_respawn_sound)) {
// "respawn_sound_listen":
rt_effects_sound(id, rt_effects_respawn_sound_can_hear, rt_effects_respawn_sound, CHAN_AUTO);
}

// "screenfade_respawn":
if (rt_effects_screenfade_respawn) {
// "screenfade_respawn_color":
// "screenfade_respawn_alpha":
UTIL_ScreenFade(id, 1.0, 0.0, g_ScreenFadeColorRespawn, rt_effects_screenfade_respawn_alpha, FFADE_IN);
}

// "revive_notification":
switch (rt_effects_revive_notification)
{
case RT_EFFECT_NOTIFICATION_NONE: {
// Если вдруг наступил момент, когда вы не знаете как жить дальше - живите ближе!
}
case RT_EFFECT_NOTIFICATION_ALL: {
// RT_NOTIFICATION_REVIVE_ALL = ^4%n^1 поднял^4 %n
client_print_color(0, friend, "%s %l", rt_prefix, "RT_NOTIFICATION_REVIVE_ALL", friend, id);
}
case RT_EFFECT_NOTIFICATION_ONLY_TEAM: {
// Только команде
for (new i = MaxClients; i > 0; --i)
{
if (!is_user_connected(i)) {
continue;
}

// Смотрим на дружественно нравственные ценности
if (RT_RelationStatus(i, friend) != RELATION_TEAMMATE) {
continue;
}

// RT_NOTIFICATION_REVIVE_TEAM = ^3%n^1 поднял^3 %n
client_print_color(i, 0, "%s %l", rt_prefix, "RT_NOTIFICATION_REVIVE_TEAM", friend, id);
}
}
case RT_EFFECT_NOTIFICATION_ONLY_PLAYERS: {
// RT_NOTIFICATION_REVIVE_PLAYER1 = Вас воскресил^4 %n
// RT_NOTIFICATION_REVIVE_PLAYER2 = Вы воскресиили^4 %n
client_print_color(id, 0, "%s %l", rt_prefix, "RT_NOTIFICATION_REVIVE_PLAYER1", friend, id);
client_print_color(friend, 0, "%s %l", rt_prefix, "RT_NOTIFICATION_REVIVE_PLAYER2", id, friend);
}
}
}

// Звуки
rt_effects_sound(const id, const can_hear, const sound[], const channel)
{
for (new i = MaxClients; i > 0; --i)
{
if (!is_user_connected(i)) {
continue;
}

// Только игроку
if (can_hear == RT_EFFECT_SOUND_ONLY_PLAYER && i != id) {
continue;
}
// Для всех кто друг
else if (can_hear == RT_EFFECT_SOUND_ONLY_PLAYER_TEAM &&
RT_RelationStatus(i, id) != RELATION_TEAMMATE) {
continue;
}

// TODO: cvar
// rg_send_audio(i, sound);
rh_emit_sound2(id, i, channel, sound);
}
}

// Свечение трупа
rt_corpse_glow(const corpse_id)
{
switch (get_entvar(corpse_id, var_team))
{
case TEAM_TERRORIST:
{
// "corpse_glow_t":
if (rt_effects_corpse_glow_t) {
// "corpse_glow_t_color":
rg_set_rendering(corpse_id, kRenderFxGlowShell, .color = g_GlowColorT, .amount = 10.0);
}
}
case TEAM_CT:
{
// "corpse_glow_ct":
if (rt_effects_corpse_glow_ct) {
// "corpse_glow_ct_color":
rg_set_rendering(corpse_id, kRenderFxGlowShell, .color = g_GlowColorCT, .amount = 10.0);
}
}
}
}

string_to_array(const from[], Float:to[])
{
new arg[3][4];
parse(from, arg[0], 3, arg[1], 3, arg[2], 3);

for (new i; i < 3; i++) {
to[i] = str_to_float(arg[i]);
}
}

stock bool:CanTouchObserverCamera()
{
// td: не совсем то, что нужно :(
if (is_module_loaded("Admins Kit") != -1) {
return false;
}

return true;
}

// Helpful stocks
stock UTIL_ScreenFade(const id, const Float:fxtime = 0.0, const Float:holdtime = 0.0, const color[3] = {0, 0, 0}, const alpha = 0, const flags = FFADE_IN)
{
// Игрок в ослеплении, даже если не полностью
if (Float:get_member(id, m_blindUntilTime) > get_gametime()) {
return;
}

static msgScreenFade;
if (msgScreenFade > 0 || (msgScreenFade = get_user_msgid("ScreenFade")) > 0) {
message_begin(MSG_ONE, msgScreenFade, .player = id);
write_short(FixedUnsigned16(fxtime, UNIT_SECOND));
write_short(FixedUnsigned16(holdtime, UNIT_SECOND));
write_short(flags);
write_byte(color[0]);
write_byte(color[1]);
write_byte(color[2]);
write_byte(alpha);
message_end();
}
}

stock FixedUnsigned16(Float:value, scale = UNIT_SECOND)
{
new output = floatround(value * scale);

if (output < 0) {
output = 0;
}

if (output > 0xFFFF) {
output = 0xFFFF;
}

return output;
}

stock rg_set_rendering(const id, const fx = kRenderFxNone, const mode = kRenderNormal, const Float:color[3] = NULL_VECTOR, const Float:amount = 0.0)
{
set_entvar(id, var_renderfx, fx);
set_entvar(id, var_rendercolor, color);
set_entvar(id, var_rendermode, mode);
set_entvar(id, var_renderamt, amount);
}[/code][/spoiler]

[spoiler title=rt_bonuses.sma][code]#include <amxmodx>
#include <reapi>
#include <hamsandwich>
#include <revive_teammates>

// BonusMenu RBS https://fungun.net/shop/?p=show&id=106
native bonusmenu_get_user_points(id);
native bonusmenu_add_user_points(id, points);

// Army Ranks Ultimate https://fungun.net/shop/?p=show&id=1
native ar_set_user_addxp(id, addxp);
native ar_add_user_anew(admin, player, anew);

// AES https://github.com/serfreeman1337/aes
native aes_add_player_exp(id, exp, override = 0);
native aes_add_player_bonus(id, bonus);

// Ultimate Weapons https://fungun.net/shop/?p=show&id=82
native weapons_give_user_ultimate(id, uid = -1, buy_name[] = "", replace = 0, ammo = -1, bpammo = -1);

// Cvars
new rt_prefix[48];
new rt_bonus_frags;
new rt_bonus_restore_deathpoint;
new rt_bonus_kevlar_type;
new rt_bonus_health_mode;
new Float:rt_bonus_spawn_health;
new Float:rt_bonus_give_health;
new Float:rt_bonus_protection_time;
new rt_bonus_reward;
new rt_bonus_reward_type;
new rt_bonus_reward_message;
new rt_bonus_weapons[256];

public plugin_init()
{
register_plugin("RT: Bonuses", RT_VERSION_STR, "@emmajule");
}

public RT_ParseConfigFile(JSON:json)
{
json_cvar_integer(json, "frags", 0, "Фрагов за поднятие тиммейта (в статистику не зачтется!)", .cvar = rt_bonus_frags);
json_cvar_integer(json, "restore_deathpoint", 0, "Обнулить очко смерти воскрешенному игроку (в статистике не изменится!)", .cvar = rt_bonus_restore_deathpoint);
json_cvar_float(json, "spawn_health", 0.0, "Количество здоровья с которым появится воскрешенный игрок^nИспользуйте 0, тогда будет использоваться 100 как обычно", .has_min = true, .cvar = rt_bonus_spawn_health);
json_cvar_integer(json, "give_kevlar", 0, "Выдавать броню?^n0 - Нет^n1 - Бронижелет^n2 - Бронижелет с каской", .has_min = true, .has_max = true, .max_val = 2, .cvar = rt_bonus_kevlar_type);
json_cvar_integer(json, "health_limit", 0, "Новое здоровье не привысит максимальное здоровье игрока^nДопустим по умолчанию максимальное здоровье 100, бонусное здоровье не сможет привысить этот параметр^nЭто также будет учитывать некоторые плагины по типу хилки, шприц..", .cvar = rt_bonus_health_mode);
json_cvar_float(json, "give_health", 0.0, "Количество бонусного здоровья за поднятие тиммейта", .cvar = rt_bonus_give_health);
json_cvar_float(json, "protection", 0.0, "Защита после спавна (в секундах)^nВ этот период воскрешенного игрока не смогут убить!", .has_max = true, .max_val = 5.0, .cvar = rt_bonus_protection_time);
json_cvar_integer(json, "reward", 0, "Награда за поднятие тиммейта^nВы можете также использовать значение с минусом, тогда это напротив будет считаться как оплатой за поднятие", .cvar = rt_bonus_reward);
json_cvar_integer(json, "reward_type", 0, "Выберите тип награды:^n0 - обычные деньги игры [$]^n1 - anew очки от BonusMenu RBS^n2 - anew очки от Army Ranks Ultimate^n3 - опыт от Army Ranks Ultimate^n4 - опыт от AES (fork Sonyx либо от serfreeman1337)^n5 - anew очки от AES (fork Sonyx либо от serfreeman1337)", .has_min = true, .has_max = true, .max_val = 5, .cvar = rt_bonus_reward_type);
json_cvar_integer(json, "reward_message", 0, "Игрок получит уведомление в чат, о том что он получил награду за воскрешение!", .cvar = rt_bonus_reward_message);
json_cvar_string(json, "weapons", "", "Список оружий с которым заспавнится воскрешенный игрок^nВводите через пробел и без weapon_^nПри бездействии квара игрок получает по стандарту пистолет и нож как обычно.^nИмеется поддержка Ultimate Weapons (для этого указывайте оружия через ultimate_)", .cvar = rt_bonus_weapons, .len = charsmax(rt_bonus_weapons));
}

public plugin_cfg()
{
// Retrive plugin prefix (co.)
RT_GetPrefix(rt_prefix, 47);
}

public RT_GotRespawn(const id, const friend)
{
if (rt_bonus_frags > 0) {
// "frags":
ExecuteHamB(Ham_AddPoints, friend, rt_bonus_frags, true);
}

if (rt_bonus_give_health > 0.0) {
// "bonus_health":
rg_add_health(friend, rt_bonus_give_health, false);
}

// "reward":
if (rt_bonus_reward != 0)
{
// "reward_type":
switch (rt_bonus_reward_type)
{
case 0: {
// обычные деньги игры [$]
rg_add_account(friend, rt_bonus_reward);
}
case 1: {
// anew очки от BonusMenu RBS
bonusmenu_add_user_points(friend, rt_bonus_reward);
}
case 2: {
// anew очки от Army Ranks Ultimate
ar_add_user_anew(-1, friend, rt_bonus_reward);
}
case 3: {
// опыт от Army Ranks Ultimate
ar_set_user_addxp(friend, rt_bonus_reward);
}
case 4: {
// опыт от AES (fork Sonyx либо от serfreeman1337)
aes_add_player_exp(friend, rt_bonus_reward);
}
case 5: {
// anew очки от AES (fork Sonyx либо от serfreeman1337)
aes_add_player_bonus(friend, rt_bonus_reward);
}
}

// "reward_message":
if (rt_bonus_reward_message) {
// RT_REWARD_NOTIFY = Вы получили^4 %d$
client_print_color(friend, 0, "%s %l", rt_prefix, "RT_REWARD_NOTIFY", rt_bonus_reward);
}
}

if (rt_bonus_restore_deathpoint) {
// "restore_death":
set_member(id, m_iDeaths, max(get_member(id, m_iDeaths) - 1, 0));

// Just update scoreboard message
ExecuteHamB(Ham_AddPoints, id, 0, true);
}

if (rt_bonus_spawn_health > 0.0) {
// "spawn_health":
set_entvar(id, var_health, rt_bonus_spawn_health);

// "health_limit_control":
if (rt_bonus_health_mode) {
// Новое здоровье не должно превысить то что стоит у нас в кваре
// По крайней мере для крутых плагинов, которые все же учитывают max_health игрока как положено
set_entvar(id, var_max_health, rt_bonus_spawn_health);
}
}

if (rt_bonus_protection_time > 0.0) {
// "protection":
set_member(id, m_flSpawnProtectionEndTime, get_gametime() + rt_bonus_protection_time);
}

if (rt_bonus_kevlar_type) {
// "give_kevlar":
rg_set_user_armor(id, 100, ArmorType:rt_bonus_kevlar_type);
}

if (!FNullString(rt_bonus_weapons)) {
// "weapons":
rg_remove_all_items(id, false);
rg_give_items(id, rt_bonus_weapons);
}
}

stock rg_give_items(const id, truncated_weapons[], bool:full_ammo = true)
{
new size = strlen(truncated_weapons);
new weapon[32];
new item;
new len;

do {
// while (argbreak(truncated_weapons, weapon, 31, truncated_weapons, size) != -1)
len += (1 + copyc(weapon, 31, truncated_weapons[len], ' '));

// Поддержка Ultimate Weapons
if (equal(weapon, "ultimate_", 9)) {
weapons_give_user_ultimate(id, .buy_name = weapon, .bpammo = !full_ammo ? 0 : -1);
}
else {
// run time error: 8 heap low ??
item = rg_give_item(id, fmt("weapon_%s", weapon));
if (item > 0 && full_ammo) {
set_member(id, m_rgAmmo,
rg_get_weapon_info(get_member(item, m_iId), WI_MAX_ROUNDS),
rg_get_weapon_info(get_member(item, m_iId), WI_AMMO_TYPE)
);
}
}
}
while (len < size);

}

stock rg_add_health(const id, const Float:hp, bool:obey_max = true)
{
new Float:health = Float:get_entvar(id, var_health);
new Float:max_health = Float:get_entvar(id, var_max_health);

if (obey_max)
{
if (health >= max_health && hp > 0.0) {
// Если у игрока здоровья больше чем должно то плагин не должен сбросить его до max_health
return;
}

set_entvar(id, var_health, floatclamp(health + hp, 1.0, max_health));
}
else {
set_entvar(id, var_health, floatmax(health + hp, 1.0));
}
}

// mx!?
public plugin_natives() {
set_native_filter("native_filter");
}

/* trap - 0 if native couldn't be found, 1 if native use was attempted
* @note The handler should return PLUGIN_CONTINUE to let the error through the
* filter (which will throw a run-time error), or return PLUGIN_HANDLED */
public native_filter(const szNativeName[], iNativeId, iTrapMode) {
return !iTrapMode;
}[/code][/spoiler]

[spoiler title=rt_restrictions.sma][code]#include <amxmodx>
#include <reapi>
#include <hamsandwich>
#include <revive_teammates>

#if !defined PLAYER_PREVENT_JUMP
#define PLAYER_PREVENT_JUMP (1<<6)
#endif

// Cvars
new rt_prefix[48];
new rt_restrictions_access[16];
new rt_restrictions_corpse_flag[16];
new rt_restrictions_team_allow;
new rt_restrictions_max_spawns;
new rt_restrictions_max_usage;
new rt_restrictions_block_attack;
new rt_restrictions_min_round;
new rt_restrictions_round_terminating;
new rt_restrictions_bomb_planted;
new rt_restrictions_water_level;
new rt_restrictions_on_ladder;
new rt_restrictions_vip_person;
new rt_restrictions_min_players;
new rt_restrictions_min_players_exclf[16];
new rt_restrictions_pvp;
new rt_restrictions_players_difference;
new rt_restrictions_domination;
new Float:rt_restrictions_time_expired;
new Float:rt_restrictions_time_remaining;
new rt_restrictions_can_jump;
new rt_restrictions_can_duck;
new Float:rt_restrictions_maxspeed;
new rt_restrictions_maxspeed_insane;
new rt_restrictions_hold_use;
new rt_restrictions_view_cone;
new rt_restrictions_bad_hitzones[16];
new rt_restrictions_to_relations;

// Vars
new g_iRevivalsCount[33];
new g_iResurrectionsCount[33];

new g_pAccessFlag;
new g_pCorpseAccessFlag;
new g_pCounterPlFlags;
new g_pHitgroup;

public plugin_init()
{
register_plugin("RT: Restrictions", RT_VERSION_STR, "@emmajule");

// RegisterHookChain(RG_CBasePlayer_Spawn, "CBasePlayer_Spawn", true);
RegisterHookChain(RG_CBasePlayer_ResetMaxSpeed, "CBasePlayer_ResetMaxSpeed", true);
RegisterHookChain(RG_CSGameRules_RestartRound, "CSGameRules_RestartRound", false);
}

public RT_ParseConfigFile(JSON:json)
{
json_cvar_string(json, "flag", "", "Флаг(и) доступа к возрождению мертвых товарищей по команде!^n0 или '' - Для всех", .cvar = rt_restrictions_access, .len = charsmax(rt_restrictions_access));
json_cvar_string(json, "corpse_flag", "", "Только игроки с этим флагом(ами) будет иметь кастомный труп^nВ противном случае труп будет стандартным (недоступен для действий плагина)^n0 или '' - Все будут", .cvar = rt_restrictions_corpse_flag, .len = charsmax(rt_restrictions_corpse_flag));
json_cvar_integer(json, "team_allow", 0, "Какая команда получит доступ к возрождению товарищей по команде^n0 - могут все!^n1 - исключительно игроки команды TERRORIST^n2 - исключительно игроки команды CT", .has_max = true, .max_val = 2, .cvar = rt_restrictions_team_allow);
json_cvar_integer(json, "max_spawns", 0, "Если игрок уже возрождался более чем Х раз в этом раунде, тогда его уже нельзя будет возродить этим плагином!", .cvar = rt_restrictions_max_spawns);
json_cvar_integer(json, "max_usage", 2, "Сколько максимально 1 игрок может возродить союзников за раунд^n0 - неограниченное число раз.", .cvar = rt_restrictions_max_usage);
json_cvar_integer(json, "block_attack", 0, "Игрок не сможет стрелять в момент содействия с трупом", .cvar = rt_restrictions_block_attack);
json_cvar_integer(json, "min_round", 0, "Использовать труп станет возможным только с Х раунда! (до этого будет спавнить обычные трупы)", .cvar = rt_restrictions_min_round);
json_cvar_integer(json, "round_ended", 0, "Невозможно использовать труп после окончания раунда!", .cvar = rt_restrictions_round_terminating);
// json_cvar_integer(json, "cost", 0, "Плата за использования трупа [$]", .cvar = rt_restrictions_cost);
json_cvar_integer(json, "bomb", 0, "Нельзя использовать труп когда бомба уже установленна", .cvar = rt_restrictions_bomb_planted);
json_cvar_integer(json, "water_level", 0, "Нельзя использовать если уровень воды игрока^n0 - можно всегда^n1 - ноги в воде^n2 - по пояс в воде^n3 - полностью в воде", .cvar = rt_restrictions_water_level);
json_cvar_integer(json, "on_ladder", 0, "Игрок не может использовать труп когда находится на лестнице", .cvar = rt_restrictions_on_ladder);
json_cvar_integer(json, "vip_person", 0, "VIP-персона не может использовать трупы^nЭто работает на сценарии 'Спасти VIP' [as_* карты]", .cvar = rt_restrictions_vip_person);
json_cvar_integer(json, "min_players", 0, "Сколько должно быть игроков на сервере для возможности возрождений!^n0 - работает всегда!", .cvar = rt_restrictions_min_players);
json_cvar_string(json, "min_players_exclude", "", "Кого не стоит учитывать при подсчете игроков?!^na - не считать зрителей^nb - не считать ботов", .cvar = rt_restrictions_min_players_exclf, .len = charsmax(rt_restrictions_min_players_exclf));
json_cvar_integer(json, "pvp", 0, "Игроки не могут использовать трупы когда остались 1 на 1^n0 - могут^n1 - не могут^n2 - не могут когда уже остался 1 игрок в любой из команд", .cvar = rt_restrictions_pvp);
json_cvar_integer(json, "players_difference", 0, "Нельзя использовать трупы если перевес живых игроков превышет этот квар^nПримечание: это не коснется команды которая в меньшинстве!^n0 - выключает эту возможность", .cvar = rt_restrictions_players_difference);
json_cvar_integer(json, "domination", 0, "Доминирующая команда не может использовать трупы!^nЭто касается сильной команды которая одерживает Х побед подряд!", .cvar = rt_restrictions_domination);
json_cvar_float(json, "time_expired", 0.0, "Использование трупа работает, если от начала раунда прошло более чем Х сек.", .has_max = true, .max_val = 60.0, .cvar = rt_restrictions_time_expired);
json_cvar_float(json, "time_remaining", 0.0, "Нельзя использовать труп за Х сек. до конца раунда", .has_max = true, .max_val = 120.0, .cvar = rt_restrictions_time_remaining);
json_cvar_integer(json, "can_jump", 1, "Игрок может прыгать в момент использования трупа", .cvar = rt_restrictions_can_jump);
json_cvar_integer(json, "can_duck", 1, "Игрок может сидеть/присаживатся в момент использования трупа", .cvar = rt_restrictions_can_duck);
json_cvar_float(json, "maxspeed", 0.0, "Скорость игрока в момент использования трупа^n1 - стоит на месте^n0 - без изменений!", .has_min = true, .cvar = rt_restrictions_maxspeed);
json_cvar_integer(json, "maxspeed_force", 0, "Скорость игрока будет постоянно обновляться!^nИспользуйте если другие плагины могут мешать, меняя скорость игрока!", .cvar = rt_restrictions_maxspeed_insane);
json_cvar_integer(json, "hold_use", 0, "Игрок должен удерживать E (+use) чтобы использовать труп^n0 - Достаточно просто нажать!", .cvar = rt_restrictions_hold_use);
json_cvar_integer(json, "view_cone", 0, "Игрок может взаимодействовать с трупом, только если он в зоне видимости его экрана", .cvar = rt_restrictions_view_cone);
json_cvar_string(json, "bad_hitzones", "0", "Игрок получит стандартный труп, если он был убит:^na - по умолчанию (generic)^nb - в голову^nc - в грудь^nd - в живот^ne - в левую руку^nf - в правую руку^ng - в левую ногу^nh - в правую ногу^nПримечание: Буквы можно использовать совместно!", .cvar = rt_restrictions_bad_hitzones, .len = charsmax(rt_restrictions_bad_hitzones));
json_cvar_integer(json, "full_restrictions", 0, "Некоторые запреты и ограничения будут действовать и на другие отношения по мимо командных!", .cvar = rt_restrictions_to_relations);
}

public plugin_cfg()
{
// Retrive plugin prefix (co.)
RT_GetPrefix(rt_prefix, 47);

g_pAccessFlag = read_flags_ex(rt_restrictions_access); // "flag":
g_pCorpseAccessFlag = read_flags_ex(rt_restrictions_corpse_flag); // "corpse_flag":
g_pCounterPlFlags = read_flags_ex(rt_restrictions_min_players_exclf); // "min_players_exclude":
g_pHitgroup = read_flags_ex(rt_restrictions_bad_hitzones); // "bad_hitzones":
}

public CBasePlayer_Spawn(const id)
{
// Сброс новых подключенных игроков
if (rg_is_user_first_spawn(id)) {
g_iRevivalsCount[id] = 0;
}
}

public CBasePlayer_ResetMaxSpeed(const id)
{
// Игрок не работает с трупом!
if (!RT_IsUsing(id)) {
return;
}

// "maxspeed":
if (rt_restrictions_maxspeed <= 0.0) {
return;
}

// "maxspeed":
set_entvar(id, var_maxspeed, rt_restrictions_maxspeed);
}

// Сброс лимитов
public CSGameRules_RestartRound()
{
arrayset(g_iRevivalsCount, 0, 33);
arrayset(g_iResurrectionsCount, 0, 33);
}

public RT_StartSneaking(const corpse_id, const owner, const model[], const Float:origin[3])
{
// "min_round":
if (rg_get_current_round() < rt_restrictions_min_round) {
// RT_ROUND = Воскрешать возможно будет с %d раунда!
return CORPSE_DEFAULT;
}

// "corpse_flag":
if (g_pCorpseAccessFlag > 0 && !(get_user_flags(owner) & g_pCorpseAccessFlag)) {
return CORPSE_DEFAULT;
}

// "bad_hitzones":
if (g_pHitgroup > 0 && (g_pHitgroup & BIT(get_member(owner, m_LastHitGroup)))) {
return CORPSE_DEFAULT;
}

return CORPSE_CUSTOM;
}

public RT_GotRespawn(const id, const friend)
{
g_iResurrectionsCount[id]++;
}

public RT_StartLoot_Pre(const corpse_id, const activator, const owner)
{
// Эти ограничения однозначно должны быть для команд
if (RT_RelationStatus(activator, owner) == RELATION_TEAMMATE)
{
if (rt_restrictions_team_allow > 0 && get_member(activator, m_iTeam) != rt_restrictions_team_allow) {
// RT_TEAM_NOT_ALLOW = Вашей команде запрещено воскрешать игроков!
client_print_color(activator, 0, "%s %l", rt_prefix, "RT_TEAM_NOT_ALLOW");
return RT_SUPERCEDE;
}

// "flag":
if (g_pAccessFlag > 0 && !(get_user_flags(activator) & g_pAccessFlag)) {
// RT_NO_ACCESS = У вас нет доступа к поднятию игроков!
client_print_color(activator, 0, "%s %l", rt_prefix, "RT_NO_ACCESS");
return RT_SUPERCEDE;
}

// "max_usage":
if (rt_restrictions_max_usage > 0 && g_iRevivalsCount[activator] >= rt_restrictions_max_usage) {
// RT_MAX_USAGE = Вы превысили количество воскрешений в этом раунде!
client_print_color(activator, 0, "%s %l", rt_prefix, "RT_MAX_USAGE", rt_restrictions_max_usage);
return RT_SUPERCEDE;
}

// "max_spawns":
if (rt_restrictions_max_spawns > 0 && g_iResurrectionsCount[owner] >= rt_restrictions_max_spawns) {
// RT_MAX_SPAWNS = Этот игрок уже воскрешался много раз в этом раунде!
client_print_color(activator, 0, "%s %l", rt_prefix, "RT_MAX_SPAWNS", rt_restrictions_max_spawns);
return RT_SUPERCEDE;
}
}

// Должен также быть и в RT_ThinkLoot
if (rt_restricted(corpse_id, activator, owner)) {
return RT_SUPERCEDE;
}

return RT_CONTINUE;
}

public RT_StartLoot_Post(const corpse_id, const activator, const owner, Float:duration)
{
// "block_attack":
if (rt_restrictions_block_attack) {
rg_flashlight(activator, false);
set_member(activator, m_bIsDefusing, true);

// Prevent C4 planting
new item = get_member(activator, m_pActiveItem);
if (!is_nullent(item) && get_member(item, m_iId) == WEAPON_C4) {
// client_printex(activator, print_center, "#C4_Arming_Cancelled");
set_member(item, m_C4_bStartedArming, false);
rg_weapon_send_animation(item, 0 /* C4_IDLE1 */, ExecuteHam(Ham_Weapon_UseDecrement, item) != 0);
rg_set_animation(activator, PLAYER_HOLDBOMB);
}
}

// "maxspeed":
if (rt_restrictions_maxspeed > 0.0) {
rg_reset_maxspeed(activator);
}

new restrictionMovementFlags;
GetControlledMovementFlags(restrictionMovementFlags);
if (restrictionMovementFlags > 0) {
set_entvar(activator, var_iuser3, get_entvar(activator, var_iuser3) | restrictionMovementFlags);
}
}

public RT_StopLoot(const corpse_id, const activator, const owner, bool:complete)
{
// "block_attack":
if (rt_restrictions_block_attack) {
set_member(activator, m_bIsDefusing, false);
}

// "maxspeed":
if (rt_restrictions_maxspeed >= 0.0) { // WTF
rg_reset_maxspeed(activator);
}

new restrictionMovementFlags;
GetControlledMovementFlags(restrictionMovementFlags);
if (restrictionMovementFlags > 0) {
set_entvar(activator, var_iuser3, get_entvar(activator, var_iuser3) & ~restrictionMovementFlags);
}

// Это означает что сопряжение прошло успешно
if (complete)
{
// Может это в RT_GotRespawn() ??
if (RT_RelationStatus(activator, owner) == RELATION_TEAMMATE) {
// "max_usage":
g_iRevivalsCount[activator]++;
}
}
}

public RT_ThinkLoot(const corpse_id, const activator, const owner, Float:time_ending)
{
// Некоторые квары требуют большего контроля игровым временем
if (rt_restricted(corpse_id, activator, owner)) {
return RT_SUPERCEDE;
}

// "maxspeed":
// "maxspeed_insane":
if (rt_restrictions_maxspeed_insane && rt_restrictions_maxspeed > 0.0) {
// rg_reset_maxspeed(activator);
set_entvar(activator, var_maxspeed, rt_restrictions_maxspeed);
}

return RT_CONTINUE;
}

bool:rt_restricted(const corpse_id, const activator, const owner)
{
// "full_restrictions":
if (!rt_restrictions_to_relations && RT_RelationStatus(activator, owner) != RELATION_TEAMMATE) {
return false;
}

// "hold_use":
if (rt_restrictions_hold_use && !(get_entvar(activator, var_button) & IN_USE)) {
return true;
}

// "view_cone":
if (rt_restrictions_view_cone && !ExecuteHam(Ham_FInViewCone, activator, corpse_id)) {
return true;
}

// "min_players":
// "min_players_exclude":
if (rt_restrictions_min_players > 0 && UTIL_PlayersInGame(g_pCounterPlFlags) < rt_restrictions_min_players) {
// RT_MIN_PLAYERS = Нехватка онлайна! Работает от^4 %d^1 игроков..
client_print_color(activator, 0, "%s %l", rt_prefix, "RT_MIN_PLAYERS", rt_restrictions_min_players);
return true;
}

// "vip_person":
if (rt_restrictions_vip_person && get_member(activator, m_bIsVIP)) {
// RT_VIP_PERSON = VIP персоны не могут поднимать союзников!
client_print_color(activator, 0, "%s %l", rt_prefix, "RT_VIP_PERSON");
return true;
}

// "domination":
if (rt_restrictions_domination > 0 && rg_get_team_wins_row(rt_restrictions_domination) == get_member(activator, m_iTeam)) {
// RT_DOMINATION = Ваша команда доминирует и одерживает %d побед подряд!
client_print_color(activator, 0, "%s %l", rt_prefix, "RT_DOMINATION", rt_restrictions_domination);
return true;
}

// "round_ended"
if (rt_restrictions_round_terminating && get_member_game(m_bRoundTerminating)) {
// RT_GAME_ENDING = Раунд окончен! Поднимать нельзя.
client_print_color(activator, 0, "%s %l", rt_prefix, "RT_GAME_ENDING");
return true;
}

// "on_ladder":
if (rt_restrictions_on_ladder && get_entvar(activator, var_movetype) == MOVETYPE_FLY) {
// RT_ON_LADDER = Вы не должны быть на лестнице!
client_print_color(activator, 0, "%s %l", rt_prefix, "RT_ON_LADDER");
return true;
}

// "waterlevel":
if (0 < get_entvar(activator, var_waterlevel) <= rt_restrictions_water_level) {
// RT_IN_WATER = Вы не должны находится в воде!
client_print_color(activator, 0, "%s %l", rt_prefix, "RT_IN_WATER");
return true;
}

// "time_expired":
if (!rg_is_time_expired(rt_restrictions_time_expired)) {
// RT_TIME_EXPIRED = Возможно только после %.0f сек. от начала раунда!
client_print_color(activator, 0, "%s %l", rt_prefix, "RT_TIME_EXPIRED", rt_restrictions_time_expired);
return true;
}

// "time_remaining":
if (0.0 < rg_get_remaining_time() < rt_restrictions_time_remaining) {
// RT_TIME_REMAINING = Нельзя за %.0f сек. до конца раунда!
client_print_color(activator, 0, "%s %l", rt_prefix, "RT_TIME_REMAINING", rt_restrictions_time_remaining);
return true;
}

// "bomb":
if (rt_restrictions_bomb_planted && rg_is_bomb_planted()) {
// RT_BOMB = Нельзя когда бомба уже установлена!
client_print_color(activator, 0, "%s %l", rt_prefix, "RT_BOMB");
return true;
}

new NumAliveT, NumAliveCT;
rg_initialize_player_counts(NumAliveT, NumAliveCT, _, _);

// "pvp":
if ((rt_restrictions_pvp == 1 && (NumAliveT == 1 && NumAliveCT == 1))
|| (rt_restrictions_pvp == 2 && (NumAliveT == 1 || NumAliveCT == 1))) {
// RT_PVP = Нельзя когда игроки остаются^4 1^1 на^4 1
client_print_color(activator, 0, "%s %l", rt_prefix, "RT_PVP");
return true;
}

// "players_difference":
new TeamName:plTeam = get_member(activator, m_iTeam);
if (rt_restrictions_players_difference > 0
&& ((plTeam == TEAM_TERRORIST && (NumAliveT - rt_restrictions_players_difference >= NumAliveCT))
|| (plTeam == TEAM_CT && (NumAliveCT - rt_restrictions_players_difference >= NumAliveT)))) {
// RT_PLAYERS_DIFF = В вашей команде перевес живых игроков^4 [> %d]
client_print_color(activator, 0, "%s %l", rt_prefix, "RT_PLAYERS_DIFF", rt_restrictions_players_difference);
return true;
}

// Ничего не мешает, можно продолжать!
return false;
}

GetControlledMovementFlags(&flags)
{
flags = 0;

// "can_jump";
if (!rt_restrictions_can_jump) {
flags |= PLAYER_PREVENT_JUMP;
}

// "can_duck":
if (!rt_restrictions_can_duck) {
flags |= PLAYER_PREVENT_DUCK;
}

// "maxspeed":
if (rt_restrictions_maxspeed > 0.0)
{
if (rt_restrictions_maxspeed <= 1.0) {
flags |= PLAYER_PREVENT_CLIMB;
}

// "maxspeed_insane":
if (rt_restrictions_maxspeed_insane) {
// rg_reset_maxspeed(activator);
}
}
}

stock UTIL_PlayersInGame(const skipF)
{
new plCount = 0;
for (new i = MaxClients; i > 0; --i)
{
if (!is_user_connected(i)) {
continue;
}

if (skipF & BIT(0)) {
if (!VALID_TEAM(i)) {
continue;
}
}
if (skipF & BIT(1)) {
if (is_user_bot(i)) {
continue;
}
}

plCount++;
}

return plCount;
}

stock UTIL_BlinkAcct(const id, const times, bool:bAlertMessage = false)
{
static msgBlinkAcct;
if (msgBlinkAcct > 0 || (msgBlinkAcct = get_user_msgid("BlinkAcct")) > 0)
{
message_begin(MSG_ONE_UNRELIABLE, msgBlinkAcct, .player = id);
write_byte(times);
message_end();
}

if (bAlertMessage) {
client_printex(id, print_center, "#Not_Enough_Money");
}
}

stock TeamName:rg_get_team_wins_row(const wins)
{
if (get_member_game(m_iNumConsecutiveCTLoses) >= wins) {
return TEAM_TERRORIST;
}
else if (get_member_game(m_iNumConsecutiveTerroristLoses) >= wins) {
return TEAM_CT;
}

// No way to take a strongest team
return TEAM_UNASSIGNED;
}

stock rg_flashlight(id, bool:bMode = true)
{
new flags = get_entvar(id, var_effects);
set_entvar(id, var_effects, bMode ? (flags |= EF_DIMLIGHT) : (flags &= ~EF_DIMLIGHT));

static msgFlashlight;
if (msgFlashlight > 0 || (msgFlashlight = get_user_msgid("Flashlight")) > 0)
{
message_begin(MSG_ONE, msgFlashlight, .player = id);
write_byte(_:bMode); // toggle
write_byte(get_member(id, m_iFlashBattery));
message_end();
}
}

stock rg_get_current_round()
{
return (get_member_game(m_iTotalRoundsPlayed) + 1);
}

stock rg_is_time_expired(Float:fSec)
{
// FIX: m_fRoundStartTime
return (get_gametime() - Float:get_member_game(m_fRoundStartTimeReal) > fSec);
}

stock bool:rg_is_user_first_spawn(const id)
{
return (get_member(id, m_iNumSpawns) == 1);
}

stock Float:rg_get_remaining_time()
{
new pGrenade = rg_find_grenade_c4();

if (pGrenade > 0) {
// Если у нас установленна бомба то время до конца раунда будет определять уже она
// Потому как время может уйти в минус!
return (Float:get_member(pGrenade, m_Grenade_flC4Blow) - get_gametime());
}

return (float(get_member_game(m_iRoundTimeSecs)) - get_gametime() + Float:get_member_game(m_fRoundStartTimeReal));
}

stock rg_find_grenade_c4()
{
if (!get_member_game(m_bMapHasBombTarget)) {
return 0;
}

new pGrenade = NULLENT;

while ((pGrenade = rg_find_ent_by_class(pGrenade, "grenade")) > 0)
{
if (get_member(pGrenade, m_Grenade_bIsC4))
{
return pGrenade;
}
}

return 0;
}[/code][/spoiler]

[spoiler title=rt_respawn_features.sma][code]#include <amxmodx>
#include <fakemeta>
#include <reapi>
#include <xs>
#include <revive_teammates>

// Cvars
new rt_rf_spot;
new rt_rf_unstuck;
new rt_rf_unstuck_ignore_monsters;

// Vars
new Float:g_VecCorpseOrigin[3];

public plugin_init()
{
register_plugin("RT: Respawn Features", RT_VERSION_STR, "@emmajule");

// RegisterHookChain(RG_CBasePlayer_OnSpawnEquip, "CBasePlayer_OnSpawnEquip", false);
// RegisterHookChain(RG_CBasePlayer_EntSelectSpawnPoint, "CBasePlayer_EntSelectSpawnPoint", false);
RegisterHookChain(RG_CSGameRules_GetPlayerSpawnSpot, "CSGameRules_GetPlayerSpawnSpot", false);
}

public RT_ParseConfigFile(JSON:json)
{
json_cvar_integer(json, "spot", 1, "Место спавна воскрешенного игрока^n0 - На респе^n1 - На том месте где погиб (заспавнен труп)", .cvar = rt_rf_spot);
json_cvar_integer(json, "unstuck", 0, "Автоматический поиск свободной точки, рядом с местом смерти!^nИспользуйте, если вы наблюдаете проблемы при спавне путем застревания в каком-нибудь обьекте", .cvar = rt_rf_unstuck);
json_cvar_integer(json, "unstuck_ignore_monsters", 0, "Не считать монстров как за препятствующий обьект.^nЭто может быть полезно, если у вас имеется возможность прохождения сквозь игроков", .cvar = rt_rf_unstuck_ignore_monsters);
}

public CBasePlayer_OnSpawnEquip(const id, bool:addDefault, bool:equipGame)
{
if (!RT_fSpawned()) {
return HC_CONTINUE;
}

SetHookChainArg(3, ATYPE_BOOL, false);
return HC_CONTINUE;
}

public CSGameRules_GetPlayerSpawnSpot(const id)
{
// "spot":
if (rt_rf_spot == 0) {
return HC_CONTINUE;
}

if (get_member(id, m_bJustConnected)) {
return HC_CONTINUE;
}

if (!RT_fSpawned()) {
return HC_CONTINUE;
}

new Float:flVecPos[3];
xs_vec_copy(g_VecCorpseOrigin, flVecPos);

// "unstuck":
if (rt_rf_unstuck) {
new Float:flRad = 12.0;
new Float:flAngle = 0.0;
new Float:flDistToFloor = 32.0;

while (!IsHullVacant(flVecPos, HULL_HEAD) || TextureBetweenPoints(flVecPos, g_VecCorpseOrigin) || fm_distance_to_floor(flVecPos) > flDistToFloor) {
flVecPos[0] = flVecPos[0] + (flRad * floatcos(flAngle, degrees));
flVecPos[1] = flVecPos[1] + (flRad * floatsin(flAngle, degrees));

// Rotate angles
flAngle += 8.0;
if (flAngle > 360.0) {
flAngle = 0.0;
flRad += 4.0;
}

// Nothing to found, try to incrase distance to floor
if (flRad > 160.0) {
flRad = 12.0;
flDistToFloor += 32.0;
}

if (flDistToFloor > 128.0) {// approx 20 feet
flVecPos[0] = random_float(g_VecCorpseOrigin[0] - flRad, g_VecCorpseOrigin[0] + flRad);
flVecPos[1] = random_float(g_VecCorpseOrigin[1] - flRad, g_VecCorpseOrigin[1] + flRad);
flVecPos[2] = random_float(g_VecCorpseOrigin[2] - flRad, g_VecCorpseOrigin[2] + flRad);
}
}
}

set_entvar(id, var_flags, get_entvar(id, var_flags) | FL_DUCKING);
// set_entvar(id, var_button, get_entvar(id, var_button) | IN_DUCK);
set_entvar(id, var_view_ofs, Float:{0.0, 0.0, 12.0});

set_entvar(id, var_origin, flVecPos);
set_entvar(id, var_velocity, NULL_VECTOR);
set_entvar(id, var_v_angle, NULL_VECTOR);
set_entvar(id, var_punchangle, NULL_VECTOR);
set_entvar(id, var_fixangle, 1);

SetHookChainReturn(ATYPE_INTEGER, 0);
return HC_SUPERCEDE;
}

public RT_StartSneaking(const corpse_id, const owner, const model[], const Float:origin[3])
{

}

public RT_StopLoot(const corpse_id, const activator, const owner, bool:complete)
{
if (!complete) {
return RT_CONTINUE;
}

// Retrive latests corpse position
get_entvar(corpse_id, var_origin, g_VecCorpseOrigin);
return RT_CONTINUE;
}

// projects a center of a player's feet base (originally by P34nut, improved)
stock Float:fm_distance_to_floor(const Float:originF[3], ignoremonsters = 1) {
new Float:dest[3], Float:end[3];
dest[0] = originF[0];
dest[1] = originF[1];
dest[2] = -8191.0;

engfunc(EngFunc_TraceLine, originF, dest, ignoremonsters, 0, 0);
get_tr2(0, TR_vecEndPos, end);

dest[2] = originF[2] - 36.0;
new Float:ret = dest[2] - end[2];

return ret > 0 ? ret : 0.0;
}

// Checks if a space is vacant, by VEN
stock bool:IsHullVacant(const Float:originF[3], hull) {
new tracehandle;
engfunc(EngFunc_TraceHull, originF, originF, fNoMonsters(), hull, 0, tracehandle);
if (get_tr2(tracehandle, TR_StartSolid) || get_tr2(tracehandle, TR_AllSolid) || !get_tr2(tracehandle, TR_InOpen)) {
return false;
}

return true;
}

// t3rkecorejz
stock bool:TextureBetweenPoints(const Float:to[3], const Float:move[3]) {
if (xs_vec_equal(move, to)) {
return false;
}

new tracehandle = create_tr2();
engfunc(EngFunc_TraceLine, move, to, IGNORE_MONSTERS, 0, tracehandle);

new Float:end[3];
get_tr2(tracehandle, TR_vecEndPos, end);
free_tr2(tracehandle);

return !xs_vec_equal(to, end);
}

stock fNoMonsters() {
// "unstuck_ignore_monsters":
if (rt_rf_unstuck_ignore_monsters) {
return IGNORE_MONSTERS;
}

return DONT_IGNORE_MONSTERS;
}[/code][/spoiler]

[spoiler title=rt_model_support.sma][code]#include <amxmodx>
#include <fakemeta>
#include <reapi>
#include <xs>
#include <revive_teammates>

// Custom Player Models (https://hlds.run/resources/182/)
native bool:custom_player_models_get_body(const player, const any:team, &body);
native bool:custom_player_models_get_skin(const player, const any:team, &skin);
native bool:custom_player_models_get_path(const player, path[] = "", length = 0);

new const CORPSE_MODEL_CLASSNAME[] = "corpse_model";

// Cvars
new rt_ms_skin;
new rt_ms_cl_minmodels;
new rt_ms_CPM;
new rt_ms_size_from_file;
new rt_ms_corpse_model_te[64];
new rt_ms_corpse_model_te_entity;
new rt_ms_corpse_model_te_body;
new rt_ms_corpse_model_te_skin;
new rt_ms_corpse_model_te_sequence;
new Float:rt_ms_corpse_model_te_sprite_frame;
new Float:rt_ms_corpse_model_te_sprite_scale;
new Float:rt_ms_corpse_model_te_offset_Z;
new rt_ms_corpse_model_ct[64];
new rt_ms_corpse_model_ct_entity;
new rt_ms_corpse_model_ct_body;
new rt_ms_corpse_model_ct_skin;
new rt_ms_corpse_model_ct_sequence;
new Float:rt_ms_corpse_model_ct_sprite_frame;
new Float:rt_ms_corpse_model_ct_sprite_scale;
new Float:rt_ms_corpse_model_ct_offset_Z;

// Vars
new g_iSkin[33];

public plugin_init()
{
register_plugin("RT: Models support", RT_VERSION_STR, "@emmajule");

RegisterHookChain(RG_CBasePlayer_Killed, "CBasePlayer_Killed", true);
}

public RT_ParseConfigFile(JSON:json)
{
json_cvar_integer(json, "skin_support", 0, "Поддержка субмоделей^nАктивируйте если вы используете субмодели (pev->skin) в моделях игроков, вместо body", .cvar = rt_ms_skin);
json_cvar_integer(json, "cl_minmodels_support", 0, "Поддержка клиентов с активным кваром cl_minmodels 1^nОбратите внимание что функция не совместима если вы используете цветную подсветку у трупов, или какую-либо прозрачность!", .cvar = rt_ms_cl_minmodels);
json_cvar_integer(json, "CPM_support", 0, "Поддержка плагина Custom Player Models от BlackSignature (только от версии 0.0.24 и выше)^nПодробности: https://hlds.run/resources/182/", .cvar = rt_ms_CPM);
json_cvar_integer(json, "size_from_file", 0, "Будет брать размеры объекта напрямую с файла модели, если это возможно", .cvar = rt_ms_size_from_file);
json_cvar_string(json, "corpse_model_te", "", "Модель трупа для команды TERRORIST^nВсе игроки этой команды будут иметь единую модель с этой настройки!", .cvar = rt_ms_corpse_model_te, .len = charsmax(rt_ms_corpse_model_te), .precache = true);
json_cvar_integer(json, "corpse_model_te_entity", 0, "Модель будет отдельно от трупа^n0 - Изменения будут на сам труп!", .cvar = rt_ms_corpse_model_te_entity);
json_cvar_integer(json, "corpse_model_te_body", 0, "Номер субмодели (pev->body)", .cvar = rt_ms_corpse_model_te_body);
json_cvar_integer(json, "corpse_model_te_skin", 0, "Номер субмодели (pev->skin)", .cvar = rt_ms_corpse_model_te_skin);
json_cvar_integer(json, "corpse_model_te_sequence", -1, "Номер проигрываемой анимации модели (если используется)", .cvar = rt_ms_corpse_model_te_sequence);
json_cvar_float(json, "corpse_model_te_sprite_frame", -1.0, "Номер кадра (pev->frame)^nМожет быть полезно, если вы используете спрайт вместо модели.", .cvar = rt_ms_corpse_model_te_sprite_frame);
json_cvar_float(json, "corpse_model_te_sprite_scale", 0.0, "Размер спрайта", .cvar = rt_ms_corpse_model_te_sprite_scale);
json_cvar_float(json, "corpse_model_te_offset_Z", 0.0, "Поднятие модели согласно позиции Z^nИспользуйте отрицательное значение чтобы напротив опустить!", .cvar = rt_ms_corpse_model_te_offset_Z);
json_cvar_string(json, "corpse_model_ct", "", "Модель трупа для команды CT^nВсе игроки этой команды будут иметь единую модель с этой настройки!", .cvar = rt_ms_corpse_model_ct, .len = charsmax(rt_ms_corpse_model_ct), .precache = true);
json_cvar_integer(json, "corpse_model_ct_entity", 0, "Модель будет отдельно от трупа^n0 - Изменения будут на сам труп!", .cvar = rt_ms_corpse_model_ct_entity);
json_cvar_integer(json, "corpse_model_ct_body", 0, "Номер субмодели (pev->body)", .cvar = rt_ms_corpse_model_ct_body);
json_cvar_integer(json, "corpse_model_ct_skin", 0, "Номер субмодели (pev->skin)", .cvar = rt_ms_corpse_model_ct_skin);
json_cvar_integer(json, "corpse_model_ct_sequence", -1, "Номер проигрываемой анимации модели (если используется)", .cvar = rt_ms_corpse_model_ct_sequence);
json_cvar_float(json, "corpse_model_ct_sprite_frame", -1.0, "Номер кадра (pev->frame)^nМожет быть полезно, если вы используете спрайт вместо модели.", .cvar = rt_ms_corpse_model_ct_sprite_frame);
json_cvar_float(json, "corpse_model_ct_sprite_scale", 0.0, "Размер спрайта", .cvar = rt_ms_corpse_model_ct_sprite_scale);
json_cvar_float(json, "corpse_model_ct_offset_Z", 0.0, "Поднятие модели согласно позиции Z^nИспользуйте отрицательное значение чтобы напротив опустить!", .cvar = rt_ms_corpse_model_ct_offset_Z);
}

public RT_StartSneaking(const corpse_id, const owner, const model[], const Float:origin[3])
{
// "cl_minmodels_support":
if (rt_ms_cl_minmodels) {
set_entvar(corpse_id, var_renderfx, kRenderFxDeadPlayer); /* kRenderAmt is the player index */
set_entvar(corpse_id, var_renderamt, float(owner));
}

// "skin_support":
if (rt_ms_skin) {
// FIX: pev->skin уже 0 на момент отправки ClCorpse
set_entvar(corpse_id, var_skin, g_iSkin[owner]);
}

// "CPM_support":
if (rt_ms_CPM) {
new path[64], body, skin;
if (custom_player_models_get_path(owner, path, 63)) {
SET_MODEL(corpse_id, path);
new team = get_entvar(corpse_id, var_team);
custom_player_models_get_body(owner, team, body);
custom_player_models_get_skin(owner, team, skin);
set_entvar(corpse_id, var_body, body);
set_entvar(corpse_id, var_skin, skin);
}
}

// "size_from_file":
if (rt_ms_size_from_file) {
new Float:flMins[3], Float:flMaxs[3];
UTIL_GetModelHitBox(model, flMins, flMaxs);
SET_SIZE(corpse_id, flMins, flMaxs);
#if 0
server_print("model <%s> mins: %f %f %f maxs: %f %f %f",
model, flMins[0], flMins[1], flMins[2], flMaxs[0], flMaxs[1], flMaxs[2]
);
#endif
}

new Float:corpseOrigin[3];
xs_vec_copy(origin, corpseOrigin);
new TeamName:corpse_team = get_entvar(corpse_id, var_team);
new entity = corpse_id;

// "corpse_model_te":
if (corpse_team == TEAM_TERRORIST && !FNullString(rt_ms_corpse_model_te)) {
if (rt_ms_corpse_model_te_entity) { // "corpse_model_te_entity":
entity = rg_create_entity("info_target");
set_entvar(entity, var_classname, CORPSE_MODEL_CLASSNAME);
set_entvar(entity, var_owner, corpse_id);
}
SET_MODEL(entity, rt_ms_corpse_model_te);
set_entvar(entity, var_body, rt_ms_corpse_model_te_body); // "corpse_model_te_body":
set_entvar(entity, var_skin, rt_ms_corpse_model_te_skin); // "corpse_model_te_skin":
set_entvar(entity, var_scale, rt_ms_corpse_model_te_sprite_scale); // "corpse_model_te_sprite_scale":
rg_animate_entity(entity, rt_ms_corpse_model_te_sequence, rt_ms_corpse_model_te_sprite_frame, 1.0); // "corpse_model_te_sequence":
corpseOrigin[2] += rt_ms_corpse_model_te_offset_Z; // "corpse_model_te_offset_Z":
SET_ORIGIN(entity, corpseOrigin);
}
// "corpse_model_ct":
else if (corpse_team == TEAM_CT && !FNullString(rt_ms_corpse_model_ct)) {
if (rt_ms_corpse_model_ct_entity) { // "corpse_model_ct_entity":
entity = rg_create_entity("info_target");
set_entvar(entity, var_classname, CORPSE_MODEL_CLASSNAME);
set_entvar(entity, var_owner, corpse_id);
}
SET_MODEL(entity, rt_ms_corpse_model_ct);
set_entvar(entity, var_body, rt_ms_corpse_model_ct_body); // "corpse_model_ct_body":
set_entvar(entity, var_skin, rt_ms_corpse_model_ct_skin); // "corpse_model_ct_skin":
set_entvar(entity, var_scale, rt_ms_corpse_model_ct_sprite_scale); // "corpse_model_ct_sprite_scale":
rg_animate_entity(entity, rt_ms_corpse_model_ct_sequence, rt_ms_corpse_model_ct_sprite_frame, 1.0); // "corpse_model_ct_sequence":
corpseOrigin[2] += rt_ms_corpse_model_ct_offset_Z; // "corpse_model_ct_offset_Z":
SET_ORIGIN(entity, corpseOrigin);
}

return CORPSE_CUSTOM;
}

// Remove entities
public RT_StopSneaking(const corpse_id, const owner)
{
new pEntity = NULLENT;
while ((pEntity = rg_find_ent_by_class(pEntity, CORPSE_MODEL_CLASSNAME)) > 0) {
if (get_entvar(pEntity, var_owner) == corpse_id) {
rg_remove_entity(pEntity);
break;
}
}
}

public CBasePlayer_Killed(const id, pevAttacker, iGib) {
g_iSkin[id] = get_entvar(id, var_skin);
}

// https://hlds.run/threads/81/#post-1636
stock UTIL_GetModelHitBox(const szModel[], Float:flMins[3], Float:flMaxs[3])
{
new hFile = fopen(szModel, "rb");

if (!hFile) {
server_print("Can't open %s", szModel);
return false;
}

fseek(hFile, 160, SEEK_SET);

new iBlock;
fread(hFile, iBlock, BLOCK_INT);
fseek(hFile, iBlock + 8, SEEK_SET);

new Float: flVec[6];
fread_blocks(hFile, _:flVec, 6, BLOCK_INT);
fclose(hFile);

for (new i; i < 3; i++) {
flMins[i] = flVec[i];
flMaxs[i] = flVec[i + 3];
}

return true;
}

stock rg_animate_entity(const entity, const sequence = -1, const Float:frame = -1.0, const Float:framerate = 0.0) {
if (frame != -1) {
set_entvar(entity, var_frame, frame);
}

if (sequence != -1) {
set_entvar(entity, var_sequence, sequence);
}

set_entvar(entity, var_framerate, framerate);
}

// mx?!
public plugin_natives() {
set_native_filter("native_filter_handler");
}

public native_filter_handler(const native_func[], index, trap) {
if (equal(native_func, "custom_player_models_get_body")) {
return 1;
}

if (equal(native_func, "custom_player_models_get_skin")) {
return 1;
}

if (equal(native_func, "custom_player_models_get_path")) {
return 1;
}

return 0;
}[/code][/spoiler]

[spoiler title=rt_mined_enemies.sma][code]#include <amxmodx>
#include <reapi>
#include <hamsandwich>
#include <xs>
#include <revive_teammates>

stock const EntVars:var_miner = var_iuser2;
// #define ptrMiner(%0) (get_entvar(%0, var_miner))

// Cvars
new rt_prefix[48];
new rt_mined_access[16];
new rt_mined_team_allow;
new rt_mined_max_usage;
new rt_mined_mode;
new rt_mined_progress_bar;
new Float:rt_mined_progress_duration;
new Float:rt_mined_explode_radius;
new Float:rt_mined_explode_damage;
new Float:rt_mined_takedamage_knockback;
new Float:rt_mined_takedamage_velmod;
new rt_mined_damage_from_radius;
new rt_mined_bypass;
new rt_mined_owner;
new rt_mined_gibs;
new rt_mined_remove_corpse;
new rt_mined_sound[64];
new rt_mined_explode_effects;
new rt_mined_explode_sound[64];
new rt_mined_explode_sprite[64];
new rt_mined_explode_sprite_count;
new rt_mined_explode_sprite_scale;
new Float:rt_mined_explode_sprite_offset;
new rt_mined_alertf[16];

enum {
DETONATION_AFTER_RESURRECTION = 0,
DETONATION_INSTANTLY,
DETONATION_BY_OWNER
};

enum (<<=1) {
RT_EFFECT_ALERT_OFF = 0,
RT_EFFECT_ALERT_CHAT = 1,
RT_EFFECT_ALERT_CENTER,
RT_EFFECT_ALERT_HUD,
};

// Vars
new g_iMinedCorpses[33];
new g_pAccessFlag;
new g_Alert;

new g_sModelIndexFireball;
new g_cSoundExplosionDisabled;

public plugin_init()
{
register_plugin("RT: Mined Enemies", RT_VERSION_STR, "@emmajule");

RegisterHookChain(RG_CBasePlayer_UseEmpty, "CBasePlayer_UseEmpty", true);
RegisterHookChain(RG_CSGameRules_RestartRound, "CSGameRules_RestartRound", true);
}

public RT_ParseConfigFile(JSON:json)
{
json_cvar_string(json, "flag", "", "Флаг(и) доступа к минированию врагов!^n0 или '' - Для всех", .cvar = rt_mined_access, .len = charsmax(rt_mined_access));
json_cvar_integer(json, "team_allow", 0, "Какая команда получит доступ к минированию вражеских трупов^n0 - могут все!^n1 - исключительно игроки команды TERRORIST^n2 - исключительно игроки команды CT", .has_max = true, .max_val = 2, .cvar = rt_mined_team_allow);
json_cvar_integer(json, "max_usage", 2, "Сколько максимально сможет минировать трупов 1 игрок за раунд", .cvar = rt_mined_max_usage);
json_cvar_integer(json, "mined_mode", 0, "Режим активации взрыва:^n0 - после процесса (когда враг закончит процесс поднятия товарища)^n1 - моментально (сразу как враг начал поднимать товарища)^n2 - дистанционно (все заминированные трупы игрока взорвутся, после того как игрок нажал дважды E)", .cvar = rt_mined_mode);
json_cvar_integer(json, "progress_bar", 1, "Полоска прогресса минирования", .cvar = rt_mined_progress_bar);
json_cvar_float(json, "progress_duration", 0.0, "Время минирования трупа^nОставьте 0, если хотите чтоб оно было таким же как и время на поднятие товарища!", .cvar = rt_mined_progress_duration);
json_cvar_float(json, "radius", 350.0, "Максимальный допустимый радиус поражения", .has_min = true, .min_val = 64.0, .cvar = rt_mined_explode_radius);
json_cvar_float(json, "damage", 250.0, "Урон от взрыва", .has_min = true, .min_val = 10.0, .cvar = rt_mined_explode_damage);
json_cvar_float(json, "pain_velmod", 0.0, "'Болевой шок' если игрок выжил от полученного урона", .has_min = true, .min_val = 0.0, .has_max = true, .max_val = 1.0, .cvar = rt_mined_takedamage_velmod);
json_cvar_float(json, "pain_knockback", 0.0, "Сила отброса, если игрок выжил от полученного урона", .cvar = rt_mined_takedamage_knockback);
json_cvar_integer(json, "gibs", 0, "Игроки которые умерли от взрыва заминированного игрока, превратятся в ошметки^nПримечание: при такой смерти труп игрока не создается, т.е его не смогут поднять вражеские товарищи..", .cvar = rt_mined_gibs);
json_cvar_integer(json, "damage_from_radius", 1, "Урон будет зависить от радиуса, чем дальше игрок тем меньше урона он получит", .cvar = rt_mined_damage_from_radius);
json_cvar_integer(json, "mined_bypass", 0, "Заминированный труп можно заминировать вновь, если тот, кто его заминировал - покинул сервер!", .cvar = rt_mined_bypass);
json_cvar_integer(json, "mined_owner", 0, "Заминированный труп будет активен только, если на сервере присутствует тот, кто его заминировал", .cvar = rt_mined_owner);
json_cvar_integer(json, "remove_corpse", 1, "Что делать с трупом после взрыва?^n1 - удалить^n0 - оставить как есть (он снова будет заминирован)^n-1 - оставить как есть и убрать метку минирования (он снова будет доступен для минирования/воскрешения)", .cvar = rt_mined_remove_corpse);
json_cvar_string(json, "mined_sound", "weapons/c4_disarm.wav", "Звук при успешном минировании трупа!", .cvar = rt_mined_sound, .len = charsmax(rt_mined_sound), .precache = true);
json_cvar_integer(json, "explode_effects", 1, "Эффекты взврыва при детонации заминированного трупа", .cvar = rt_mined_explode_effects);
json_cvar_string(json, "explode_sprite", "sprites/fexplo.spr", "Спрайт взрыва!^nИспользуйте 0 или '' - если хотите полностью исключить звук!", .cvar = rt_mined_explode_sprite, .len = charsmax(rt_mined_explode_sprite), .precache = true, .cache_id = g_sModelIndexFireball);
json_cvar_integer(json, "sprite_count", 2, "Количество спрайтов которые будут проиграны вокруг цели", .has_min = true, .min_val = 1, .cvar = rt_mined_explode_sprite_count);
json_cvar_integer(json, "sprite_scale", 30, "Размер спрайта", .cvar = rt_mined_explode_sprite_scale);
json_cvar_float(json, "sprite_offset", 0.0, "Оффсет поднятия спрайта от стартовой позиции в мире^nИспользуйте отрицательное значение, тогда это будет напротив, опускать спрайт!", .cvar = rt_mined_explode_sprite_offset);
json_cvar_string(json, "explode_sound", "", "Звук взрыва трупа!^nПри пустом значении или '0' будет использоваться стандартный звук взрыва гранаты.^nИспользуйте 'off' - если хотите полностью исключить звук!", .cvar = rt_mined_explode_sound, .len = charsmax(rt_mined_explode_sound), .precache = true);
json_cvar_string(json, "alert_flags", "c", "Уведомления при минировании^na - в чат^nb - по центру экрана^nc - HUD (плавное сообщение)^nПримечание: можно использовать посовместно (abc)^n'' или 0 - отключено", .cvar = rt_mined_alertf, .len = charsmax(rt_mined_alertf));
}

public plugin_cfg()
{
// Retrive plugin prefix (co.)
RT_GetPrefix(rt_prefix, 47);

// Deprecated !!
// RT_Set_Relation(RELATION_ENEMY, true);

g_cSoundExplosionDisabled = equali(rt_mined_explode_sound, "OFF"); // "explode_sound":
g_pAccessFlag = read_flags_ex(rt_mined_access); // "flag":
g_Alert = read_flags_ex(rt_mined_alertf); // "alert_flags":

// "remove_corpse":
if (rt_mined_remove_corpse == 0 && rt_mined_mode == DETONATION_BY_OWNER) {
rt_mined_remove_corpse = -1;
}
}

// Сброс лимитов
public CSGameRules_RestartRound()
{
arrayset(g_iMinedCorpses, 0, 33);
}

public CBasePlayer_UseEmpty(const id)
{
// "mined_mode":
if (rt_mined_mode != DETONATION_BY_OWNER) {
return;
}

static Float:flNextUseTime[33];
new Float:gameTime = get_gametime();

if (flNextUseTime[id] > gameTime)
{
new corpse_id = rg_find_ent_by_class(-1, CORPSE_CLASSNAME);
while (corpse_id > 0)
{
// Поиск трупов заминированным игроком!
if (ptrMiner(corpse_id) != id)
{

}
else
{
// Детонация
rt_corpse_explode(corpse_id);
}

// See next
corpse_id = rg_find_ent_by_class(corpse_id, CORPSE_CLASSNAME);
}

flNextUseTime[id] = 0.0;
}
else
{
// Control time for next click?
flNextUseTime[id] = gameTime + 0.2;
}
}

public RT_RelationConditions(const player, const target)
{
// Помечаем как новый вид отношений между игроками вражеских команд
if (get_member(player, m_iTeam) != get_member(target, m_iTeam)) {
return RELATION_ENEMY;
}

return RELATION_NONE;
}

public RT_StartLoot_Pre(const corpse_id, const activator, const owner)
{
// Смотрим на новый тип отношений
if (RT_RelationStatus(activator, owner) != RELATION_ENEMY) {
return RT_CONTINUE;
}

if (rt_mined_team_allow > 0 && get_member(activator, m_iTeam) != rt_mined_team_allow) {
// RT_MINED_TEAM_NOT_ALLOW = Вашей команде запрещено минировать игроков!
client_print_color(activator, 0, "%s %l", rt_prefix, "RT_MINED_TEAM_NOT_ALLOW");
return RT_SUPERCEDE;
}

// "flag":
if (g_pAccessFlag > 0 && !(get_user_flags(activator) & g_pAccessFlag)) {
// RT_MINED_NO_ACCESS = У вас нет доступа к минированию игроков!
client_print_color(activator, 0, "%s %l", rt_prefix, "RT_MINED_NO_ACCESS");
return RT_SUPERCEDE;
}

// "max_usage":
if (rt_mined_max_usage > 0 && g_iMinedCorpses[activator] >= rt_mined_max_usage) {
// RT_MINED_MAX_USAGE = Вы достигли лимита!^1 (не более^4 %d^1 минирований за раунд!)
client_print_color(activator, 0, "%s %l", rt_prefix, "RT_MINED_MAX_USAGE", rt_mined_max_usage);
return RT_SUPERCEDE;
}

// Труп уже заминирован?
new bool:CorpseMined = IsMined(corpse_id, activator);
if (CorpseMined)
{
new pMiner = ptrMiner(corpse_id);
if (pMiner == 0) {
// "mined_bypass":
if (rt_mined_bypass) {
return RT_CONTINUE;
}
// RT_MINED_ALREADY = Этот враг уже заминирован!
client_print_color(activator, 0, "%s %l", rt_prefix, "RT_MINED_ALREADY");
} else {
// RT_MINED_ALREADY_BY = Этот враг уже заминирован товарищем^4 %n!
client_print_color(activator, 0, "%s %l", rt_prefix, "RT_MINED_ALREADY_BY", pMiner);
}

return RT_SUPERCEDE;
}

return RT_CONTINUE;
}

public RT_StartLoot_Post(const corpse_id, const activator, const owner, Float:duration)
{
// What is the player's relationship with this entity?
new relation = RT_RelationStatus(activator, owner);

// "mined_mode":
if (rt_mined_mode == DETONATION_INSTANTLY && relation == RELATION_TEAMMATE)
{
// Если труп заминирован -> происходит детонация!
if (IsMined(corpse_id, activator))
{
// Бум!
rt_corpse_explode(corpse_id);
return;
}
}

// Дальнейший код исключительно для минирования вражеских трупов!
if (relation != RELATION_ENEMY) {
return;
}

new Float:flDuration = duration;

// Кастомное время минирования
if (rt_mined_progress_duration > 0.0) {
// "progress_duration":
flDuration = rt_mined_progress_duration;
// Нужно обновить время
RT_ProcessionTimerChange(corpse_id, flDuration);
}

if (rt_mined_progress_bar && flDuration > 0.75) {
// "progress_bar":
rg_send_bartime(activator, floatround(flDuration), .observer = true);
}

// Уведомления
if (g_Alert & RT_EFFECT_ALERT_CHAT)
{
// RT_PRINT_CHAT_MINING = Вы минируете^3 %n^1 (продержитесь^4 %.0f^1 сек.)
client_print_color(activator, owner, "%s %l", rt_prefix, "RT_PRINT_CHAT_MINING", owner, flDuration);
}

if (g_Alert & RT_EFFECT_ALERT_CENTER)
{
// RT_PRINT_CENTER_MINING = Вы минируете %n^rПродержитесь %.0f сек.
client_print(activator, print_center, "%l", "RT_PRINT_CENTER_MINING", owner, flDuration);
}

if (g_Alert & RT_EFFECT_ALERT_HUD)
{
// RT_PRINT_HUD_MINING = Вы минируете %n^nПродержитесь %.0f сек.
set_dhudmessage(30, 200, 150, -1.0, 0.76, 2, 3.0, 2.0, 0.03, 0.4);
show_dhudmessage(activator, "%l", "RT_PRINT_HUD_MINING", owner, flDuration);
}
}

public RT_StopLoot(const corpse_id, const activator, const owner, bool:complete)
{
// What is the player's relationship with this entity?
new relation = RT_RelationStatus(activator, owner);

// Прогресс завершен!
if (complete)
{
// "mined_mode":
if (relation == RELATION_TEAMMATE && rt_mined_mode == DETONATION_AFTER_RESURRECTION)
{
// Если труп заминирован происходит детонация!
if (IsMined(corpse_id, activator))
{
// Бум!
rt_corpse_explode(corpse_id);
return RT_SUPERCEDE;
}
}
// Завершение процесса минирования
else if (relation == RELATION_ENEMY)
{
// Учет количества минирований
g_iMinedCorpses[activator]++;

// Метка владельца заминированного трупа
set_entvar(corpse_id, var_miner, get_user_userid(activator));

// RT_MINING_SUCESSFULLY = Труп успешно заминирован!
client_print_color(activator, owner, "%s %l", rt_prefix, "RT_MINING_SUCESSFULLY", owner);

// Со звуком
if (!FNullString(rt_mined_sound)) {
// "mined_sound":
rh_emit_sound2(corpse_id, 0, CHAN_AUTO, rt_mined_sound);
}

// Предотвращение оригинального сценария
return RT_SUPERCEDE;
}
}
else if (relation == RELATION_ENEMY && rt_mined_progress_bar) {
// "progress_bar":
rg_send_bartime(activator, 0);
}

return RT_CONTINUE;
}

// Событие взрыва
rt_corpse_explode(const corpse_id)
{
// "explode_effects":
if (rt_mined_explode_effects) {
static Float:originF[3];
get_entvar(corpse_id, var_origin, originF);
UTIL_Explosion(originF);
}

// "damage":
new Float:flDamage = rt_mined_explode_damage;
new TeamName:corpseTeam = get_entvar(corpse_id, var_team);
new bitsDamageType = DMG_GRENADE;
new pevMiner = ptrMiner(corpse_id);

// "gibs":
if (rt_mined_gibs) {
bitsDamageType |= DMG_ALWAYSGIB;
}

// Ловим ближайших игроков
for (new i = MaxClients; i > 0; --i)
{
if (!is_user_alive(i)) {
continue;
}

// Relation?
if (get_member(i, m_iTeam) != corpseTeam) {
continue;
}

// "damage_from_radius"
if (rt_mined_damage_from_radius)
{
// Формируем урон согласно радиусу
flDamage = rt_mined_explode_damage - rg_entity_range(i, corpse_id) * (rt_mined_explode_damage / rt_mined_explode_radius);

// Этого игнорим..
if (flDamage < 1.0) {
continue;
}
}
else if (rg_entity_range(i, corpse_id) > rt_mined_explode_radius) {
// "radius":
continue;
}

// Наносим урон
PM_GotaNaNVelocity(i, corpse_id);
set_member(i, m_LastHitGroup, HITGROUP_GENERIC);
// set_member(i, m_pevLastInflictor, corpse_id);
rg_takedamage(i, corpse_id, pevMiner, flDamage, bitsDamageType);

// Игрок остался жив, значит можно поиздеватся
if (get_entvar(i, var_deadflag) == DEAD_NO) {
// "pain_knockback": "pain_velmod":
rg_entity_takedamage_impulse(i, corpse_id, rt_mined_takedamage_knockback, rt_mined_takedamage_velmod);
}
}

// Что будем делать с трупом после взрыва?!
if (rt_mined_remove_corpse == 1) {
// "remove_corpse":
RT_DeleteCorpse(ptrOwner(corpse_id));
}
else if (rt_mined_remove_corpse == -1) {
// Make corpse great again
set_entvar(corpse_id, var_miner, 0);
}
}

// Got a NaN velocity on
PM_GotaNaNVelocity(const id, const inflictor) {
new Float:dest[3], Float:source[3], Float:blastV[3];
get_entvar(id, var_origin, dest);
get_entvar(inflictor, var_origin, source);
xs_vec_sub(dest, source, blastV);
set_member(id, m_vBlastVector, blastV);
}

bool:IsMined(const corpse_id, const activator)
{
// Не использован
if (get_entvar(corpse_id, var_miner) == 0) {
return false;
}

new pMiner = ptrMiner(corpse_id);
if (pMiner == 0) // Not connected anymore
{
// "mined_owner":
if (rt_mined_owner) {
return false;
}
}
else
{
// FIX: Спустя время, он может быть уже в другой команде
if (RT_RelationStatus(activator, pMiner) != RELATION_TEAMMATE) {
return false;
}
}

return true;
}

// Get player pointer
ptrMiner(const corpse_id)
{
new userid = get_entvar(corpse_id, var_miner);
return GETPLAYERUSERID(userid);

}

stock UTIL_Explosion(const Float:originF[3])
{
new expFlags = TE_EXPLFLAG_NOSOUND;

// "explode_sound":
if (!g_cSoundExplosionDisabled) {
if (!FNullString(rt_mined_explode_sound)) {
rh_emit_sound2(0, 0, CHAN_AUTO, rt_mined_explode_sound, .attn = ATTN_STATIC, .origin = originF);
}
else {
expFlags = TE_EXPLFLAG_NONE;
}
}

for (new i; i < rt_mined_explode_sprite_count; i++) {
message_begin_f(MSG_PAS, SVC_TEMPENTITY, originF);
write_byte(TE_EXPLOSION); // This makes a dynamic light and the explosion sprites/sound
if (rt_mined_explode_sprite_count == 1) {
write_coord_f(originF[0]); // Send to PAS because of the sound
write_coord_f(originF[1]);
} else {
write_coord_f(originF[0] + random_float(-128.0, 128.0)); // Send to PAS because of the sound
write_coord_f(originF[1] + random_float(-128.0, 128.0));
}
write_coord_f(originF[2] + random_float(30.0, 35.0) + rt_mined_explode_sprite_offset);
write_short(g_sModelIndexFireball);
write_byte(rt_mined_explode_sprite_scale + random_num(-10, 12)); // scale * 10
write_byte(30); // framerate
write_byte(expFlags); // flags
message_end();
}
}

stock rg_takedamage(const pPlayer, pevInflictor, pevAttacker, Float:flDamage, bitsDamageType) {
rg_multidmg_clear();
rg_multidmg_add(pevInflictor, pPlayer, flDamage, bitsDamageType);
rg_multidmg_apply(pevInflictor, pevAttacker);
// return (get_entvar(pPlayer, var_deadflag) == DEAD_NO);
}

stock rg_entity_takedamage_impulse(const id, const entity, const Float:flKnockbackForce, const Float:flVelModifier) {
if (flKnockbackForce != 0.0) {
new Float:VecPlayerVelocity[3], Float:VecPlayerOrigin[3], Float:VecEntityOrigin[3];
get_entvar(id, var_velocity, VecPlayerVelocity);
get_entvar(id, var_origin, VecPlayerOrigin);
get_entvar(entity, var_origin, VecEntityOrigin);
VecEntityOrigin[2] -= 16.0; // Incrase vertical velocity
xs_vec_sub(VecPlayerOrigin, VecEntityOrigin, VecPlayerOrigin);
xs_vec_normalize(VecPlayerOrigin, VecPlayerOrigin);
xs_vec_mul_scalar(VecPlayerOrigin, flKnockbackForce, VecPlayerVelocity);
set_entvar(id, var_velocity, VecPlayerVelocity);
}

if (flVelModifier != 0.0) {
set_member(id, m_flVelocityModifier, flVelModifier);
}
}

stock RT_ProcessionTimerChange(const corpse_id, const Float:flTime) {
set_entvar(corpse_id, var_timer, get_gametime() + flTime);
// set_entvar(corpse_id, var_nextthink, get_gametime());
}
[/code][/spoiler]

[spoiler title=rt_life_time.sma][code]#include <amxmodx>
#include <fakemeta>
#include <reapi>
#include <revive_teammates>

// const EntVars:var_spriteId = var_iuser3;
// #define ptrSprite(%0) (get_entvar(%0, var_spriteId))
new const CORPSE_TIMER_CLASSNAME[] = "corpse_timer";

// Cvars
new rt_lt_file[64];
new Float:rt_lt_spawn_delay;
new Float:rt_lt_destroy_time;
new rt_lt_corpse_fade_effect;
new Float:rt_lt_step_time;
new Float:rt_lt_offset_Z;
new Float:rt_lt_scale;
new rt_lt_abuse_time;
new rt_lt_team;
new rt_lt_access[16];

// Vars
new g_pAccessFlag;

public plugin_init()
{
register_plugin("RT: Life Time", RT_VERSION_STR, "@emmajule");
}

public RT_ParseConfigFile(JSON:json)
{
json_cvar_string(json, "file", "sprites/revive.spr", "Спрайт для показа^nВ спрайте присутствуют кадры (frames) для показа количества секунд.^nМожно оставить пустым, тогда будет просто работать как отсчет времени до исчезновения!", .cvar = rt_lt_file, .len = charsmax(rt_lt_file), .precache = true);
json_cvar_float(json, "spawn_time", 3.0, "Время, после которого начнет действовать таймер^n0 - сразу при создании трупа", .cvar = rt_lt_spawn_delay);
json_cvar_float(json, "destroy_time", 30.0, "Время через которое труп исчезнет!^nПлагин использует кадры (картинки) которые указанны в спрайте для показа отсчета посекундно", .cvar = rt_lt_destroy_time);
json_cvar_integer(json, "corpse_fade_effect", 0, "Труп будет плавно исчезать по истечению времени^nОбратите внимание, что могут быть конфликты если вы используете функцию подсветки трупов!", .cvar = rt_lt_corpse_fade_effect);
json_cvar_float(json, "step_time", 1.0, "Интервал между каждым новым кадром (то-есть это может быть не обязательно секунда)", .cvar = rt_lt_step_time);
json_cvar_float(json, "offset_Z", 16.0, "На сколько юнит поднять спрайт над трупом^nИспользуйте отрицательное значение, если напротив хотите опустить", .cvar = rt_lt_offset_Z);
json_cvar_float(json, "scale", 0.15, "Размер спрайта", .cvar = rt_lt_scale);
json_cvar_integer(json, "abuse_time", 0, "Время не считается, когда происходит взаимодействия между игроком и трупом^nЭто может спасти труп на последних секундах, когда время на поднятие больше, чем осталось..", .cvar = rt_lt_abuse_time);
json_cvar_integer(json, "team", 0, "Действие команд^n0 - Работает для всех^n1 - Не работает для команды TERRORIST^n2 - Не работает для команды CT", .has_min = true, .has_max = true, .max_val = 2, .cvar = rt_lt_team);
json_cvar_string(json, "flag", "", "Игроки с этим флагом(ами) не будут подвержены действиям таймера!^n0 или '' - Плагин действует для всех!", .cvar = rt_lt_access, .len = charsmax(rt_lt_access));
}

public plugin_cfg()
{
// "flag":
g_pAccessFlag = read_flags_ex(rt_lt_access);
}

public RT_StartSneaking(const corpse_id, const owner, const model[], const Float:origin[3])
{
// "team":
if (get_entvar(corpse_id, var_team) == rt_lt_team) {
return CORPSE_CUSTOM;
}

// "flag":
if (g_pAccessFlag > 0 && (get_user_flags(owner) & g_pAccessFlag)) {
return CORPSE_CUSTOM;
}

// Create model
new entity = rg_create_entity("info_null");
set_entvar(entity, var_classname, CORPSE_TIMER_CLASSNAME);
set_entvar(entity, var_effects, EF_NODRAW);
set_entvar(entity, var_owner, corpse_id);
set_entvar(entity, var_scale, rt_lt_scale); // "scale":
set_entvar(entity, var_nextthink, get_gametime() + rt_lt_spawn_delay); // "spawn_delay":

// "corpse_fade_effect":
if (rt_lt_corpse_fade_effect) {
set_entvar(corpse_id, var_renderamt, 255.0);
set_entvar(corpse_id, var_rendermode, kRenderTransAlpha);
set_entvar(corpse_id, var_renderfx, kRenderFxNone);
}

// "offset_Z":
new Float:entityPos[3];
entityPos = origin;
entityPos[2] += rt_lt_offset_Z;
SET_ORIGIN(entity, entityPos);

// "file"
if (!FNullString(rt_lt_file)) {
SET_MODEL(entity, rt_lt_file);
}

SetThink(entity, "CPointEntity_Think");
return CORPSE_CUSTOM;
}

// Remove entities
public RT_StopSneaking(const corpse_id, const owner)
{
new pEntity = NULLENT;
while ((pEntity = rg_find_ent_by_class(pEntity, CORPSE_TIMER_CLASSNAME)) > 0) {
if (get_entvar(pEntity, var_owner) == corpse_id) {
rg_remove_entity(pEntity);
break;
}
}
}

public CPointEntity_Think(const id)
{
new corpse_id = get_entvar(id, var_owner);
new Float:frames = Float:get_entvar(id, var_frame);
if (frames == 0.0)
{
// "destroy_time":
set_entvar(id, var_frame, rt_lt_destroy_time - 1.0);
set_entvar(id, var_effects, 0);
}
else
{
if (rt_lt_abuse_time && ptrActivator(corpse_id) != 0) {
goto pt_end;
}

new Float:total_frame = frames - 1.0;
if (total_frame > 0.0)
{
set_entvar(id, var_frame, total_frame);

// "corpse_fade_effect":
if (rt_lt_corpse_fade_effect) {
new Float:flAmount = 255.0 * (total_frame / rt_lt_destroy_time);
set_entvar(corpse_id, var_renderamt, floatmax(flAmount, 60.0));
}
}
else
{
// Время вышло, труп удаляется..
new owner = ptrOwner(corpse_id);
RT_DeleteCorpse(owner);
return;
}
}

pt_end:
// "step_time":
set_entvar(id, var_nextthink, get_gametime() + rt_lt_step_time);
}[/code][/spoiler]

[spoiler title=rt_ghost_mode.sma][code]#include <amxmodx>
#include <fakemeta_util>
#include <reapi>
#include <xs>
#include <revive_teammates>

#define GetObserverMode(%0) (get_entvar(%0, var_iuser1))

const UNIT_SECOND = 1<<12;
const FFADE_IN = 0x0000;
const FFADE_OUT = 0x0001;
const FFADE_STAYOUT = 0x0004;

// Cvars
new rt_ghost_scenario_disabled;
new rt_ghost_force_observer_mode;
new Float:rt_ghost_search_delay;
new Float:rt_ghost_speed;
new rt_ghost_screenfade;
new rt_ghost_can_revive;
new rt_ghost_relationship;
new rt_ghost_max_invites;
new rt_ghost_fov;

// Vars
new g_MsgSetFOV;
new Array:g_aCorpseQueue, g_iQueueSize;
new Float:g_flNextObserverTime[33];
new bool:g_bInGhostMode[33];
new g_iRespawnCount[33];

public plugin_init()
{
register_plugin("RT: Ghost Mode", RT_VERSION_STR, "@emmajule");

RegisterHookChain(RG_CSGameRules_RestartRound, "CSGameRules_RestartRound", false);
RegisterHookChain(RG_CBasePlayer_StartObserver, "CBasePlayer_StartObserver", false);
RegisterHookChain(RG_CBasePlayer_Observer_SetMode, "CBasePlayer_Observer_SetMode", false);
RegisterHookChain(RG_CBasePlayer_Observer_SetMode, "CBasePlayer_Observer_SetMode_Post", true);
RegisterHookChain(RG_CBasePlayer_Observer_Think, "CBasePlayer_Observer_Think", true);
RegisterHookChain(RG_CBasePlayer_ResetMaxSpeed, "CBasePlayer_ResetMaxSpeed", true);
RegisterHookChain(RG_CBasePlayer_Spawn, "CBasePlayer_Spawn", false);

g_aCorpseQueue = ArrayCreate(1, 0);
g_MsgSetFOV = get_user_msgid("SetFOV");
register_message(g_MsgSetFOV, "Message_SetFOV");
}

public RT_ParseConfigFile(JSON:json)
{
json_cvar_integer(json, "disable_scenario", 1, "Этот плагин будет блокировать обычный способ взаимодействия с трупом через клавишу E", .cvar = rt_ghost_scenario_disabled);
json_cvar_integer(json, "force_camera", 1, "Камера будет автоматически в режиме свободного полета^nПереключать режимы камеры будет невозможно!", .cvar = rt_ghost_force_observer_mode);
json_cvar_integer(json, "max_invites", 0, "Сколько максимально раз за раунд можно вселятся в трупы^n0 - Неограниченное кол-во раз.", .cvar = rt_ghost_max_invites);
json_cvar_float(json, "frequency", 0.2, "Частота времени между новым поиском трупов", .cvar = rt_ghost_search_delay);
json_cvar_integer(json, "screenfade", 1, "Экран игрока будет подвсечен в режиме призрака!", .cvar = rt_ghost_screenfade);
json_cvar_integer(json, "fov", 120, "Поле дальности зрения игрока в режиме призрака!", .has_max = true, .max_val = 180, .cvar = rt_ghost_fov);
json_cvar_float(json, "speed", 800.0, "Скорость камеры в режиме призрака!^n0 - по стандарту! (согласно sv_spectatormaxspeed)", .cvar = rt_ghost_speed);
json_cvar_integer(json, "relationship", 4, "Призрак может вселится^n0 - только в свой труп^n1 - в любой труп своей команды^n2 - в любой труп своей команды, кроме своего^n3 - во все трупы^n4 - во все трупы, кроме своего", .cvar = rt_ghost_relationship);
json_cvar_integer(json, "can_revive", 0, "Не позволяет вселятся в трупы которые уже в процессе воскрешения", .cvar = rt_ghost_can_revive);
}

public RT_StartLoot_Pre(const corpse_id, const activator, const owner)
{
// "disable_scenario":
if (rt_ghost_scenario_disabled) {
return RT_BREAK;
}

return RT_CONTINUE;
}

public RT_RelationConditions(const player, const target)
{
if (g_bInGhostMode[player]) {
return RELATION_ALLY;
}

return RELATION_NONE;
}

public RT_StartSneaking(const corpse_id, const owner, const model[], const Float:origin[3])
{
// Вообще конечно уместно будет задавать размеры с конфига
// Но этого никто не делаает :(
SET_SIZE(corpse_id, Float:{-60.0, -60.0, -36.0}, Float:{60.0, 60.0, 36.0});

// Add entity to queue
ArrayPushCell(g_aCorpseQueue, corpse_id);
g_iQueueSize++;
}

public RT_StopSneaking(const corpse_id, const owner)
{
new item = ArrayFindValue(g_aCorpseQueue, corpse_id);

// Check valid
if (item != -1)
{
// Remove entity from queue
ArrayDeleteItem(g_aCorpseQueue, item);
g_iQueueSize--;
}
}

public client_disconnected(id)
{
g_bInGhostMode[id] = false;
g_flNextObserverTime[id] = 0.0;
}

public CBasePlayer_Spawn(const id)
{
g_bInGhostMode[id] = false;
return HC_CONTINUE;
}

public CSGameRules_RestartRound()
{
arrayset(g_iRespawnCount, 0, 33);
return HC_CONTINUE;
}

public CBasePlayer_StartObserver(const id, Float:VecPos[3], Float:VecViewAngle[3])
{
// Check status
g_bInGhostMode[id] = !IsBadClient(id);
if (!g_bInGhostMode[id] && g_flNextObserverTime[id] != 0) {
GhostEffects(id, false);
}

g_flNextObserverTime[id] = 0.0;
return HC_CONTINUE;
}

new iCurMode;
public CBasePlayer_Observer_SetMode(const id, iMode)
{
if (!g_bInGhostMode[id]) {
return HC_CONTINUE;
}

// "force_camera":
if (rt_ghost_force_observer_mode) {
SetHookChainArg(2, ATYPE_INTEGER, OBS_ROAMING);
}

iCurMode = get_entvar(id, var_iuser1);
return HC_CONTINUE;
}

public CBasePlayer_Observer_SetMode_Post(const id, iMode)
{
if (!g_bInGhostMode[id]) {
return;
}

// Just abort if we're changing to the mode we're already in
if (iCurMode == iMode) {
return;
}

if (iMode == OBS_ROAMING) {
// "entire_delay":
g_flNextObserverTime[id] = get_gametime() + 3.0;
}
else {
g_flNextObserverTime[id] = 0.0;
}

// Screen effects
GhostEffects(id, g_flNextObserverTime[id] != 0);
}

public CBasePlayer_Observer_Think(const id)
{
if (!g_flNextObserverTime[id]) {
return;
}

// Задержка между следующим поиском
new Float:flGameTime = get_gametime();
if (g_flNextObserverTime[id] > flGameTime) {
return;
} else {
// "frequency":
g_flNextObserverTime[id] = flGameTime + rt_ghost_search_delay;
}

// Нет надобности использоать без трупов!
if (g_iQueueSize <= 0) {
return;
}

new corpse_id;
for (new i = 0; i < g_iQueueSize; i++) {
corpse_id = ArrayGetCell(g_aCorpseQueue, i);

// v0
if (is_nullent(corpse_id)) {
continue;
}

// В какие трупы можно вселятся
new pevOwner = ptrOwner(corpse_id);
new bSameTeam = (get_member(id, m_iTeam) == get_entvar(corpse_id, var_team));
switch (rt_ghost_relationship) // "relationship":
{
case 0: {
// только в свой труп
if (pevOwner != id) {
continue;
}
}
case 1: {
// в любой труп своей команды
if (!bSameTeam) {
continue;
}
}
case 2: {
// в любой труп своей команды, кроме своего
if (!bSameTeam || pevOwner == id) {
continue;
}
}
case 3: {
// во все трупы
}
case 4: {
// во все трупы, кроме своего
if (pevOwner == id) {
continue;
}
}
}

// Нет возможности вселится в этот труп
if (!CanInsideInThisCorpse(id, corpse_id)) {
continue;
}

// "can_revive":
if (!rt_ghost_can_revive) {
RT_BreakAction(corpse_id, ptrActivator(corpse_id), pevOwner, false);
}

// set_entvar(corpse_id, var_owner, id);
if (RT_GoAction(corpse_id, id, true)) {
RT_BreakAction(corpse_id, id, id, true);
RT_DeleteCorpse(pevOwner);
g_iRespawnCount[id]++;
break;
}
}
}

public CBasePlayer_ResetMaxSpeed(const id)
{
// "speed":
if (rt_ghost_speed > 0 && GetObserverMode(id) == OBS_ROAMING && g_flNextObserverTime[id] != 0) {
set_entvar(id, var_maxspeed, rt_ghost_speed);
}
}

public Message_SetFOV(msg_id, msg_dest, msg_entity)
{
// "fov":
if (rt_ghost_fov > 0 && GetObserverMode(msg_entity) == OBS_ROAMING && g_flNextObserverTime[msg_entity] != 0) {
set_msg_arg_int(1, ARG_BYTE, rt_ghost_fov);
}

return 0;
}

GhostEffects(const id, const st)
{
if (st)
{
// "screenfade":
if (rt_ghost_screenfade) {
// TODO: cvar settings..
UTIL_ScreenFade(id, 0.45, 1.0, .color = {157, 177, 204}, .alpha = 85, .flags = FFADE_OUT | FFADE_STAYOUT);
}

// "fov":
if (rt_ghost_fov > 0) {
UTIL_SetFOV(id, rt_ghost_fov);
}
}
else
{
// "screenfade":
if (rt_ghost_screenfade) {
UTIL_ScreenFade(id, 0.001);
}

// "fov":
if (rt_ghost_fov > 0) {
UTIL_SetFOV(id, 0);
}
}
}

#define vec(%0) Float:%0[3]
bool: CanInsideInThisCorpse(const player, const corpse_id)
{
static vec(src), vec(end);
static vec(mins), vec(maxs);

get_entvar(player, var_origin, src);
get_entvar(corpse_id, var_origin, end);

get_entvar(corpse_id, var_maxs, maxs);
get_entvar(corpse_id, var_mins, mins);

xs_vec_add(mins, end, mins);
xs_vec_add(maxs, end, maxs);

// TODO: cvar settings..
if (fm_distance_to_box(src, mins, maxs) > 24.0) {
return false;
}

/*
new vec(angl), vec(fwd);
xs_vec_sub(end, src, end);
xs_vec_normalize(end, end);
get_entvar(player, var_v_angle, angl);
angle_vector(angl, ANGLEVECTOR_FORWARD, fwd);
// xs_vec_mul_scalar(end, -1.0, end);
new Float:dot = xs_vec_dot(fwd, end);

if (dot > 0.75) {
return true;
}
*/

return true;
}

bool: IsBadClient(const id)
{
// Not a playable team
if (!VALID_TEAM(id)) {
return true;
}

// Fake client
if (is_user_bot(id)) {
return true;
}

// Choose a appearance team menu state
if (get_member(id, m_iMenu) == Menu_ChooseAppearance ||
get_member(id, m_iJoiningState) == PICKINGTEAM) {
return true;
}

// "max_invites":
if (rt_ghost_max_invites > 0 && g_iRespawnCount[id] >= rt_ghost_max_invites) {
return true;
}

// Seems fine, can go
return false;
}

stock UTIL_SetFOV(const id, const fov)
{
set_entvar(id, var_fov, float(fov));
set_member(id, m_iClientFOV, fov);
set_member(id, m_iFOV, fov);

message_begin(MSG_ONE, g_MsgSetFOV, .player = id);
write_byte(fov);
message_end();
}

stock UTIL_ScreenFade(const id, const Float:fxtime = 0.0, const Float:holdtime = 0.0, const color[3] = { 0, 0, 0 }, const alpha = 0, const flags = FFADE_IN)
{
static msgScreenFade;
if (msgScreenFade > 0 || (msgScreenFade = get_user_msgid("ScreenFade")) > 0) {
message_begin(MSG_ONE, msgScreenFade, .player = id);
write_short(FixedUnsigned16(fxtime));
write_short(FixedUnsigned16(holdtime));
write_short(flags);
write_byte(color[0]);
write_byte(color[1]);
write_byte(color[2]);
write_byte(alpha);
message_end();
}
}

stock UTIL_ScreenShake(const id, const Float:amplitude = 1.0, const Float:duration = 1.0, const Float:frequency = 1.0)
{
static msgScreenShake;
if (msgScreenShake > 0 || (msgScreenShake = get_user_msgid("ScreenShake")) > 0) {
message_begin(MSG_ONE_UNRELIABLE, msgScreenShake, .player = id);
write_short(FixedUnsigned16(amplitude));
write_short(FixedUnsigned16(duration));
write_short(FixedUnsigned16(frequency, (1<<8)));
message_end();
}
}

stock FixedUnsigned16(Float:value, scale = UNIT_SECOND)
{
new output = floatround(value * scale);

if (output < 0) {
output = 0;
}

if (output > 0xFFFF) {
output = 0xFFFF;
}

return output;
}[/code][/spoiler]

Инклуды

revive_teammates.inc

Код: Выделить всё

#if defined _revive_teammates_included
  #endinput
#endif
#define _revive_teammates_included

#include <revive_teammates_const>

#if AMXX_VERSION_NUM >= 175
	#pragma reqlib revive_teammates
	#if !defined AMXMODX_NOAUTOLOAD
		#pragma loadlib revive_teammates
	#endif
#else
	#pragma library revive_teammates
#endif

// NATIVES

/**
 * Retrives a plugin prefix
 *
 * @param string        String buffer to copy 
 * @param len           Max buffer size
 *
 * @noreturn
 */
native RT_GetPrefix(string[], len);

/**
 * Force delete a player corpse
 * 
 * @param id            Player index
 * 
 * @return              true if the entity was successfully removed, false otherwise
 */
native RT_DeleteCorpse(id);

/**
 * Get a entity index of player corpse
 * 
 * @param id            Player index
 * 
 * @return              Entity index of player corpse, 0 otherwise
 */
native RT_GetCorpse(const id);

/**
 * Get a attachment corpse entity index which player a stationary controlled
 * 
 * @param id            Player index
 * 
 * @return              Entity index of corpse, 0 otherwise
 */
native RT_Attachment(const id);

/**
 * Utility for checking the player's spawn
 * Use it only in player Spawn() events or forwards
 * 
 * @return              1 on success, 0 otherwise
 */
native RT_fSpawned();

/**
 * Get a relationship status between two players
 * 
 * @param player        Player index (like a victim)
 * @param target        Player index (like a attacker)
 * 
 * @return              Relation status (see revive_teammates_const.inc)
 */
native any:RT_RelationStatus(const player, const target);

/**
 * Force's a begin action of revive
 * 
 * @param corpse_id     Entity index of corpse
 * @param activator     Player index (corpse activator)
 * @param skip_checks   If true, the process cannot be stopped by other plugins.
 *                      Be carefully about plugin logic
 * 
 * @return              true on success, false otherwise
 */
native RT_GoAction(const corpse_id, const activator, const bool:skip_checks = false);

/**
 * Instantly a break action of revive
 * 
 * @param corpse_id     Entity index of corpse
 * @param activator     Player index (corpse activator)
 * @param owner         Player index (owner of corpse)
 * @param complete      Complete status
 * 
 * @return              true on success, false otherwise
 */
native RT_BreakAction(const corpse_id, const activator, const owner, bool:complete);

// FORWARDS

/**
 * Called when player tries to interact with a corpse
 *
 * @param corpse_id     Entity index of corpse
 * @param activator     Player index (corpse activator)
 * @param owner         Player index (owner of corpse)
 *
 * @return      RT_CONTIUE to let the activator use the corpse
 *              RT_SUPERCEDE or higher to prevent this action
 */
forward RT_StartLoot_Pre(const corpse_id, const activator, const owner);

/**
 * Сalled when the player successfully starts interacting with a corpse
 *
 * @param corpse_id     Entity index of corpse
 * @param activator     Player index (corpse activator)
 * @param owner         Player index (owner of corpse)
 * @param duration      Time for the process
 *
 * @noreturn
 */
forward RT_StartLoot_Post(const corpse_id, const activator, const owner, Float:duration);

/**
 * Сalled when interaction between monsters is interrupted
 *
 * @param corpse_id     Entity index of corpse
 * @param activator     Player index (corpse activator)
 * @param owner         Player index (owner of corpse)
 * @param complete      This means the revive is passed
 *
 * @return     RT_CONTINUE to let the completed it successfully and the player will be spawned
 *             RT_SUPERCEDE or higher to complete the process, but the player will not be revived
 */
forward RT_StopLoot(const corpse_id, const activator, const owner, bool:complete);

/**
 * Called when creating the corpse of a deceased player (ClCorpse message)
 *
 * @param corpse_id     Entity index of corpse
 * @param owner         Player index (owner of corpse)
 * @param model         Entity model
 * @param origin        Entity position in world
 *
 * @return     CORPSE_CUSTOM a custom corpse with defined properties (using by default)
 *             CORPSE_DEFAULT a corpse is created via client side message (default behaviour)
 *             CORPSE_BLOCK prevent the appearance of a corpse 
 */
forward RT_StartSneaking(const corpse_id, const owner, const model[], const Float:origin[3]);

/**
 * Called when the corpse is removed from world (every "TeamInfo" message on player)
 *
 * @param corpse_id     Entity index of corpse
 * @param owner     	Player index (owner of corpse)
 *
 * @noreturn
 */
forward RT_StopSneaking(const corpse_id, const owner);

/**
 * Called at every think when entity is used
 *
 * @param corpse_id     Entity index of corpse
 * @param activator     Player index (corpse activator)
 * @param owner     	Player index (owner of corpse)
 * @param time_ending   This is the time when the process of rebirth will be completed
 *
 * @return     RT_CONTINUE to let the continue of procces
 *             RT_SUPERCEDE or higher to prevent this action
 */
forward RT_ThinkLoot(const corpse_id, const activator, const owner, Float:time_ending);

/**
 * Called immediately after the resurrection of the player
 *
 * @param id            Player index (who was reborn)
 * @param friend        Player index by which the player was resurrected
 *
 * @noreturn
 */
forward RT_GotRespawn(const id, const friend);

/**
 * It's called before each check of the relationship between monsters.
 * You can try to play out your own scenario
 *
 * @param player        Player index (like a victim)
 * @param target        Player index (like a attacker)
 *
 * @return     Choose your own return value that will determine the relationship between entities
 *             See revive_teammates_const.inc
 */
forward RT_RelationConditions(const player, const target);

/**
 * Called when config file is parsing..
 * NOTE: Use this only in plugin_precache() forward.
 *
 * @param json          JSON Handle
 *
 * @noreturn
 */
forward RT_ParseConfigFile(JSON:json);


// Backwards
stock bool:RT_IsUsing(const id)
{
	return (RT_Attachment(id) != 0);
}

revive_teammates_const.inc

Код: Выделить всё

#if defined _revive_teammates_const_included
  #endinput
#endif
#define _revive_teammates_const_included

#if !defined _json_included
	#include <json>
#endif

// Corpse classname
stock const CORPSE_CLASSNAME[] = "player_corpse";

// Corpse default collision
stock const Float:DEFAULT_CORPSE_MINS[3] = {-16.0, -16.0, -36.0};
stock const Float:DEFAULT_CORPSE_MAXS[3] = {16.0, 16.0, 36.0};

// Corpse max search distance
stock const Float:CORPSE_MAX_RANGE = 128.0;

// Plugin version
stock const RT_VERSION_STR[] = "3.4.79";
stock const RT_SUFFIX[] = "RT";
#define RT_VERSION_NUM 3479

stock const EntVars:var_activator = var_iuser1;
stock const EntVars:var_timer     = var_fuser1;
#define ptrOwner(%0)     get_entvar(%0, var_owner)
#define ptrActivator(%0) get_entvar(%0, var_activator)

// Cvar description
stock const CM_VALUE_TAG[] = "#";
stock const CM_DESCRIPTION_TAG[] = "description";
stock const CM_DEFAULT_TAG[] = "default";
stock const CM_MIN_TAG[] = "min";
stock const CM_MAX_TAG[] = "max";

// Helper macro
#define VALID_PLAYER(%0)        (1 <= %0 <= MaxClients)
#define VALID_TEAM(%0)          (TEAM_TERRORIST <= get_member(%0, m_iTeam) <= TEAM_CT)
#define CUSTOM_RELATION(%0)     (%0 < RELATION_NONE && %0 > RELATION_ENEMY)

#define GETPLAYERUSERID(%0)     find_player_ex(FindPlayer_MatchUserId, %0)
#define GETPLAYERAUTHID(%0)     find_player_ex(FindPlayer_MatchAuthId, %0)

#define FNullString(%0)         (!%0[0] || %0[0] == '0' || strlen(%0) <= 0)
#define mod(%0,%1)              ((((%0) % (%1)) + (%1)) % (%1))
#define _clamp(%0,%1,%2)        (max(%1, min(%2, %0)))

#define SET_SIZE(%0,%1,%2)      engfunc(EngFunc_SetSize, %0, %1, %2)
#define SET_MODEL(%0,%1)        engfunc(EngFunc_SetModel, %0, %1)
#define SET_ORIGIN(%0,%1)       engfunc(EngFunc_SetOrigin, %0, %1)


// Return type
enum
{
	RT_CONTINUE = 0,
	RT_SUPERCEDE,
	RT_BREAK
};

/*
	For RT_StartSneaking()
*/
enum
{
	CORPSE_CUSTOM = 0,
	CORPSE_DEFAULT,
	CORPSE_BLOCK
};

/*
	For RT_RelationCheck()
*/
enum
{
	RELATION_NONE = 0,
	RELATION_TEAMMATE,
	RELATION_ENEMY,
	RELATION_NEUTRAL,
	RELATION_ALLY,
	RELATION_CUSTOM
};

// Parsing varibles
stock json_cvar_integer(const JSON:json, const name[], const value, const description[], bool:has_min = false, min_val = 0, bool:has_max = false, max_val = 0, &cvar)
{
	new sec[64];
	new JSON:json_c;
	new JSON:json_dir;
	
	// Need to choose custom directory section
	json_dir = json_cvar_directory(json, sec);
	
	if (json_object_has_value(json_dir, name, JSONObject))
	{
		// Create a new key as default
		json_c = json_object_get_value(json_dir, name);	
		cvar = json_object_get_number(json_c, CM_VALUE_TAG);
		
		// Clamp to limits
		if (has_max && cvar > max_val) {
			cvar = max_val;
		}
		else if (has_min && cvar < min_val) {
			cvar = min_val;
		}
	}
	else
	{
		json_c = json_init_object();
		cvar = value;
		json_object_set_number(json_c, CM_VALUE_TAG, cvar);
	}
	
	// Set's a description tag
	json_cvar_set_description(json_c, description);
	
	// Set a notification about default limits
	if (has_min) {
		json_object_set_number(json_c, CM_MIN_TAG, min_val);
	}
	if (has_max) {
		json_object_set_number(json_c, CM_MAX_TAG, max_val);
	}
	
	json_object_set_value(json_dir, name, json_c);
	json_object_set_value(json, sec, json_dir);
	
	json_free(json_dir);
	json_free(json_c);
}

stock json_cvar_float(const JSON:json, const name[], const Float:value, const description[], bool:has_min = false, Float:min_val = 0.0, bool:has_max = false, Float:max_val = 0.0, &Float:cvar)
{
	new sec[64];
	new JSON:json_c;
	new JSON:json_dir;
	
	// Need to choose custom directory section
	json_dir = json_cvar_directory(json, sec);
	
	if (json_object_has_value(json_dir, name, JSONObject))
	{
		// Create a new key as default
		json_c = json_object_get_value(json_dir, name);	
		cvar = json_object_get_real(json_c, CM_VALUE_TAG);
		
		// Clamp to limits
		if (has_max && cvar > max_val) {
			cvar = max_val;
		}
		else if (has_min && cvar < min_val) {
			cvar = min_val;
		}
	}
	else
	{
		// Or take it from an existing one
		json_c = json_init_object();
		cvar = value;
		json_object_set_real(json_c, CM_VALUE_TAG, cvar);
	}
	
	// Set's a description tag
	json_cvar_set_description(json_c, description);
	
	// Set a notification about default limits
	if (has_min) {
		json_object_set_real(json_c, CM_MIN_TAG, min_val);
	}
	if (has_max) {
		json_object_set_real(json_c, CM_MAX_TAG, max_val);
	}
	
	json_object_set_value(json_dir, name, json_c);
	json_object_set_value(json, sec, json_dir);
	
	json_free(json_dir);
	json_free(json_c);
}

stock json_cvar_string(const JSON:json, const name[], const value[], const description[], cvar[], len, bool:precache = false, &cache_id = 0)
{
	new sec[64];
	new JSON:json_c;
	new JSON:json_dir;
	
	// Need to choose custom directory section
	json_dir = json_cvar_directory(json, sec);
	
	if (json_object_has_value(json_dir, name, JSONObject))
	{
		// Create a new key as default
		json_c = json_object_get_value(json_dir, name);
		json_object_get_string(json_c, CM_VALUE_TAG, cvar, len);
	}
	else
	{
		// Or take it from an existing one
		json_c = json_init_object();
		json_object_set_string(json_c, CM_VALUE_TAG, value);
		copy(cvar, len, value);
	}
	
	// Set's a description tag
	json_cvar_set_description(json_c, description);
	
	// Precache file
	if (precache && !FNullString(cvar))
	{
		new file_length = strlen(cvar);
		switch (cvar[--file_length])
		{
		case '3', 't':
			cache_id = precache_generic(cvar);
		case 'v':
			cache_id = precache_sound(cvar);
		case 'l', 'r':
			cache_id = precache_model(cvar);
		// case 'c':
			// cache_id = precache_event(cvar);
		}
	}
	
	json_object_set_value(json_dir, name, json_c);
	json_object_set_value(json, sec, json_dir);
	
	json_free(json_dir);
	json_free(json_c);
}

stock JSON:json_cvar_directory(const JSON:json, sec[])
{
	if (!sec[0]) {
		get_plugin(-1, sec, 63);
	}
	
	new JSON:json_dir;
	if (json_object_has_value(json, sec, JSONObject)) {
		json_dir = json_object_get_value(json, sec);
	}
	else {
		json_dir = json_init_object();
	}
	
	return json_dir;
}

stock json_cvar_set_description(JSON:json, const description[])
{
	new desc[512];
	new reloc_idx, idx;
	new JSON:json_description = json_init_array();

	while ((idx = split_string(description[reloc_idx], "^n", desc, charsmax(desc))) != -1)
	{
		reloc_idx += idx;
		json_array_append_string(json_description, desc);
	}
	
	// FIX: Last arg
	if (reloc_idx > 0)
	{
		json_array_append_string(json_description, description[reloc_idx]);
		json_object_set_value(json, CM_DESCRIPTION_TAG, json_description);
	}
	else {
		json_object_set_string(json, CM_DESCRIPTION_TAG, description);
	}
	
	json_free(json_description);
}

stock read_flags_ex(const flags[])
{
	if (FNullString(flags)) {
		return 0;
	}
	
	return read_flags(flags);
}

// Same as fm_entity_range (fakemeta_util.inc)
stock Float:rg_entity_range(ent1, ent2)
{
	static Float:origin1[3], Float:origin2[3];
	get_entvar(ent1, var_origin, origin1);
	get_entvar(ent2, var_origin, origin2);

	return get_distance_f(origin1, origin2);
}

// For JSON colored format
stock replace_color_tag(string[], len)
{
	replace_string(string, len, "!n", "^1");
	replace_string(string, len, "!y", "^1");
	replace_string(string, len, "!t", "^3");
	replace_string(string, len, "!g", "^4");
	// replace_string(string, len, "^^1", "^1");
	// replace_string(string, len, "^^3", "^3");
	// replace_string(string, len, "^^4", "^4");
}

Версия	Дата выхода	Размер	Скачиваний	Скачать
3.4.79	Вчера, 22:11	225.53 КБ	1	revive_teammates.tar
2.3.9	17 апр 2022, 14:18	16.74 КБ	180	Revive Die Players 2.3.9.zip
2.3.9	13 апр 2022, 07:59	12.02 КБ	7	Revive Die Players 2.3.9.zip
2.3.2	29 мар 2022, 04:28	8.63 КБ	10	Revive Die Players 2.3.2.zip
2.2.5	27 мар 2022, 11:07	19.45 КБ	4	Revive Die Players 2.2.5.zip

История изменений

Версия: 3.4.79 18.09.2026 22:11

Крупное обновление, переработан код.

Версия: 2.3.9 17.04.2022 14:18

Добавлены новые квары

Код: Выделить всё

// Если команда доминирует над другой (побед подряд) запретить ей воскрешать/минировать?
// -
// Default: "0"
rt_domination "0"

// Возможность воскрешать/минировать только после Х сек. от начала раунда
// -
// Default: "10.0"
// Maximum: "60.000000"
rt_time_expired "10.0"

Добавлен include emma_jule.inc

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

Версия: 2.3.9 13.04.2022 07:59

Обновил архив, конфиг в архиве лежал не по верному пути поэтому некоторые редактировали не тот который положено.

Путь до конфига addons/amxmodx/configs/plugins/ReviveTeammates.cfg (создаётся автоматически)
В архиве лежал в addons/amxmodx/configs/ReviveTeammates.cfg

Версия: 2.3.2 29.03.2022 04:28

Фикс.

Версия: 2.2.5 27.03.2022 11:07

Описания нет

41 комментарий

Пред.
1
2
3
4
5

Emma Jule: Сообщения: 0; Зарегистрирован: 01 дек 2024, 17:19; Контактная информация:
Контактная информация пользователя Emma Jule

Отправить email