Highest Reputation Content

1. Загрузка и синхронизация на высокой скорости при помощи DarkLine Launcher'a. [Рекомендуется]

2. ИЛИ скачать аддоны отдельно
Набор аддонов ARMA3.RU + рация Task Force
- https://yadi.sk/d/BLYLCLh9fvUJg

All In Arma Terrain Pack
- https://yadi.sk/d/g3v81_P0doiCK

Islands RU Pack

- https://yadi.sk/d/kjsxIfqee78sV

RHS: Escalation v0.3.6
- https://yadi.sk/d/Cg42hKRKezPWe

3. ИЛИ Синхронизация с помощью Arma3Sync (Медленно):
- ftp://games.arma3.ru/arma3/vi-repo/.a3s/autoconfig

- Аддоны -
[ARMA3.RU Addons Pack]
В корневом каталоге с ArmA 3 должны быть папки: @A3RU_CORE; @A3RU_MODS;
 
[All In Arma Terrain Pack]
Аддон островов. Качать с патчами:
http://www.armaholic...ge.php?id=26682
 
[Islands RU Pack]
Аддон островов + фиксы для All In Arma
 
[RHS: Escalation]
Аддон пехоты, оружия и техники ВС РФ и USAF
Скачать:
http://www.rhsmods.o...ds/escal/latest
[CBA / TF Radio]
Аддон рации, а также инструкции по установке можно найти по ссылке:
http://radio.task-force.ru/

v34

• Хотфикс AGM в связи с выходом ARMA 3 v1.40

v33

• Обновление RHS до версии 0.3.6
• Обновление аддона островов:
  - Caribou
  - Emita
  - Gorgona
  - Hazarkot
  - Capraia
  - Podagorsk
  - Torabora
• Обновление платформы и модулей:
  - Совместимость с аддоном реплеев
  - Новый модуль - Настройки, заменяющий настройки миссии в файле mission_parameters.hpp
  - Возможность игроку устанавливать дистанцию обзора в наземной технике, воздухе, пешком (в меню действий A3A)
• Обновление спектатора:
  - Более крупные имена игроков, увеличена дистанция отображения
  - Меньший размер точек над игроками
  - Возможность завершения миссии администратором (надстройка в конфигураторе клавиш)
• Добавлена колесная и бронетехника (вероятно, не полностью сбалансирована):
  - БРДМ-2
  - БТР-60
  - Т-34-85М
  - Т-55А
  - ЗСУ-23-4 Шилка
  - Hilux (Без вооружения, АГС-30, ДШКМ, РСЗО, М2, МЕД, СПГ-9)
  - Land Rover (M2, МЕД, MK19, СПГ-9, TOW, без вооружения) - наборы в двух вариациях

v31/32
- A3A Модули: Случайная позиция для объектов, Эвакуация объектов из зоны
- AGM_Logistics: Добавлена проверка объекта на возможность загрузки в технику
- A3A Модули: Фикс модуля завершения по потерям
- Визуальные фиксы ПТРК Метис
 
v30
- Обновлена платформа/модули A3A (фикс раздачи ЛЦУ, модулей, статистики убийств, новые модули)
- Обновлен аддон совместимости RHS (M249 использует 5x45 станаги)
- Добавлен аддон быстрой смены пистолет/винтовки (AGM кнопки)
 
v28/29
- Обновлен аддона спектатора CSSA3 - добавлен список убийств
- Обновлена платформа/модули A3A (новая система работы модулей)
- Обновлен аддон Leights Opfor v0.8 - убран ИГИЛ
- Обновлен аддон A3RU_Difficulties
- Удален аддон CAF Agressors
- Фикс коэффициента брони солдат из аддона RHS
- MAS Static: гаубицы, ЗУ теперь нельзя перетаскивать/загружать в технику
- Замена аддона спектатора на CSSA3
- Обновление A3A_Core, A3A_Modules
- Добавлен аддон юнитов Leights из DEVTEST сборки
- Добавлен аддон юнитов ЧВК (PG Services PMC)
- Удален аддон старых модулей платформы Atrium (версии меньше 1.0)
 
v27
- @A3RU_WEAPONS удален из сборки, содержимое перемещено в @A3RU_MODS
- Добавлена аддон-версия платформы Atrium
- Добавлены острова (@islands_ru):
-- Afghan Village
-- Thirsk + Thirsk Winter
-- Fata
-- Panthera
-- SMD Sahrani
-- Sarugad
-- Фиксы к островам AiA
- Фикс пункта меню AGM "Ready Grenade"
- T-Cube Motion Tracker снова работает как GPS
- Фикс бронепробиваемости БТРов от RHS
- Обновлен универсальный конфигуратор аддонов от Drill'a
 
v26
- Обновление AGM
- Обновление Fireteam HUD
 
v25
- Фикс прицелов в аддоне статического вооружения
- HLC <-> RHS - полная обратная совместимость АК
 
v24
- Хотфикс для All In Arma, предотвращающий крэш
- Аддон совместимости HLC и RHS
 
v23
- Обновлен AGM
- Обновлен RHS v0.3.5
- Обновлен All In Arma
- Медицина CSE заменена аналогом от AGM (!!!)
- Статическое вооружение RDS заменено на статику от MAS (http://www.armaholic...ge.php?id=27652)
- Удален Nimitz, F-18, СУ-35
v22
- Откат модулей AGM
- Добавлен USS Nimitz
-- http://www.armaholic...ge.php?id=23049
- Добавлен F-18
-- http://www.armaholic...ge.php?id=22594
- Добавлен СУ-35
-- http://www.armaholic...ge.php?id=24024
- Добавлен наземный реверс для самолетов
- Добавлен набор масок и балаклав
-- http://www.armaholic...ge.php?id=24936

v21
- Обновление модулей AGM
- Добавлен аддон страйкеров
-- http://forums.bistud...-2-Stryker-Pack
- Добавлен стационарный Метис
- Изменены характеристики Javelin, добавлен AGM Direct/TopDown Attack
- Изменены радары M3A3 Bradley
- Изменены хитпоинты (степень повреждений) вертолетов
- Обновление подписей
 
v20
- Обновление компонентов AGM
- Фикс униформы RHS (ВС РФ могли одевать униформу армии США)
- Обновление аддона модулей платформы
 
v19
- Обновление AGM_Vehicles (Фикс пушки Bradley).
- Добавлен AGM_Reload.
- Обновление подписей
Общий объем обновленных файлов: ~ 150Кб
 
v18
- Исправление мода Agressors (зеленая фракция)
- Исправление AGM_Recoil
- Обновление конфигуратора аддонов
- atrium_modules для создания модулей условий миссии на карте
- @CBA внутри @A3RU_CORE
 
v17
- All In Arma Terrain Pack
- RHS: Escalation
- AGM
- Agressors
- RH M4 Weapons Pack
- HLC AK/FNFAL/M60E4/MP5 Weapons Pack
v16
- Обновлен CSE до 0.9.1а
- Обновлена рация TaskForce до 0.9.7
- Добавлен аддон маркеров SweetMarkers
v15
- Добавлена медицина CSE
- Обновлена рация TaskForce
- Обновлен CBA
- Добавлен аддон маркеров SweetMarkers
- Добавлен аддон отключения радара и изменения вооружения на вертолетах (класс HARD air)
- Добавлен аддон BlastCore Tracers
- Добавлены аддоны расширенной настройки аддонов от Drill
- Добавлен фикс света на островах из А2
- Добавлены аддоны L_Exshake  и L_Twitch
- убран старый аддон меток
v14
- Фикс меню в связи с выходом обновления Arma 3
v13
- Удалена рация A3RU.Radio из сборки
- Добавлен аддон, отключающий отображение отряда, внутриигровых переговоров
v12
- Применено множество фиксов к плагину для рации, которые должны повысить производительность и улучшить стабильность работы
- Новая версия плагинов для API последних версий Teamspeak 3
- Новая комбинация клавиш: SHIFT + I - открывает диалог с настройками громкости для ДВ и КВ радиостанций
- Исправлено: Баг при использовании подобранной рации врага
- Изменен конфиг диалога Fireteam HUD в соответствии с обновлением Arma 3
- Заглушены радио-переговоры ИИ
- Громкость голоса по-умолчанию - нормальная
v11
- Добавлены новые предметы: колеса разных размеров, ремонт колесной техники
- Небольшие фиксы рации
v10
- Добавлен аддон сошек для основного оружия. Клавиши: CTRL + SPACE
- Увеличена вместимость рюкзаков с ДВ-рациями
- Исправлена ошибка, выводящая сообщение о несуществующем шрифте в аддоне рации
- Добавлена информация об аддонах в конфиги для их идентификации в платформе Atrium
 
v9
- Добавлена возможность регулировки громкости речи и радиопереговоров в настройках плагина в Teamspeak'е
- Несколько багфиксов в плагине рации
- Изменено название папки с аддонами на @ARMA3RU_VI
- Новая версия цифровой подписи аддонов
 
v8
- Фикс расположения контролей главного меню для релизной версии Arma 3
 
v7
- Удалены аддоны кириллического шрифта и фикса миноментов за ненадобностью
- Добавлена вместимость 100 единиц для ДВ-рюкзаков
- Первый пресет маркера на карте - точка
 
v6.1
- По ошибке была залита прошлая версия. Перезалито!
v6
- Фикс минометов для новых классов в БЕТЕ
- Обновлен плагин рации для TeamSpeak
v5
- Добавлен шрифт с поддержкой кириллицы
v4
- Исправлено(?): Вылезающая ошибка аддона рации при погружении в воду
- Дальность действия КВ раций уменьшена до 2км (за счет появления ДВ - станций)
- Фикс минометов выделен в отдельный аддон
- Добавлен аддон ShackTac Fireteam HUD
- Добавлен датчик движения T-Cube для Fireteam HUD

Введение

Скрипты - важная часть создания миссий. Они позволяют делать чудные видеовставки (катсцены), создавать эффекты и настраивать по своей задумке практически любой аспект создаваемой миссии. Вот вам несколько различных примеров, что можно сделать скриптами: симуляция артиллерийского огня, облако ядовитого газа, а также денежная система для покупки экипировки.

Алгоритм

Ваша первая задача при написании скриптов - определить, какие шаги надо предпринять, чтобы решить какую-либо проблему. Последовательность таких шагов - это и будет алгоритм.

Например, если ваше намерение - транспортировать оружие от Петровиче до Липан, вы (как командир) отдадите вот такие приказы:

• Командир: Рядовой Хонка, рядовой Куба, ко мне!
• Командир: Рядовой Куба, сесть в Урал на место водителя!
• Командир: Рядовой Хонка, сесть в Урал!
• Командир: Рядовой Куба, езжайте в Петровиче и загрузите Урал!
• Рядовой Куба: Я не знаю, где Петровиче, сэр!

И у нас проблема. Всё, что знает Куба - это как доехать в Липаны, а Хонка знает дорогу только до Петровиче. Наши солдаты - новобранцы и они реально тупые. Они понимают только простые приказы, и-то в количестве не больше одного за раз. Сесть и вылезть из машины они могут, и вести её могут, и даже загрузить и разгрузить оружие - тоже смогут. Но командиру нужно составить правильную последовательность приказов, и предвидеть, какие препятствия исполнению этих приказов могут возникнуть.

• Пункт назначения - Петровиче
• По машинам!
• Если водитель не знает, как доехать в пункт назначения - поменяться местами водителю и пассажиру!
• Вести машину в пункт назначения
• Выйти из машины
• Загрузить машину
• Пункт назначения Липаны
• По машинам!
• Если водитель не знает, как доехать в пункт назначения - поменяться местами водителю и пассажиру!
• Вести машину в пункт назначения
• Выйти из машины
• Разгрузить машину

Интерпретатор

Когда вы составили алгоритм, вам нужно что-то, что может его исполнить. У нас есть компьютерная игра - наша несравненная Армочка, которая может это сделать; у командиров есть солдаты.

Язык программирования

Это способ - как записать наш алгоритм так, чтобы наша несравненная Армочка БИСовна его поняла и могла исполнить. Скрипты Армочки - это последовательность "приказов", описывающих, как это сделать.

Исходный код

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

Синтаксис

Синтаксис - это набор команд и параметров, причём, иногда хватает лишь одной лишь команды, как в случае команды  - exit, но чаще синтаксис в синтаксисе присутствует один и более параметров. У каждой команды есть своя страничка с руководством на вики [color=rgb(128,128,128);][читайте раздел "ArmA Scripting Tutorials: Список Cкриптовых Команд Arma 2 / Arma 3"][/color]. У каждой команды есть пример применения, указаны необходимые параметры и рассказано, как каждая команда работает [color=rgb(128,128,128);][ах, если бы - не пришлось бы это всё писать, кабы было оно так][/color].

if (PrivateHonka == TheMostCleverSoldierInTheWorld) then {
	IAmChineseGodOfHumour = true;
};//Если рядовой Хонка самый умный солдат в мире, то я - китайский бог юмора

Стоит заметить, что в Армочке есть две скриптовых грамоты - SQS и SQF [color=rgb(128,128,128);][на вторую ждите скорой статьи, а от первой БИСы советуют отказываться в пользу SQF везде, где только можно][/color]. И хотя большинство функций у них одинаковы, всё-таки существуют некоторые различия в написании выражений, ходе программы и управляющих структурах.

Как работает интерпретатор

Несравненный движок несравненной Армочки читает ваш код из скриптовых файлов и переводит команды в соответствующие им действия, и на выходе вы получаете желаемый эффект/результат в игре.

Начнём же!

Каждый скрипт состоит из набора команд [color=rgb(128,128,128);font-family:helvetica, arial, sans-serif;][читайте раздел "ArmA Scripting Tutorials: Список Cкриптовых Команд Arma 2 / Arma 3"][/color] и выражений, управляющих ходом программы (в Армочке они исполняются как команды, но на данном этапе это неважно [color=rgb(128,128,128);font-family:helvetica, arial, sans-serif;][ждите статью по управляющим структурам, где это будет объяснено подробнее][/color]). Самой используемой командой при первых ваших шагах в скриптописании может стать команда titleText. Она может написать любой текст, какой вы захотите, на экране игрока.

titleText ["Good morning, captain", "PLAIN DOWN"]; 

Перед вами самый обычный способ вызова команд. Сразу за именем команды следуют параметры (но это всё-таки зависит от команды, и надо сверяться с руководством). Каждая команда может иметь не более одного параметра перед своим именем и/или один - после имени (большее количество аргументов может быть передано с помощью массивов, поскольку один массив воспринимается как один параметр). Параметры могут быть самых различных типов [color=rgb(128,128,128);][ждите материал по типам данных][/color]. В нашем примере параметр - это массив [color=rgb(128,128,128);][читайте урок по массивам в трёх частях, или хотя бы его первую часть][/color] - набор других типов данных. Он может содержать от 0 до 4096 (?) значений. Первое значение - это строка представляющая собой текст, который будет выведен на экран, а второе значение, в данном случае, говорит в каком месте экрана текст будет показан (см. руководство к команде titleText). Также, данная команда допускает третье значение в массиве - число, которое укажет, как долго текст будет появляться на экране , если значение не введено, будет использоваться значение по умолчанию (1).

titleText ["Good morning, captain", "BLACK IN", 5]; 

Скрипты, которые называются функциями, нахотядся в .sqf-файлах в папке миссии, те же, что хранятся в .sqs-файлах, называются скриптами.

теперь вы можете попробовать исполнить наш "скриптик". Для этого создайте в редакторе миссию, сохраните её под каким-нибудь названием, например testingmission, откройте текстовый редактор (блокнот сойдёт), напишите:

titleText ["Good morning, captain", "PLAIN DOWN"]; 

и сохраните файл как hello.sqf в папку с только что созданной миссией. В редакторе, в своей миссии добавьте солдатика, и напишите в его строке инициализации:

nul = [] execVM "hello.sqf" 

Теперь, когда вы запустите эту миссию, вы должны будете увидеть результат работы скрипта. Отлично, солдат!

Настоятельно рекомендую ознакомиться с разделом "ArmA Scripting Tutorials: Начинаем",- поскольку там представлен более удобный и быстрый способ знакомства со скриптами. Но эта статья тоже должна быть полезна - тут первое упоминание того, как же добавлять скрипты в миссии.

Ведите себя хорошо

Несмотря на то, что я взял эту статью у КК и указал его, как автора, должен заметить, что список на его сайте [color=#808080;][пока не умею размечать таблицы на этом форуме - вам придётся ходить по ссылочкам][/color] весьма и весьма современен и удобен, это не единственное место, где вы можете найти эти команды. Более того, все, кто занимается скриптописанием прекрасно знают эти места, но для новичков эта информация может оказаться полезной

Вот вам ещё ссылок:

http://community.bis...Commands_Arma_3

http://community.bis...g_Commands_List

Чтобы найти интересующую команду в данных списках, можно нажать Ctrl+F [color=#808080;][Да, знаю, что те, кто с этим имеет дело, знают эту команду, но вы не поверите, сколько мне встретилось человеков за последние 2 года, кто этого не умел[/color]], кроме того, в отладочной консоли в Армочке можно набрать команду и нажать F1.

Перевод свободный, поэтому, посещение оригинала лишь привествуется.

Стоит запомнить, что движок армы в своей повседневной работе слегка долбанутый - он очень любит создавать работу сам себе, и если вы не скажете ему остановиться и передохнуть, он будет продолжать и продолжать делать что-нибудь. Сегодня в фокусе нашего внимания - выражения с условными операторами, возвращающими нам значения true или false. Давайте взглянем на простой пример:

if (a && b && c) then {
    //делайте что-нибудь
};

Что мы имеем: если a, b и c - все имеют значение true, то всё выражение в скобках () должно быть оценено как true и наш код в фигурных скобках {} будет исполнен. В общем, КАЖДАЯ переменная должна иметь значение true, чтобы всё выражение было расценено как true. Выражения оцениваются движком слева направо и в идеале, если a принимает значение false, нам не нужно дальше оценивать выражение. Ну что тут скажешь, движок Армочки думает иначе, и продолжает проверять всё, до тех пор, пока не встретит закрывающуюся скобку ).

Как это влияет на написание кода? Это значит, что  для того, чтобы ускорить работу скриптов, вам лучше каскадировать несколько операторов if. Приведённый выше код может быть оптимизирован как:

if (a) then {
    if (b) then {
        if (c) then {
            //делайте что-нибудь
         };
    };
};

В этом случае, если a принимает значение false, то движок игнорирует код фигурных скобках {} и переходит к выполнению других задач.

К нашему счастью, в BETA 93632 в движок Армочки была введена "ленивая" оценка условий.

New: Lazy evaluation variants of scripting functions and / or.

Чтобы включить это чудо, нужно использовать другой синтаксис. Обычный режим оценки условий включается при вот таком синтаксисе:

• boolean [and/or] boolean [and/or] boolean … [and/or] boolean​
•  

Сравните это с синтаксисом "ленивой" оценки условий:

• boolean [and/or] code [and/or] code … [and/or] code
•  

Начинается оценка с переменной булевого типа, а продолжается с оценкой кода. Вы можете использовать булевый тип данных только однажды и только в самом начале выражения. Вам необходимо осуществить оценку кода и приведению к значениям true или false, так же как и переменные булевого типа. Итак, чтобы включить "ленивую" оценку условий нам нужно переписать наш пример как:

if (a && {b} && {c}) then {
    //делайте что-нибудь
};

Не так уж и плохо, хотя, для единообразия, лучше бы оно и начиналось с кода - было бы безобразно, зато единообразно, а не как сейчас. Кстати, это работает даже с операторами switch, while и waitUntil.

private ["_result","_step","_c"];
_result = "is false";
a = {
    _step = "1";
    true;
};
b = {
    _step = "2";
    false;
};
_c = {
    _step = "3";
    true;
};
scopeName "main";
while {call a && b && _c} do {
    _result = "is true";
    breakTo "main";
};
hintSilent format ["expression %1, quit at step %2", _result, _step];

Исполнение этого кода выведет: Expression is false, quit at step 2. Ну вот он и закончился, мой урок по "ленивой" оценке условий в Армочке.

Есть смысл применять тогда и только тогда, когда события обязаны выполняться в определённом порядке, и хоть сколь-нибудь ощутимый выигрыш можно получить при применении метода if () then { if () then { if () then {}}}; Этот метод даёт выигрыш, если вещи идут в нужном вам порядке, и ухудшает производительность, если этот порядок нарушается, применение же БИСовской оптимизации не даёт почти никакого выигрыша, если вещи идут в нужном вам порядке, и ухудшает производительность, если этот порядок может быть нарушен.

Ведите себя хорошо,

КК

Что такое специальные переменные? Эти переменные обладают особой значимостью для движка. Приватные же специальные переменные ограничены в пределах функции, к которой они приписаны, и могут уже содержать какие-либо данные, когда к ним идёт обращение. [color=#808080;][Значение этой переменной может быть изменена только самой функцией, которой она вызывается - в этом весь смысл приватности][/color].

Типичными приватными специальными переменными, которые вы наверняка уже знаете являются _this, которая используется для передачи параметров в скрипты, _x, используемая в циклах forEach и счётных циклах и _forEachIndex тоже используемая в циклах forEach. Другие специальные частные переменные менее известны, но несмотря на это они всё-таки специальные.

Как показывает практика, лучше, чтобы имена специальных переменных не конфликтовали не совпадали с именами приватных переменных, созданных кодером. Вот почему специальные переменные имеют свою подсветку в автоподсветке синтаксиса, созданной КК. А как у Блендера? - либо маякните, либо я позже сам посмотрю,- чтобы кодер сразу это видел. На сайте с оригинальной статьёй (клац) приведён список всех специальных переменных, которые КК смог найти. Если вам известны другие частные переменные, используемые в Армочке, и они похожи на специальные, пожалуйста, поделитесь этой инфой.

Ведите себя хорошо

P.S. И если кто может сказать, как разметить таблицу для удобного представления данных на этом форуме - напишите об этом, пожалуйста (можно в ПМ).

Армочка полна массивов, и так уж случилось, что тов. КК тоже их любит. Неважно, вызываете вы скрипт или функцию, добавляете предметы в инвентарь или считываете положение объекта, рано или поздно вам придётся иметь дело с массивами. Очень много важных команд в Армочке возвращает результаты в виде массива, и наступит время, когда вам нужно будет считывать массивы значений из классов конфигураций.

Узнать массив можно по квадратным скобкам. Чтобы определить массив, назначьте переменной пустой массив [] или заполните его значениями через запятую. Значениями массива могут быть числа, строки, булевы значения, объекты, другие переменные, да всё не перечислить. И даже всё вышеперечисленное может быть содержимым массива.

_array = []; //пустой массив
_array = [1,2,3,4,5,6,7,8,9]; //массив чисел
_array = ["Bob","Peter","John"]; //массив строк
_array = [player,_var,true,var,56,"ok",_this]; //смешанный массив 

Массив может не содержать никаких значений (пустой массив), может содержать 1 элемент, или множество элементов, даже массивы внутри массивов. Чтобы узнать сколько элементов содержится в массиве, можно сосчитать их командой count.

_array = [];
_result = count _array; //_result = 0
_array = ["hello"];
_result = count _array; //_result = 1
_array = [1,2,3];
_result = count _array; //_result = 3 

Команда count может считать элементы только в одномерном массиве. Чтобы исследовать многоразмерный массив, вам нужно проделать несколько итераций - для каждого измерения отдельно.

_array = [[1,2,3],[5,6,7]]; //В массиве содержится ещё два массива: [1,2,3] и [5,6,7]

Чтобы получить доступ к элементу массива вам нужно использовать команду select  и индекс элемента, к которому вы хотите получить доступ. Самому первому элементу в массиве (слева направо) соответствует индекс 0, второму соответстует 1, третьему - 2 и т.д. Таким образом, чтобы получить доступ к 15-му элементу, необходимо использовать команду select 14. Чтобы получить доступ к последнему элементу массива, нужно сначала посчитать количество элементов в массиве и вычесть 1 из результата.

_array = ["orange","blue","red","green"];
_result = _array select 1; //_result = "blue"
_result = _array select ((count _array) - 1); //_result = "green", последний элемент

Чтобы получить доступ к элементу многомерного массива, необходимо отслеживать иерархию массива. Чтобы выбрать 3-й элемент 1-го массива, внутри 2-го массива (внутри общего массива _array):

_array = [[[1,2],[3,4]],[[5,6,7],[8,9]]];
_result = ((_array select 1) select 0) select 2; //_result = 7 

[color=#808080;][сначала выполняются команды в скобках, потом те, что за скобками][/color]

А теперь снова вернёмся к команде count. У этой команды есть альтернативный синтаксис, который позволяет выполнять код на каждый отдельный элемент массива. Если выполненный код возвращает true, элемент считается, если же нет - не считается. Например, нам нужно узнать, как много раз имя John встречается в следующем массиве:

_array = ["John","Samantha","Billy","Archer","John","John","Peter","Casey"];
_result = {_x == "John"} count _array; //_result = 3 

Пытливый читатель (обожаю этот оборот, как и "не имеет аналогов") может заметить, что мы используем в коде _x. В таком формате команда count будет просматривать каждый элемент массива, и вызывать код {} в каждой итерации. _x является специальной переменной, которая приписывается к тому элементу массива, с которым сейчас работает команда count. Поэтому, если значение элемента, с которым мы сейчас работаем есть John, то он считается. Да, и ещё, будьте бдительны: когда вы работаете со смешанным массивом, убедитесь, что производите сравнение с правильным типом данных.

//ЛАЖА
_array = ["John",23,"Samantha",25,"Billy",67,"Archer",45,"John",23,"John",32];
_result = {_x == "John"} count _array; //ОШИБКА скрипта

Показанный выше массив выдаст ошибку, как только доберётся до второго элемента в массиве, потому что код в функции count ожидает типа данных string, а вместо этого получает число. Чтобы недопустить этого, вы можете проверить тип данных элемента перед выполнением сравнения. Также в приведённом ниже примере используется "ленивая" проверка условия, потому что обычная выдаст ошибку.

//ВСЁ ЧЁТКО
_array = ["John",23,"Samantha",25,"Billy",67,"Archer",45,"John",23,"John",32];
_result = {typeName _x == "STRING" && {_x == "John"}} count _array; //нет ОШИБКИ 

Если нужно просто узнать, есть ли элемент с определённым значением в массиве, используйте команду in. Она возвращает true если такой элемент есть, и false - если его нет. Чтобы проверить, присутствует ли такой элемент, и если есть, то узнать его индекс, пользуйтесь командой find. Команда find вернёт значение -1, если совпадений не найдено, в обратном случае, она вернёт индекс первого совпадающего элемента.

_array = [1,"two",3,"four",1,"two",3,"four"];
_result = "four" in _array; //_result = true;
_result = 4 in _array; //_result = false;
_result = _array find "three"; //_result = -1
_result = _array find 3; //_result = 2 

Стоит отметить, что обе команды find и in чувствительны к регистру, и обе же они не работают со вложенными массивами.

_array = ["one","two","three"];
_result = "TWO" in _array; //_result is false
_result = _array find "TWO"; //_result is -1
_array = [[1,2,3],[4,5,6]];
_result = [1,2,3] in _array; //_result is false
_result = _array find [1,2,3]; //_result is -1 

На этом мы завершаем первую часть урока, посвященного массивам. Во второй части будет рассказано как манипулировать массивами и изменять их.

Ведите себя хорошо

В первой части объяснялось, по большей части, то, как получить информацию из архивов. В этой части мы собираемся посмотреть как их изменять и как манипулировать ими. Но сначала позвольте рассказать о ещё двух командах, связанных с массивами, они вам понадобятся когда будете работать с записями в конфигах классов, getArray и isArray. getArray возвращает выходные данные правильного типа (массив), но не конвертирует их. Например, если запись в конфиге имеют строковый тип (string), навроде "sometextstring", getArray выдаст [], а не ["sometextstring"]. isArray просто говорит, является ли запись конфига массивом или нет.

class MakarovSD: Makarov {
  descriptionshort = "Silenced semi-automatic pistol <br/>Caliber: 9x18mm";
  displayname = "Makarov SD";
  magazines[] = {"8Rnd_9x18_MakarovSD", "8Rnd_9x18_Makarov"};
  ...
};

_result = isArray (configFile >> "cfgWeapons" >> "MakarovSD" >> "magazines");
//_result = true
_result = getArray (configFile >> "cfgWeapons" >> "MakarovSD" >> "magazines");
//_result = ["8Rnd_9x18_MakarovSD","8Rnd_9x18_Makarov"]
_result = getText (configFile >> "cfgWeapons" >> "MakarovSD" >> "magazines");
//_result = ""
_result = isArray (configFile >> "cfgWeapons" >> "MakarovSD" >> "displayname");
//_result = false
_result = getArray (configFile >> "cfgWeapons" >> "MakarovSD" >> "displayname");
//_result = []
_result = getText (configFile >> "cfgWeapons" >> "MakarovSD" >> "displayname");
//_result = "MakarovSD" 

Чтобы поменять значение, записанное в  элемент массива, пользуйтесь командой set. Эту команду надо запускать с аргументами [index,newvalue] [color=#808080;]([индекс,новое значение])[/color]. set дополнительно изменит размер массива, если вы записываете новое значение, которое выходит за длину массива. Кроме того, вы можете напрямую изменить размер массива командой resize. Команда resize либо "обрежет", либо "растянет" массив, в зависимости от значения введённого вами аргумента.

_array = [1,2,3,4,6,6,7,8,9];
_array set [4,5];
//значение _array теперь будет [1,2,3,5,5,6,7,8,9]
_array set [count _array,10];
//теперь _array становится [1,2,3,4,5,6,7,8,9,10]
_array set [12,13];
//_array теперь [1,2,3,4,5,6,7,8,9,10,<null>,<null>,13]
_array resize 3;
//_array теперь [1,2,3]
_array resize 5;
//_array теперь [1,2,3,<null>,<null>]
_array resize 0;
//_array теперь []

Вы можете убрать определение с элемента массива, присваивая ему значение nil. Эта команда не будет ни стрирать элемент, ни изменять длину массива.

_array = [1,2,3,4,5];
_array set [2,nil];
//_array примет значение [1,2,any,4,5]

В Армочке нет способа убрать элемент из массива, при этом одновременно изменив его длину. Но есть несколько "костылей", основанных на сложении и вычитании массивов в Армочке. Вы можете складывать и вычитать массивы друг из друга. Сложение массивов приведёт к тому, что добавит значения из второго массива в первый, соответственно, изменив его длину.

_array = [4,5,6];
_array = _array + [7,8,9];
//_array = [4,5,7,8,9]
_array = [1,2,3] + _array;
//_array = [1,2,3,4,5,6,7,8,9] 

Вычитание же удалит ВСЕ элементы второго массива из 1-го, изменяя длину первого массива.

_array = [1,1,2,2,3,3,4,4,5,5];
_array = _array - [1];
//_array принимает значение [2,2,3,3,4,4,5,5]
_array = _array - [4,2,5];
//теперь наш _array = [3,3] 

Если элементом массива является массив, он не может вычитаться из дугого массива.

_array = [[1,2],[3,4]];
_array = _array - [1,2];
//_array по прежнему равен [[1,2],[3,4]] 

Таким образом, чтобы убрать элемент из  массива, надо сначала изменить его значение, на что-нибудь, не имеющее аналогов в данном массиве (теперь всегда буду переводить так слово "уникальный"), а потом вычесть это значение. Кстати, присваивание и вычетание нулевых объектов, таких как objNull, locationNull, grpNull, taskNull, teamMemberNull, controlNull, displayNull - тоже работает.

_array = [1,2,3,4,5];
_array = set [1,"deletethis"];
//_array принимает значение [1,"deletethis",3,4,5]
_array = _array - ["deletethis"];
// теперь _array равен [1,3,4,5]_
array set [3,objNull];
//_array равен [1,3,4,<Null-object>]
_array = _array - [objNull];
//_array равен [1,2,3]; 

Если вам хочется добавить элемент в массив, и при этом вам необходимо, чтобы он не имел аналогов, то для этого есть неплохой трюк. Конечно, всегда можно сначала проверить, имеется ли такой элемент в массиве или нет, но можно предположить, что он есть, вычесть его, и добавить заново. После столь хитрожопого действа, новый добавленный вами элемент точно не будет иметь аналогов.

_array = [1,2,3,4,5];
_array = (_array - [6]) + [6];
//_array равен [1,2,3,4,5,6]
_array = (_array - [6]) + [6];
//_array по-прежнему [1,2,3,4,5,6] 

На этом мы завершаем вторую часть массивного урока. Дополнительные инструменты по работе с массивами вы сможете найти в третьей части марлезонского балета нашего урока

Итак, во второй части мы научились манипулировать с массивами. Время перейти к кое-чему посложнее, навроде копирования массивов. Видите ли, если вы присваиваете значения одного массива другому, навроде _array2=_array1, вы не создаёте независимый массив _array2, но создаёте ссылку на _array1. Если после этого вы меняете каким-либо образом _array2, те же изменения произойдут и в _array1. И если бы на этом всё заканчивалось, но нет же! Если вы передадите _array1 в какую-либо функцию, как параметр, а внутри функции присвоите его значения массиву _array2, то изменения в _array2 будут и в этом случае влиять на _array1.

_array1 = [1,2,3];
_array2 = _array1;
_array2 set [2,0];
//_array1 равен [1,2,0]
a = {	private ["_array2"];
	_array2 = _this;
	_array2 set [2,10];
};
_array1 call a;
//_array1 = [1,2,10] 

Во избежание сего конфуза вы можете добавить или вычесть пустой массив из оригинального массива, затем присвоить результат вашему новому создаваемому массиву, или исопользовать оператор +, который создаёт копию массива, а не создаёт ссылки на оригинальный массив. Хорошенько запомните это, поскольку это спасёт вас от вырывания волос на собственной голове (или спине - кто уж откуда вырывает) при отлаживании скриптов.

_array1 = [1,2,3];
_array2 = [] + _array1;
//_array2 = [1,2,3]
_array2 set [2,0];
//_array1 как и был - [1,2,3], _array2 теперь будет [1,2,0]
_array2 = _array1 + [];
//_array2 = [1,2,3]
_array2 set [2,10]
//_array1 как и был - [1,2,3], _array2 теперь будет [1,2,10]
_array2 = _array1 - [];
//_array2 = [1,2,3]
_array2 set [2,20];
//_array1 как и был - [1,2,3], _array2 теперь будет [1,2,20]
_array2 = + _array1;
//_array2 = [1,2,3]
_array2 set [2,30];
//_array1 как и был - [1,2,3], _array2 теперь будет [1,2,30] 

Чтобы изменить значение элемента в массиве, глубоко вложенном в другие массивы, просто аккуратно выбирайте элементы, следуя иерархии массивов, а когда дойдёте до нужного элемента, просто установите его значение, как обычно.

_array = [[1,2,3],[4,5,6],[7,8,[9,10]]];
((_array select 2) select 2) set [0,10];
//_array = [[1,2,3],[4,5,6],[7,8,[10,10]]] 

Чтобы поочерёдно пройтись по одному измерению массива, просто пользуйтесь командой forEach. Она именно это и делает - проходит по каждому элементу последовательно, похоже на команду count, которую мы рассматривали в первой части. Специальная переменная [font="'courier new', courier, monospace;"]_x[/font] будет содержать значение текущего элемента массива, а специальная переменная [font="'courier new', courier, monospace;"]_forEachIndex[/font] - его (текущего элемента) индекс, так что, если вам он когда-нибудь понадобится - вы знаете, где его искать.

_array = ["John","Paul","George","Ringo","John","Paul","George","Ringo"];
_lastGeorgeIndex = -1;
{
	if (_x == "George") then {
		_lastGeorgeIndex = _forEachIndex;
	};
} forEach _array;
//_lastGeorgeIndex = 6 

Ну а теперь к интересненькому. Забудьте об использовании функций, сделанных сторонними производителями, навроде BIS_fnc_selectRandom, чтобы случайно выбирать 1 элемент из массива. Будьте умнее - полностью контролируйте ваши скрипты. Вся эта функция может быть сделана однострочным выражением.

private ["_colours","_randomColour"];
_colours = ["green","yellow","purple","white"];
_randomColour = _colours select (floor (random (count _colours)));
//чётко, да? 

Кстати, в Армочке нет как такового манипулирования текстом, нет регулярных выражений, а сравнение строк нечувствительно к регистру ("hEllO" == "heLLo" выдаст true в качестве результата, чтобы получить зависимое от регистра сравнение, надо воспользоваться оператором switch/case). Но есть команда toArray. Она преобразует любую строку в массив ASCII значений, то есть массив чисел. После этого вы можете совершить операции с массивом и toString'нуть обратно, когда закончите. Вот пример из практики: когда хочется привести в порядок имена, и заменить символы открывающихся и закрывающихся угловых скобок <> значениями &lt и &gt соответственно, чтобы они не мешались со структурированным текстом.

private ["_array","_temp","_sanitised"];
_array = toArray "<<<Killzone_Kid>>>";
_temp = [];
{
	switch _x do {
		case 60 : {
			_temp = _temp + toArray "&lt;";
		};
		case 62 : {
			_temp = _temp + toArray "&gt;";
		};
		default {
			_temp = _temp + [_x];
		};
	};
} forEach _array;_sanitised = toString _temp;
//_sanitised = &lt;&lt;&lt;Killzone_Kid&gt;&gt;&gt; 

Ну на этом всё, завершаем с массивами. КК даже не думал, что эта третья часть будет написана, когда начинал. И КК надеется, что вы нашли для себя что-нибудь полезное в этом уроке из трёх частей.

Ведите себя хорошо

Цикл - это кода кусок, который повторяется, и повторяется, и повторяется, и повторяется, и повторяется, и ... Когда-нибудь такая хитрая штука понадобится и вам, и есть не так уж много путей, как организовать сие. Сейчас приведу пример. Допустим, вам необходимо добавить 3 одинаковых вещи в инвентарь. Вы можете просто добавить вещь, добавить вещь и добавить вещь - всего три раза. Но если вам придётся делать это 20 раз, что может быть лучше, чем написать простенький код и зациклить его на 20 повторений? Быстро и изящно.

Циклы for.  Эти циклы позволяют выполнить кода кусок, заключённый в фигурные скобки {} указанное количество раз. Синтаксис позволяет установить счётчик двумя способами. Хотя они очень похожи, всё-таки разница между ними есть, и от того, какой способ вы выберете, будет зависеть производительность, а разница такая нехеровая - один способ работает в 2,5 раза быстрее, чем другой.

for "_i" from 5 to 93 step 7 do {hint str _i}; //последнее значение _i равно 96

Это быстрый вариант цикла. Этот синтаксис читается примерно так: Создай приватную переменную _i, присвой ей значение 5, проверь, не является ли эта переменная большей или равной 93, и если является, то заверши цикл, если же нет, то выведи на экран командой hint значение _i на экран, а затем прибавь к ней 7, и снова проверь, не является ли теперь переменная большей или равной 93, и если является, то заверши цикл, если же нет, то выведи на экран командой hint значение _i на экран, а затем прибавь к ней 7... и так далее, пока условие проверки не будет соответствовать тому, что от неё ожидается (что она будет большей или равной 93), и тогда цикл завершается. Если вы опустите step, то _i будет увеличиваться с шагом 1 по умолчанию. Вы можете заметить, что результат "выскакивает" за предел 93, который мы установили (значение _i при завершении цикла будет равно 96 - можете проверить на логарифмической линейке). Так происходит, поскольку при данном синтаксисе проверка условия выглядит как если _i >=93, то завершай цикл. Также, значение to проверяется только один раз - в самом начале цикла, поэтому, вы можете использовать, например, ceil(random 10), чтобы задать случайное количество итераций, скомпилировано это будет только один раз. Ещё одна характерная особенность этой конструкции - то, что _i является частной переменной, и область её действия ограничена лишь этим циклом, это означает, что если у вас где-то за пределами цикла есть переменная _i, то изменения в нашей _i ту, внешнюю, _i не испортят. Бесконечный цикл можно создать, если задать step равным 0.

for "_i" from 0 to 1 step 0 do {};//будет зацикленно навечно 

Если вам случалось кодить на других языках, то вам, возможно, удобнее другой вариант циклов for. Медленный.

for [{_i=5},{_i<=93},{_i=_i+7}] do {hint str _i}; // последнее значение _i равно 89 

Такой синтаксис читается несколько иначе: Присвой переменной _i значение 5, проверь, чтобы оно было меньше или равно 93, если это не так, то заверши цикл, если всё так, то хинтани значение _i на экран, и увеличь _i на 7, снова проверь, чтобы оно было меньше или равно 93, если это не так, то заверши цикл, если всё так, то хинтани значение _i на экран, и увеличь _i на 7 ... и продолжай, пока проверяемое условие не станет ложным, и тогда завершай цикл. В противоположность первому условию, _i никогда не будет больше установленного порога. Так получается, потому что здесь условие проверки несколько иное - пока _i<=93 повторяй. В довесок к этому, переменная _i не будет приватной, если вы сами её такой не сделаете, непосредственно указав это требование.

_i = 101;
for [{private "_i"; _i=5},{_i<=93},{_i=_i+7}] do {};
hint str _i; //на экран хинтанётся значение 101 

В отличие от первого варианта цикла for, этот цикл проверяет условие завершения каждую итерацию, и я предполагаю, что именно поэтому он медленнее. Но зато вы можете динамически изменять количество итераций, которое он совершит.

k = 3; a = {k = k + 0.5; k};
for [{_i=0},{i<(call a)},{_i=_i+1}] do {
	diag_log format ["_i:%1/k:%2", _i, k];
};
//.rpt файл
//"_i:0/k:3.5"
//"_i:1/k:4"
//"_i:2/k:4.5"
//"_i:3/k:5"
//"_i:4/k:5.5"
//"_i:5/k:6"
//"_i:6/k:6.5" 

Такой цикл тоже можно сделать бесконечным как намеренно, так и случайно. Всё, что вам надо сделать - обеспечить, чтобы результат проверки всегда выдавал результат true.

for [{_i=0},{true},{_i=_i+1}] do {}; //будет выполняться бесконечно 

Вы можете сказать: "воу-воу, палехчи! чё мы тут паримся, забубеним while и всё будет ништяк!" Что же, не совсем так, ну, по крайней мере, не всегда. Давайте взглянем на циклы while.

_i=5; while {_i<=93} do {hint str _i; _i=_i+7};// последнее значение _i = 89
_i=5; while {_i<=93} do {_i=_i+7}; hint str _i;// последнее значение _i = 96 

В результате очевидно, что мы можем достичь с циклом while тех же результатов, что и с циклом for. Но также очень просто ошибиться и сделать порог, который будет догонять наша переменная, и никогда не догонит, поэтому движком несравненной Армочки количество выполняемых while-циклов ограниченно 10000 итераций, после чего происходит выход из цикла. Поместите следующий кода кусок в поле init юнита в редакторе и нажмите превью.

i=0; while {true} do {i=i+1}; hint str i;//в результате исполнения цикла на экране хинтанётся 10000 

Такое ограничение установлено, потому что когда скрипт вызывается движком, он должен ждать от for до возвращения, прежде чем сможет делать что-то ещё. И нехорошести могут случиться, когда вы вызываете командой call бесконечный while-цикл из обработчика событий, FSM-скрипта или строки инициализации. Если ваш скрипт выполняется с помощью команды spawn или execVM, вы можете сделать бесконечный while-цикл. А у вышеупомянутых циклов for нет таких ограничений. Кстати, файл init.sqf не вызывается, поэтому, в нём цикл while может крутиться вечно. Объединим вышесказанное:

spawn {while {true} do {}} //бесконечно бесконечен
call {while {true} do {}} // 10000 если вызван из FSM или обработчика событий, или поля init
call {while {true} do {}} // бесконечен, если вызван из init.sqf или execVM
spawn {call {while {true} do {}}} //бесконечно бесконечен 

Большинство человеков используют циклы while true, чтобы проверять разные вещи, а особо он популярен когда человеки делятся своими кодами, поскольку это самый простой способ подключить кусок кода к уже существующему коду. Это отстой: мало кто хочет, чтобы полчища циклов срали ему в процессор, и ухудшали производительность его пекарни. Не делайте так, научитесь использовать обработчики событий (event handler). У несравненной Армочки есть множество разнообразных обработчиков событий, которые запустят ваш код, когда сработает установленное для его выполнения условие.

Допустим, вам нужно узнать, когда игрок садится в машину или выходит из неё.

//хорошо
_veh addEventHandler ["GetIn",{_this call isIn}];
_veh addEventHandler ["GetOut",{_this call isOut}];

//не очень хорошо
lastVehicle = objNull;
lastSeat = "";
null = [] spawn {
	private ["_veh","_roles","_seat"];
	while {true} do {
		_veh = vehicle player;
		if (_veh != player) then {
			_roles = assignedVehicleRole player;
			_seat = if (count _roles > 0) then [{_roles select 0},{""}];
			if (_veh != lastVehicle || _seat != lastSeat) then {
				lastVehicle = _veh;
				lastSeat = _seat;
				[_veh, _seat, player] call isIn;
			};
		} else {
			if (!isNull lastVehicle) then {
				[lastVehicle, lastSeat, player] call isOut;
			};
		};
		sleep 0.1;
	};
}; 

Если вы хотите повысить скорость отклика в примере с while, вам нужно уменьшить значение sleep, что приведёт к большему количеству повторений, и пустому расходованию ресурсов процессора. А обработчик событий, просто врубает ваш скрипт так быстро, как только возможно, каждый раз.

Цикл forEach. В уроке про массивы мы его касались, поэтому его получится объяснить быстрее. Этот цикл проходит по массиву, перебирая его элементы по-одному, и завершается, когда в данном массиве не остаётся непройденных элементов. Если вы попытаетесь добавить или удалить элементы из исходного массива операторами + или - в то время, как работает цикл, это не повлияет на количество итераций, не смотря на то, что длина исходного массива изменилась.

_array = [1,2,3];
diag_log format ["_array:%1", _array];
{
	_array = _array + [0];
	diag_log format ["_x:%1/_forEachIndex:%2/_array:%3", _x, _forEachIndex, _array];
} forEach _array;
diag_log format ["_array:%1", _array];
//.rpt файл
//"_array:[1,2,3]"
//"_x:1/_forEachIndex:0/_array:[1,2,3,0]"
//"_x:2/_forEachIndex:1/_array:[1,2,3,0,0]"
//"_x:3/_forEachIndex:2/_array:[1,2,3,0,0,0]"
//"_array:[1,2,3,0,0,0]" 

И всё же, следует быть крайне осторожным с командой set, поскольку , поскольку если она изменит исходный массив во время работы цикла, то может случиться и так, что цикл станет бесконечным. В следующем примере используется команда min, чтобы ограничить длину массива и остановить цикл, не дав ему убежать в бесконечность.

_array = [1,2,3];
diag_log format ["_array:%1", _array];
{
	_array set [(count _array) min 5, 0];
	diag_log format ["_x:%1/_forEachIndex:%2/_array:%3", _x, _forEachIndex, _array];
} forEach _array;
diag_log format ["_array:%1", _array];
//.rpt file
//"_array:[1,2,3]"
//"_x:1/_forEachIndex:0/_array:[1,2,3,0]"
//"_x:2/_forEachIndex:1/_array:[1,2,3,0,0]"
//"_x:3/_forEachIndex:2/_array:[1,2,3,0,0,0]"
//"_x:0/_forEachIndex:3/_array:[1,2,3,0,0,0]"
//"_x:0/_forEachIndex:4/_array:[1,2,3,0,0,0]"
//"_x:0/_forEachIndex:5/_array:[1,2,3,0,0,0]"
//"_array:[1,2,3,0,0,0]" 

А есть ещё 3 дополнительных цикла forEach, специально сделанных для работы с группами: forEachMember, forEachTeamMember и forEachMemberAgent. Во всех этих случаях переменная _x содержит значение текущего элемента, а _forEachIndex - его индекс.

Баааалин, чуть не забыл про цикл onEachFrame. Это бесконечный цикл, который будет выполнять код в фигурных скобках {вот этот вот} каждый кадр. Полезно, если вам нужно выводить на экран что-то, связанное с вашим FPS. Например, есть у вас один скрипт GUI (графическое пользовательское междумордие), сделанный на while-true, и если поставить его молотить с параметром sleep равным 0.01, то он будет отрисовывать HUD (намордный дисплей) 100 раз в секунду, ну и какой в этом смысл, даже если у вас 60 FPS, не говоря уж о более приземлённых значениях. В этом случае команда onEachFrame подходит как нельзя лучше.

onEachFrame {hint str diag_fps};
onEachFrame {hint str diag_tickTime}; 

Эта команда зацикленно запускает код в фигурных скобках {}. Движок может запустить только одну инстанцию onEachFrame, поэтому каждый последующий вызов этой команды заменит собой предыдущий вызов. Чтобы отменить исполнение команды onEachFrame, нужно запустить её снова с пустым кодом. Она не допускает использования других способов останова скрипта, навроде sleep или waitUntil. И ещё, если вам надо передать какой-либо параметр в код внутри этого цикла, вы будете вынуждены использовать глобальную переменную.

_i = "123";
onEachFrame {
	hint str (isNil "_i"); // хинт будет постоянно выводить "true"
};
cutText [str _i, "PLAIN DOWN"]; //скрипт продолжает выполняться и начинает выводить "123"
onEachFrame {hint "1"; sleep 1; hint "2"); //.rpt засерается ошибками
i = 0;
onEachFrame {
	i = i + 1;
	hint str i; //хинт начинает считать
};
i = 0; //старое значение хинта сбрасывается и, хинт начинает считать заново
onEachFrame {}; // отменяет цикл 

Ждите ещё интересный материалов по циклам - их есть у меня

Ведите себя хорошо.

Мне хотелось бы вернуться к уроку по циклам и особое внимание уделить циклам, которые могут запускаться каждый кадр. Почему именно на них? Да потому что если вы привязываете код к FPSу, то вы получаете наилучшую возможную скорость отклика вкупе с наиболее плавным отображением. Сейчас объясню о чём я - если вам нужно двигать что-то на экране, обновлять это что-то каждый фрейм - это всё, что вам нужно, поскольку это именно то, что вы видите. Нет никакого смысла обновлять такие вещи между фреймами, даже если ресурсы позволяют. То же самое с откликом/реакцией - вы видите реакцию/отклик только если у вас обновляется кадр.

Вот несколько фактов. Обычный цикл for может быть выполнен около 170 000 раз в секунду, когда вызывается напрямую обработчиком событий или FSM. Если вы spawn'ите или execVM'ите этот же цикл, у вас получится порядка 25 000 раз в секунду. Чтобы не отставать от фреймрейта вам надо выполнить всего 60 итераций (40/30/25/15 - зависит от фреймрейта) в секунду.

В прошлом уроке я уже касался цикла onEachFrame. И хотя эта команда хороша для быстрого исполнения грязной работёнки, у неё есть большой минус - вы не можете запустить несколько циклов onEachFrame одновременно, этих циклов не может быть больше одного. А ещё его нельзя приостановить командами навроде sleep.

Другим способом создания циклов, привязанных к фреймрейту, является установка обработчиков событий. В Армочке Третьей вы можете использовать "миссионный" (лучше я буду называть его миссионерским) обработчик событий "Draw3D". Команда addMissionEvenHandler["Draw3D",{}] будет вызывать код каждый фрейм. И вот этим способом вы можете создать более, чем один цикл, и это ещё и будет работать. Как подсказывает имя команды, такой тип циклов предполагался скорее для отрисовки HUD-ов (намордных дисплеев), чем для чего-то ещё. Но поскольку это обработчик событий - он не допускает использования команд останова скриптов. [color=#808080;][Пример использоания этой команды вы увидите позже в уроке "ArmA Scripting Tutorials: boundingBox, boundingBoxReal, composeText, formatText, visiblePosition, visiblePositionASL", - да, в этом названии ни одного слова по-русски, только запятые. Ожидайте перевода][/color]

Двигаемся дальше всё ближе к FSM. [Пора, пожалуй, объяснить что такое FSM - это автомат состояний, дословно "машина конечных состояний" - finite state machine]. Условия, которые связаны с текущим состоянием FSM проверяются каждый фрейм. Кроме того, вам доступна секция предварительных условий, и если вы туда поместите какой-нибудь код, то он всегда будет выполняться до самой проверки условий. Таким образом, этот код будет исполняться каждый фрейм. Если вам необходимо несколько таких циклов, вы можете создать дополнительные условия и связать их с тем же состоянием автомата. У автомата есть один офигительный плюс - у него приоритет повыше, чем у других скриптов. Ну и традиционно, он не любит остановы скриптов.

И, наконец, нежданчик в виде... waitUntil. По умолчанию, эта команда будет исполнять свой код каждый фрейм, пока код не вернёт значение "true". Вы можете заspawn'ить, несколько циклов waitUntil, если вам надо. Чтобы выйти из этого цикла, вам нужно сделать так, чтобы самое последнее выражение в коде waitUntil возвращало "true".

_null = [] spawn {
	_time = diag_tickTime + 1;
	_i = 0;
	waitUntil {
		_i = _i + 1;
		diag_tickTime >= _time
	};
	hint format [
		"Code executed %1 times per second",
		_i
	];
};
//взгляните, сколько раз в секунду будет выполняться ваш код 

Если этого недостаточно, вы можете добавить останов скрипта к этой конструкции, в случае, если вам хочется ещё сильнее замедлить цикл, но всё-таки оставить скорость цикла сравнимой с фреймрейтом. А ещё я откопал интересную аномалию, пока проделывал этот трюк. Значение sleep >0.0005 заставляет waitUntil терять фрейм каждый раз, что тем более особенно, если учесть, насколько это малая задержка.

_null = [] spawn {
	_time = diag_tickTime +1;
	_i = 0;	waitUntil {
		sleep 0.00051;
		_i = _i + 1;
		diag_tickTime >= _time
	};
	hint format [
		"Code executer %1 times per second",
		_i
	];
};//сравните, сколько раз в секунду исполняется этот код. 

Я подозреваю, что эта штука делает что-то с планировщиком движка, что также привело меня к заключению, что использование цикла waitUntil требует меньшей вычислительной мощности процессора, чем цикл while с задержкой, созданной командой sleep. Поскольку waitUntil проверяется во время отрисовки кадра, то после того, как проверка произошла, она не будет запланирована на проверку до тех пор, пока не нужно будет отрисовывать следующий кадр. Проверка же условия команды while может, напротив, быть проверена множество раз за время отрисовки кадра.

Ведите себя хорошо

Бывает так, что вам нужно, чтобы определённый кусок кода был выполнен на всех компьютерах, вне зависимости от причины. Как создатель миссии или мода, вы отвечаете за всё, что позволительно и непозволительно в вашем творении. Одна вещь, которую вам, наверняка, не захочется допустить - это передача кода по сети, и разрешение на выполнение этого кода на всех подключенных машинах. По большей части, потому что это любезное приглашение разного рода хаков и эксплойтов в ваш код. А ещё потому что передача отрезков кода по сети - отстой для пропускной способности канала. Чего вам следует хотеть - так это создавать кастомные функции для каждого клиента, блокировать их, и иметь возможность вызывать их с набором параметров из любого места - это намного лучше, чем пересылать голый код.

Создать функцию у каждого клиента - просто. Когда миссия загружается, загружается init.sqf, и каждая машина выполнит этот файл один раз, даже выделенный сервер. Поэтому, определение функции в init.sqf или в любом другом файле, который вызывается из init.sqf - ровно тот трюк, который сработает. Вызывать такую функцию откуда угодно - тоже просто, вам просто придётся использовать комбинацию из publicVariable и ответственного за переменную обработчика событий. И всё это, в итоге, сводится к созданию фреймворка обратных вызовов, т.е. основной функции, которая будет совершать вызовы на всех клиентах для нас.

Мы будем передавать название нашей кастомной функции в виде строки в нашу функцию обратного вызова. Эту строку нужно как-нибудь преобразовать в реальную переменную, содержащую код кастомной функции. Но что бы вы не делали - не используйте call compile format для этой цели. Ща покажу почему. Вот, в примере ниже мы сконструировали нашу плохую функцию, создающую фреймворк обратного вызова, и определили её на каждой пекарне.

our_badfunction = {
	private ["_fnc","_params"];
	_fnc = _this select 0;
	_params = _this select 1;
	call compile format ["%2 call fnc_%1", _fnc, _params];
}; 

Мы даже попытались сделать её безопасной, используя префикс, чтобы никакие другие функции не могли быть вызваны, кроме тех, которые начинаются на "fnc_". А теперь давайте определим кастомную функцию, которую мы хотим вызвать на каждой машине.

fnc_lolfunk = {
	private "_params";
	_params = _this select 0;
	hint str _params;
}; 

Чтобы заставить всю эту херобазу взлететь, нам нужен обработчик событий, который будет вызывать наш хреновенький фреймворк обратных вызовов, который, в свою очередь вызовет нашу кастомную функцию.

our_publicvariable = []; "our_publicvariable" addPublicVariableEventHandler {
	(_this select 1) call our_badfunction;
}; 

Теперь, чтобы обработчик событий "выстрелил", прежде всего нам нужно определить и транслировать нашу публичную переменную с другой машины.

our_publicvariable = ["lolfunc", ["LMAO!"]];
publicVariable "our_publicvariable"; 

И наконец, мы выполняем call compile format, и получаем вот такой вот результат:

call {["LMAO!"] call fnc_lolfunc}; 

Вроде бы похоже на то, что всё работает. Неплохо, до тех пор пока хакер не придёт и не будет транслировать его собственную публичную переменную, навроде этой:

our_publicvariable = ["lolfunc;...злонамеренный код...", ["LMAO!"]];
publicVariable "our_publicvariable";

И вот теперь после call compile format, мы уже получаем вот такой вот результат:

call {["LMAO!"] call fnc_lolfunc;...злонамеренный код...};

Это именно то, что я и хотел продемонстрировать, сначала наша хреновенькая функция выполнить намеренный вызов, а затем вся радостная и счастливая притащит злонамеренный код, инжектированный хакером. Поэтому, сначала - о главном, мы никогда не используем комбо call compile format, вместо этого мы используем пространства имён (namespace) [смотри вторую часть урока по переменным]

_params call missionNamespace getVariable [format ["%1", _fnc], fallback_function]; 

В эту конструкцию просто не получится  инжектировать код. Ну... на самом деле можно, конечно, но это не сработает, поскольку ничего не компилируется, поэтому и бесполезно. И, как сверху бантик, мы можем присобачить резервную функцию (fallback) которая будет выполнена в случае, если передаваемая функция - не существующая переменная, и эта резервная функция даст нам знать, что кто-то пытается сделать кое-что нечестное. Кроме того, мы создаём условия, когда мы гарантированно не можем вызвать нашу фреймворковскую функцию из самой этой функции, создавая бесконечный цикл. После всех этих умозаключений мы получаем:

KK_fnc_CB_ERROR = {
	diag_log (format [
		"CB_ERROR! Call to non-existent function '%1'(Passed params: %2)",
		_this select 0,
		_this	])
};
KK_fnc_CB = {
	private ["_fnc","_code"];
	_fnc = _this select 0;
	if (_fnc != "KK_fnc_CB") then {
		_code = missionNameSpace getVariable [
			format ["%1", _fnc],
			KK_fnc_CB_ERROR
		];
		if ((_this select 2) == "call") then {
			_this call _code;
		} else {
			null = _this spawn _code;
		}
	}
}; 

Как и раньше, нам нужна кастомная функция и обработчик событий.

fnc_lolfunc = {
	hint (_this select 1);
};
KK_pv_CB = []; "KK_pv_CB" addPublicVariableEventHandler {
	(_this select 1) call KK_fnc_CB;
}; 

И, чтобы транслировать это в сеть:

KK_pv_CB = ["fnc_lolfunc", "LMAO!", "spawn"];
publicVariable "KK_pv_CB"; 

Помните, однако, что обработчик событий публичных переменных не сработает на той машине, с которой вызвана publicVariable, поэтому, на том компьютере, с которого вы вызываете publicVariable, кастомную функцию придётся запускать напрямую.

После того, как всё оттестировано, отлажено и работает, как задумывалось, самое время заблокировать код, чтобы никто не мог переписать ваш фреймворк обратных вызовов. Для этого мы собираемся изспользовать функцию compileFinal (особенность Армочки Третьей на данный момент). Эта команда компилирует переданную строку в код и финализирует его. После этого невозможно изменить переменную, содержащую код. Мы можем конвертировать наши функции в строки вручную, либо же воспользоваться Конвертером кода в compileFinal, который сделал КК. Конечный результат будет выглядеть вот так:

KK_fnc_CB_ERROR = compileFinal "
    diag_log (format [
        ""CB_ERROR! Call to non-existent function '%1' (Passed params: %2)"",
        _this select 0,
        _this
    ])
";
KK_fnc_CB = compileFinal "
    private [""_fnc"",""_code""];
    _fnc = _this select 0;
    if (_fnc != ""KK_fnc_CB"") then {
        _code = missionNamespace getVariable [
            format [""%1"", _fnc],
            KK_fnc_CB_ERROR
        ];
        if ((_this select 2) == ""call"") then {
            _this call _code;
        } else {
            null = _this spawn _code;
        }
    }
"; 

И неплохо бы предотвратить нашу кастомную функцию от неавторизированной перезаписи.

fnc_lolfunc = compileFinal "
    hint (_this select 1);
"; 

Ждите продолжения и дополнения этой статьи!

Итак, справа мы имеем выбор инструментов, сверху — стандартное меню сохранения-загрузки. Нажав на кнопку ADVANCED INTEL, мы сможем заняться настройкой погоды, но пока нас это не интересует. Навигация по карте происходит с зажатой правой клавишей мыши, масштаб изменяется колесиком.

Действия нашей первой миссии развернутся на Северо-Восточной оконечности острова — вблизи бухты Камино (Kamino bay), квадрат 065-049. Как видим, в бухте стоит небольшая постройка, а от нее к Северу в сторону маяка ведет грунтовая дорога. Здесь мы и расположим наш отряд!

Конечно, можно выставить всех бойцов по одному и потом объединить в группу, но иногда проще поставить сразу целое отделение. Выберите правом меню Groups (Группы) или просто нажмите F2. Затем, кликните два раза на пустом месте там, где начинается дорога, и вы увидите интерфейс создания групп -
 

В появившемся окне выберем SIDE – OPFOR (Сторона — Красные), FACTION – Red (Фракция — Красные), CLASS – Infantry (Класс — пехота) и UNIT – Infantry squad (Подразделение — Стрелковое отделение). А затем, нажмем ОК. Суть понятна — мы выбрали среди заранее заготовленных групп стрелковое отделение иранцев и поставили его на карту. Сейчас у нас не выбран игрок, и редактор нам об этом напомнит.
 

Скажем ему «CLOSE» (Закрыть) и сделаем двойной клик по третьему справа бойцу, именуемому Grenadier (Стрелок с ГП) перед нами откроется меню редактирования отдельного юнита. В нем нас интересует, прежде всего, пункт CONTROL (Контроль) в панели слева. Он имеет три опции — None (нет, бойцом будет управлять AI), Player (Этим юнитом будет управлять игрок) и Playable («Играет» Этим юнитом игрок может управлять. Все слоты в сетевой игре представляют собой юнитов с параметром Playable, а в одиночной — игрок имеет возможность переключаться в таких юнитов через меню выбора). Еще одно важное поле, которое мы заполним — это поле NAME (Имя). Это не то имя, которое отображается в игре, а условное имя, по которому к этому юниту смогут обращаться триггеры и скрипты. Зададим нашему протагонисту имя aP.
 

После этого, откроем аналогичным образом командира нашей группы и зададим ему имя Com. И прежде, чем нажать ОК, давайте окинем взором меню редактирования юнита.

SIDE (Сторона) — тут все очевидно. Может представлять собой BLUFOR (синие), они же НАТО, REDFOR (Красные), в их роли Иран. Independence (Независимые) — благородные греки, отважно отсутствующие в альфа-версии, Civilian (Гражданские) и Ambient life (Животные). На этом, список играбельных сторон закончен, а дальше идут Game Logic (о них - в свое время) и Empty (Пусто). Последняя сторона позволяет ставить на карту пустую технику, боеприпасы и прочие объекты.

CLASS – это класс юнита. Пехотинцы, бронетехника, авиация и так далее собраны по разным классам, а UNIT (Юнит) — это, собственно, тип самого персонажа или машины.

SPECIAL (Особенности) — здесь можно выбрать, появится юнит на карте в строю (In Formation) или будет стоять свободно (None). Для воздушных юнитов можно выбрать Flying (В полете), и тогда они появятся прямо в воздухе. А если в группе есть грузовой транспорт — можно выбрать In Cargo (В грузовом отсеке), тогда боец появится прямо в машине.

Назначение поля CONTROL мы уже поняли — здесь мы выбираем, кто будет игроком, а VEHICLE LOCK (Доступ) нужен для техники — позволяет поставить ее на карту закрытой. RANK – это Звание юнита. Юнит с более высоким званием автоматически становится командиром группы. AZIMUTH и ELEVATION – это направление и высота, на которой юнит появится. Справа есть колесо азимута, а в главном меню редактора можно крутить объекты, зажимая Shift.

В правом меню мы видим знакомое поле NAME, а ниже его INITIALIZATION – это очень важное поле, в него пишутся скриптовые команды. Если нам надо поменять юниту оружие, задать какие-то параметры, а то — и просто установить здоровье в ноль, чтобы создать на карте заведомый труп — все это обычно пишется в ините. SKILL (Уровень) — это уровень интеллекта AI, чем выше — тем умнее. PROBABILITY OF PRESENCE (вероятность присутствия) по умолчанию выставлена на 100%, но если мы захотим внести в миссию элемент случайности — можно его уменьшить.

А теперь, закроем меню игрока и укажем нашему отряду путь!

Одиночным щелчком по любому члену отряда, сделаем его активным, а затем — в правом меню выберем Waypoints (Вейпоинты) или просто нажмем F4. К северу от места нашей высадки расположен маяк — туда и назначим первую точку, два раза щелкнув.
 

В появившемся окне мы можем гибко редактировать поведение группы в движении. Оставим все поля по умолчанию кроме поля FORMATION (Построение) — там выберем Column (compact), в колонне нашему отряду будет проще подниматься в горку. Ах, да! Не лишним будет также поставить скорость движения на полную (SPEED – Full), чтобы маневр был более решительным.

Поле ON ACT. (По активации) позволяет нам выполнить разные скриптовые команды, когда группа достигнет этой точки. Пусть в нашем случае командир отряда (которого мы назвали Com, помните?) доложит на базу о занятии позиции для атаки. Впишем в это поле com sideChat "Base, this is Viper-1. We have reached the lighthouse! Over."; Поскольку в Альфа-версии игры поддержки русского языка и кирилицы нет — мы не сможем написать ничего по-русски, поэтому, давайте пока условимся на простых английских фразах. В данном случае, все должно быть понятно. Com – это мы обращаемся к соответствующему юниту, SideChat – это команда, заставляющая юнита сказать в синий чат фразу в кавычках «База, это Гадюка-1. Мы достигли маяка! Прием.»

Ну что же, если хотите — можно закрыть окно вейпоинта, нажать PREVIEW (Предпросмотр) и убедиться, что группа иранцев побежала в горку плотным строем, а по прибытии на место командир об этом доложил.

Давайте прямо сейчас сохраним нашу миссию, нажав в верхней панели Save (Сохранить) или просто Ctrl+S, если вы еще этого не сделали. Зададим ей имя, скажем — dk_tutor.

Установим на базе первую группу противников. Для начала, войдем в меню Units (F1), кликнем дважды неподалеку от центра базы. Юнит будет иметь сторону BLUFOR (Синие), Class – Men, юнит — Riffleman (Light). Звание (Rank) установим в Sergeant, чтобы он автоматически стал командиром группы. Рядом с ним разместим еще двоих-троих аналогичных бойцов, но в звании рядового (Private). Если эти бойцы помещены достаточно близко от сержанта — они автоматически свяжутся с ним голубыми линиями. Этой группе мы поставим вейпоинт прямо рядом, практически под ноги. Но тип (SELECT TYPE) выберем не MOVE (Перемещение), а SENTRY (Защищать). Это «умный» вейпоинт — с ним группа будет не просто стоять в указанной точке, а станет атаковать любого противника, замеченного союзниками, даже если сама его еще не видела.
 

Вокруг базы мы пустим патрули! Создадим пару синих бойцов слева от базы и добавим им вейпоинт MOVE (Перемещение) с параметрами SPEED – Limited (Скорость — ограничено), BEHAVIOUR – Safe (Поведение — Безопасно). Примерно в трех сотнях метров. Еще два аналогичных вейпоинта создадим в другой точке патрулирования и в начальной точке, образовав, таким образом, треугольник. А потом, недалеко от самого первого вейпоинта добавим точку с типом CYCLE (Зациклить). Обратите внимание, как она автоматически свяжется с первым вейпоинтом, если расположена достаточно близко.
 

Таким образом, патруль будет ходить по трем точкам по кругу. Скопируйте патруль вместе со всеми вейпоинтами клавишей Ctrl+C и клавишей Ctrl+V разместите на противоположной стороне базы. Так у нас будет выглядеть оборона базы в конечном итоге.
 

Итак, задача на бой у нас сформулирована, теперь надо как-то определить его результаты, чтобы миссия могла закончиться или идти дальше. Поэтому, теперь мы познакомимся с триггерами!

Триггер — это обработчик игровых событий, который при наступлении определенного условия запускает какое-то действие. Чтобы установить, что база захвачена, нам надо, чтобы выполнились два условия -
 

[*]В зоне базы нет вражеских юнитов.
[/list]

[*]Территория базы занята своими войсками.
[/list]

Каждое из этих условий включит по одному триггеру, которые сделают истинными две соответствующих переменных. В третьем триггере мы будем ожидать, пока истинными станут обе переменные — тогда мы и определим, что база зачищена. Сложно? Нет, ни капли.

Создадим первый триггер (кнопка F3, меню Triggers) в центре атакуемого военного лагеря. Размеры зоны задаются параметрами Axis X и Axis Y – установим их по 150 метров. Имя триггера установим как BAZA_BLUE и для удобства введем то же самое в поле TEXT, чтобы легко опознавать его на карте. Условием активации данного триггера будет отсутствие в его зоне солдат Синих. Поэтому, в поле ACTIVATION (Активация) выберем сторону BLUFOR (Синие), а ниже выберем Not present (Отсутствуют). Теперь определим, что произойдет, когда он активируется — нам нужно, чтобы истинной стала одна из переменных, назовем ее BaseIsClear. В поле ON ACT. (По активации) так и напишем BaseIsClear=true;
 



Второй триггер сработает, когда в зону войдет кто-нибудь из Красных. Создадим триггер такого же размера, назовем его BAZA_RED, в поле ACTIVATION (Активация) выберем OPFOR (Красные) и на этот раз — Present. В поле ON ACT. напишем WeAreHere=true; Ну, то-есть, «мы здесь».
 



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

Разместим его где-нибудь рядом и назовем BAZA_CLEAR. Радиус ему можно поставить нулевой — реагировать он будет не на юнитов, а на условия, написанные в строке CONDITION. Туда вписываем BaseIsClear and WeAreHere . А в поле ON ACT. Напишем следующее Leader aP sideChat "Ok! Now we must defend this place."; То-есть «Ок! Теперь нам необходимо защищать это место.» Почему в этот раз мы пишем «Leader aP», а не просто Com? Элементарно, в бою первоначального командира по имени Comмогли убить, а выражение Leader aP находит текущего командира игрока, и кто бы ни был в данный момент лидером — именно он и скажет эту фразу.

Наверное, самое время запустить превью и посмотреть, все ли работает.

Теперь нам надо сделать, чтобы группа начала движение не сразу, а только тогда, когда база будет нами захвачена. Поставим стандартный вейпоинт движения (MOVE) со скоростью «Полная» (Speed – Full) «под ноги» новой группе. Тепь выберем в меню (F5) Syncronization (Синхронизация), щелкнем на этом вейпоинте и протянем темно-синюю линию к недавно созданному триггеру BAZA_CLEAR.
 

Как уже, наверное, понятно — группа не двинется дальше этого вейпоинта, пока не сработает связанный с ним триггер. Вейпоинты полезно временно блокировать, и делать это можно не только с помощью триггера, можно синхронизировать вейпоинты нескольких групп друг с другом — например, чтобы они подходили на позиции с разных сторон, но атаковали одновременно.

Продолжим устанавливать маршрутные точки группе подкрепления! Следующий вейпоинт поставим непосредственно на машину, а тип его установим GET IN (Войти). Заметьте, что точка поставилась поверх машины, и если нам впоследствии понадобится «залезть под» путевую линию и открыть меню самого броневика — надо удерживать Shift.

Итак, когда триггер сработает — группа сядет в броневик. В дальнейшем, нам достаточно только указать точку высадки неподалеку от базы, а как туда добраться, боты решат самостоятельно. Поставим вейпоинт GET OUT (Выйти) на дороге неподалеку от базы, а следующую точку для подкрепления поставим уже на самой базе и зададим ей тип SEEK AND DESTROY (Найти и уничтожить), чтобы бойцы попытались атаковать нашу группу. Поведение на последней точке (Behaviour) логичным будет поставить «В бою» (Combat), так как по нашей задумке, подкрепление уже знает, что их ждет контакт с противником.
 

Кстати, в триггеры и вейпоинты мы можем добавлять эффекты, в частности — можно включить музыку в момент высадки подкрепления. Для этого, надо войти в соответствующий вейпоинт, нажать EFFECTS (Эффекты) внизу и выбрать трек. Кроме того, можно добавить кое-какого текста. Давайте сделаем это!
 

Окей! Теперь добавим условие, которое окончит миссию, когда подкрепление будет уничтожено, а контратака — отбита. Для этого мы поставим триггер, который сработает, когда число юнитов в группе подкрепления будет равно нулю.

Таким образом, когда количество юнитов группы Podkrep будет равно нулю — триггер сработает, и наступит финал миссии.

Ну что ж, мы задумали сюжет миссии, создали ее логику и последовательность событий, поставили обрабатывающие эти события триггеры и создали финальный триггер — который завершает миссию.

[*]Create Task (Создать задачу) – создает саму задачу. Ей нужно задать название, внутриигровое имя и описание.
[/list]

[*]Set Task Destination (Установить точку назначения) – будучи синхронизирован с предыдущим, отмечает задачу на карте в месте своего нахождения (опция Module position). Либо его можно синхронизировать еще и с объектом — тогда на карте задача будет помечена там (опция Synchronized object).
[/list]

[*]Set Task State (Установить статус задачи) – устанавливает изначальный статус задания. По умолчанию, все имеющиеся задания имеют статус Created (создано), и в начале миссии имеет смысл сделать активным одно из них. Перечень статусов таков - Created (создано), Assigned (Назначено, задача отмечена галочкой), Succeeded (Выполнено успешно, отмечается зеленой галочкой), Failed (Провалено), Canceled (Отменено).
[/list]

Поместим на карту модуль Create Task рядом со стартовой точкой, и заполним его так. Task ID (ID задачи) — Zadacha1, это имя задачи, которое мы будем обрабатывать командами. Title (Название) - Reach the lighthouse («Достигнуть маяка»), Description – Take position («Занять позицию» - это краткое описание). Apply to – Synchronized object only (Применить к — только к синхронизированному объекту). Заполнив поля таким образом, синхронизируем этот модуль с игроком. Рядом поставим модуль Set Task State (Установить статус задачи) и синхронизируем его кнопкой F5 с предыдущим модулем. State (Статус) выберем Assigned (Назначено), поскольку это первое задание, и оно должно быть активно с самого начала. Дадим ему имя (NAME) – ASSIGNED, чтобы было наглядно.

Рядом поставим такой же модуль, но со статусом Succeeded (Выполнено успешно) и так же свяжем его с модулем первой задачи. «Вторым концом» мы в последствии свяжем этот модуль с триггером, который будет отслеживать, что игрок забрался на маяк. Этому модулю тоже желательно дать имя, чтобы его было видно на карте.
 



Как мы помним, о том, что отряд забрался на гору, нам сигнализирует команда в вейпоинте группы. К сожалению, синхронизировать модуль Succeeded с вейпоинтом нельзя, поэтому, создадим небольшой триггер диаметром 20 и с условием активации на присутствие Красных, а затем, свяжем его с нашим модулем.
 



Должно быть понятно — по умолчанию у нас включится статус Assigned, а статус Succeeded связан с триггером и включится только тогда, когда и он.

Вторая задача у нас состоит в том, чтобы зачистить базу от противника. Создадим еще один модуль Create Task, дадим ему имя и Task ID – Zadacha2. А в задании так и напишем — Attack base and kill em all. Эту задачу мы так же соединим с игроком и создадим для нее три модуля Set Task State (Установить статус задачи), синхронизировав их все, как и в прошлый раз, с основным.
 


[*]Первый модуль будет задавать статус Created (Создано), ведь активной в начале миссии должна быть только первая задача.
[/list]

[*]Второй модуль будет задавать статус Assigned (Назначено), и привязан он будет к триггеру на маяке — ведь когда группа дойдет до точки, первое задание отметится выполненным, а второе нужно сделать текущим.
[/list]

[*]Третий модуль со статусом Succeeded (Выполнено успешно) свяжем с триггером BAZA_CLEAR. Помните, это тот, который включается при полностью зачищенной базе и запускает подкрепление?
[/list]



Наконец, третье задание — отразить контратаку.

Создаем третий модуль Create Task, дадим ему имя и Task ID – Zadacha3. В названии и описании задачи так и напишем - Defend base, то-есть, «защитить базу». К нему так же три статуса.
 


[*]Created (Создано)
[/list]

[*]Assigned (Назначено) – синхронизируем на триггер BAZA_CLEAR, ведь третье задание становится активным тогда, когда выполняется второе.
[/list]

[*]Succeeded (Выполнено успешно) — на триггер END1.
[/list]



Само собой, надо еще разок пробежать всю миссию и посмотреть, все ли срабатывает. Должно быть следующее.
 



Начало миссии — активна первая задача, остальные неактивны.
 



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



База захвачена, готовимся к обороне.

На этом, можно сказать, что наша первая миссия практически готова — теперь не только мы сами знаем, что в ней надо делать, а любой, кто способен прочитать пару строчек немудреного текста в нашем брифинге.

Как говорилось выше, briefing.html оставим пустым, а, вот, overview.html будет иметь следующее содержание.

<html>
<head>
<title>Overview</title>
</head>
<body bgcolor="#FFFFFF">
<p align="center"><img src="my_first_preview.jpg" width="460" height="230"></p>
<p align="center">
<br><font size="14">My first ArmA 3 mission!</font><br>
</p>
</body>
</html>

Здесь мы видим ссылку на картинку my_first_preview.jpg, именно это изображение будет в меню. Взять его можно прямо здесь и положить в папку с миссией, назвав соответствующим образом. Либо можно использовать свое jpg или paa изображение размером 460х230.
 

Теперь вернемся к редактору. Пока наша миссия никак не называется, и будет отображаться в меню и на карте просто как название папки. Это надо исправить! Для этого зайдем в ADVANCED INTEL («Разведка», «сведения») и заполним поле NAME (Имя) — так и напишем «My first ArmA 3 mission!». Далее, чтобы миссия отобразилась в главном меню игры, надо нажать в панели сверху Save As (Сохранить как) и вместо User mission (Пользовательская миссия) выбрать Export to single missions (Экспортировать в одиночные миссии) — в этом случае, наше задание сохранится как файл .pbo в папке Arma 3 Alpha/missions.

Сохраниться-то она там — сохранится. А самого меню одиночных миссий в Альфа-версии почему-то нет. Поэтому, пока будем довольствоваться запуском в редакторе, а чтобы перед миссией отображался созданный нами брифинг — кликать мышью по кнопке PREVIEW будем с зажатой клавишей Shift.

поле наберите “services.msc” (без кавычек). 

Появится список всех ваших служб, их текущее состояние (работает та или иная служба, либо 

нет) и параметры их запуска (запускается автоматически, вручную, полностью выключена и т.д.).

Гуглите сразу что-то типа «чистка ненужных служб windows» или “очистка windows от лишних 

процессов” и т.п. В этом случае, вы быстро найдете список всех тех служб, которые обычно не 

нужны 99% пользователей и сможете их полностью отключить, чтобы они не отнимали зря  

бесценные ресурсы вашего компьютера. Далее, вы можете просто вбивать название сомнительной 

службы в поисковик и получать подробное описание, принимая соответствующее решение об её 

удалении/не удалении.

Но будьте крайне осторожны! Если вы не уверены в том, что знаете, за что отвечает определенная 

служба, то лучше её вообще не трогайте! Иначе потом будет проблематично определить, отсутствие 

какого именно процесса,  привело к нестабильной работе Windows и/или различных приложений.

“Процессы“). 

Посмотрите, какие процессы находятся сейчас в вашей системе, посмотрите, какие из 

них жрут больше всего вашей памяти и CPU. Действительно ли они нужны вам? Нужны ли вам 

автоапдейтеры различных установленных программ, постоянно висящие на фоне, готовые в любой 

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

будет удобнее.

В общем, опять же, пользуйтесь поисковиком. Вбивайте имя процесса в поисковик, читайте его 

описание, деинсталлируйте программы, которыми уже давно не пользуетесь, но они все еще 

“садятся” в память (или ищите соответствующую службу в “services.msc“ и запрещайте автоматический 

запуск).

Короче, наша задача состоит в том, чтобы в фоновых процессах оставались только реально нужные 

службы для работы системы и необходимых приложений!

win+r), в появившемся поле наберите “msconfig” (без кавычек) -> перейдите на вкладку “Автозагрузка”. 

Проверьте, какие программы стартуют вместе с запуском вашей Windows. Уберите галочки с тех 

программ, которые вы не хотите запускать при загрузке. Например, вам нужен скайп, который 

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

рабочего стола при необходимости?

хочу настоятельно порекомендовать вам скачать и установить две софтинки:

- “System Explorer” (бесплатная утилита, которая является альтернативой с более расширенными

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

управления процессами).

- “AusLogicsBoostSpeed” (незаменимый инструмент для чистки, исправления и ускорения вашего

компьютера).

Кстати, “AusLogicsBoostSpeed” мы еще обязательно рассмотрим далее, т.к. она пригодится нам

для следующих шагов.

* Одно дополнение. Есть ещё одна программа, на мой взгляд более функциональная нежели AusLogics BoostSpeed Premium, многие наверное из вас знают про неё:

AVG PC TuneUp

Спасибо за рекомендацию 

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

Windows и приложениям для других задач позже.

Ведь службы, которые нам никогда не будут нужны, мы с вами уже определили и полностью

отключили с помощью стандартных средств Windows. А GameBooster поможет определить и

временно отключить весь остальной шлак + у него там есть еще несколько полезных функций,

которые могут некоторым очень пригодится:

• Фпс оверлей в игре.
• Выгрузка памяти при нажатии на кнопку ускорения.
• Дефрагментация файлов игры.
• Возможность делать скриншоты и записывать видео в игре.

(хотя я тремя последними функциями никогда не пользовался, т.к. видео записываю сторонним

приложением, а с дефрагментацией и оптимизацией жесткого диска отлично справляется

“AusLogicsBoostSpeed”).

Ну а после того, как вы закрываете игру, “Razer GameBooster” восстанавливает систему обратно

(есть подозрение, что все же кривовато восстанавливает, поэтому, если что-либо будет глючить

после выхода из игры, просто перезагрузите систему).

В общем, в первую очередь, сделайте самое важное. Пройдитесь по основным вкладкам и

отметьте галочками те процессы, которые должны будут отключаться перед запуском игры. Это

нужно будет сделать только один раз. А затем, вы просто нажимаете кнопку ускорения и всё разом

отключается. 

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

Игру можно добавлять прямо  в GameBooster и он автоматически будет её ускорять при каждом

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

систему вручную.

Тем более что мы позже будем прописывать параметры запуска к ярлыку ARMA3 прямо в Steam. Однако вы,

вероятно, и сами прекрасно понимаете, что эти данные можно прописать и в сам ярлык, и в параметрах

запуска игры из GameBooster (насколько я помню). А если вы часто играете на внешних серверах, с

определенной сборкой аддонов, то ярлыков этих будет несколько, и тогда прописывать параметры нужно

прямо в ярлыки. Так что… делайте как вам удобнее. Главное, не запутайтесь потом с этими ярлыками.

становится мутным. И наоборот, при повышении – картинка становится более четкой, но жутко проседает

фпс. Оптимальный вариант – 100%.

- Текстуры (HDD/GPU). Значительно повышает качество прорисовки текстур объектов и при этом, почти

не влияет на фпс. Рекомендуется ставить на высокие или на ультра.

- Объекты (CPU/GPU). Отвечает за качество прорисовки объектов в зависимости от их расстояния до вас.

На качество графики опция влияет минимально, однако может негативно повлиять на фпс в тех местах,

где есть много деревьев и других сложных объектов. Рекомендую ставить на минимум, либо стандартно.

- Ландшафт (CPU/GPU). Влияет на детализацию ландшафта, наличие травы и т.д. в зависимости от

расстояния. Если поставить опцию на минимум, полностью исчезнет трава. Если поставить чуть выше,

вы все равно можете обнаружить вдали кусты и деревья, торчащие из воздуха (т.к. ландшафт будет

упрощен). В целом, на средненьких системах, рекомендуется выставлять данную опцию в положение

стандартно, либо высоко.

- Тень (GPU). Тут на данный момент есть 2 варианта. Либо вы отключаете тень полностью, либо ставьте

её на ультра. Я сразу отключил её полностью и не проверял её влияние на фпс (т.к. в мультиплеере тень

мне только мешает), но есть информация, что средние настройки тени просаживают в ARMA3 фпс еще

больше, чем максимальные её настройки. Поэтому, если стремитесь к максимальному реализму картинки,

смело ставьте тень сразу на максимум.

- Частицы (GPU). Взрывы, пыль, дым – всё это частицы. Выкрутив данную опцию на максимум, вы можете

обнаружить снижение фпс в те моменты, когда кто-то бросил перед вами дымовую шашку, перед вами горит

техника и т.п. В целом, рекомендуется выставлять качество частиц на нормальное или высокое, тк лучше

видны фонтанчики от пуль и фпс сильно не проседает (спасибо за подсказку, ddt). Последний момент

(видимость фонтанчиков от пуль), делает эту опцию (на ряду с тенью и облаками), в значительной степени

влияющей на игровой процесс.

-  Облака (GPU). Примерно та же ситуация, что и с тенями. Если хотите максимального реализма,

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

минимальные настройки, т.к. за облаками можно не увидеть авиацию.

- PIP (GPU). Данная опция влияет на качество отображения в зеркалах заднего вида и т.п. Даже если вы

стремитесь к максимальному реализму, достаточно поставить положение этой настройки в низкое.

Нужный эффект вполне создается. А если вас беспокоит фпс, когда находитесь в транспорте, попробуйте

эту опцию полностью отключить. Вместо зеркал, будет что-то несуразное, но фпс немного повысится.

- HDR (GPU). Если я не ошибаюсь, эта опция отвечает за степень реалистичности освещения (или что-то

в этом роде). Как всегда, придется выбирать между реалистичностью картинки и фпс. Лично я поставил на

минимум и меня всё устраивает. А вы решайте сами, исходя из ваших предпочтений и железа.

- Динамический свет (GPU). Оптимальный вариант – стандартное или высокое.

- Режим вывода, разрешение и формат экрана. Если вы готовы пойти на радикальные меры для

сохранения максимального качества картинки, сохранив при этом вменяемый фпс – попробуйте снизить

разрешение и играйте в оконном режиме. Лично я был готов пойти на такие жертвы. При базовом

разрешении монитора 1920x1080, я выставил разрешение игры в 1600x900. Получилась дополнительная

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

получить при полноэкранном режиме. Всё нормально видно, т.к. разрешение снижено совсем не на много.

- Вертикальная синхронизация. Отключаем.

- Размер интерфейса, яркость, гамма. Не влияют на фпс.

- Подсвечивание, круговое размытие, размытие при поворотах, резкость. Выставляйте на свой вкус.

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

- SSAO (GPU). Опция, значительно влияющая на фпс и реалистичность изображения. Если с включенной

опцией сильно проседает ФПС, попробуйте включить вместо неё HDAO (method for ambient occlusion

computation). Эта опция появилась с недавним патчем (подсказал ddt). Если и с HDAO проседает ФПС,

можно отключить полностью.

- Каустика (GPU). Отключив эту опцию, можно улучшить ФПС под водой (подкорректировал ddt). В целом,

рекомендуется не выключать. Особой разницы в ФПС все равно не заметите.

- FSAA (GPU). Опция, достаточно сильно влияющая на фпс. Однако если сглаживание полностью отключить,

картинка становится корявой. При сглаживании 2x все становится гораздо приятнее на глаз, но все еще

напрягают провода в игре (лесенками) и некоторые другие объекты. Однако сглаживание 8x создает

значительную нагрузку на железо. По этой причине, рекомендую выбрать между сглаживанием 2x и 4x.

Тем не менее, если вас не устраивает даже сглаживание 4x, вы можете попробовать выставить

сэмплирование на 200% и сглаживание 2x. Читал где-то, что на некоторых системах это создаст

меньшую нагрузку на железо, чем при сглаживании только на 8x и при этом, обеспечит примерно такой

же визуальный эффект. В общем, экспериментируйте.

Примечание: если позволяет железо, конечно, желательно включать сглаживание 8x. Это не только

делает картинку намного более красивой, но (как прокомментировал ddt) позволяет лучше видеть цели.

- ATOC (GPU). Либо полностью отключите, либо включите ”Трава”. (спасибо за совет, ddt). Путем подбора

выявлено, что при таком варианте фпс просаживается меньше.

- PPAA (GPU). Для слабых систем рекомендуется полностью отключать. Либо включайте режим SMAA на

"очень высокое". Если отключить обычное сглаживание полностью и включить только SMAA, вы получите

схожий эффект, но производительность при этом должна быть получше.

Примечание: FXAA "очень высокое" качество, делает картинку более четкой, что может иметь значение

для игрового процесса. Причем, некоторые игроки (спасибо за подсказки, ddt и Avi), заметили, что FXAA 

на их железе меньше просаживает FPS, чем SMAA. Настройку "Ультра" включать не рекомендуется, т.к.

это может вызывать баги в ARMA 3. В общем, тестируйте.

- Анизотропная фильтрация (GPU). На данный момент, практически не влияет на фпс в ARMA 3. Можно смело

выкручивать на максимум.

- Текстуры: Очень высокое.

- Объекты: Низкое.

- Ландшафт: Стандартное.

- Тень: Отключено.

- Частицы: Среднее.

-  Облака: Низкое.

- PIP: Низкое.

- HDR: Низкое.

- Динамический свет: Стандартное.

- Вертикальная синхронизация: Отключена.

- SSAO/HDAO: Отключено.

- Каустика: Отключена.

- Сглаживание: 2x.

- AToC : Все деревья.

- PPAA: SMAA Очень высокое.

- Анизотропная фильтрация: Ультра.

можете попробовать вообще не включать файл подкачки. Но этот способ не проверен и

многие крайне не рекомендуют отключать подкачку.

Во всяком случае у меня, с 6 гб оперативки, игра намертво висла без файла подкачки.

Но вы попробуйте, винда от этого не слетит, и вы всегда сможете поставить файл подкачки

обратно. Зато, если сработает, то игра будет идти гораздо шустрее, благодаря меньшему

взаимодействию с жестким диском.

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

процессе (даже с 16 гб оперативки), значит нужно его все же включить. Для этого:

Правый клик по ”Мой компьютер” -> “Свойства” -> “Дополнительные параметры

системы” -> Вкладка “Дополнительно” -> раздел “Быстродействие” -> кнопка

«Параметры» -> вкладка “Дополнительно”. В разделе ”Виртуальная память”

нажимаем кнопку ”Изменить”.

Если ваш жесткий диск поделен на разделы, файл подкачки желательно делать на первом

из них (т.е. на диске С). Чтение с него будет осуществляться быстрее всего. И еще важный

момент! Рекомендуют не ставить файл подкачки на тот раздел, где у вас установлена игра.

Т.е. если у вас ARMA стоит на диске C, то лучше сделайте файл подкачки на другом разделе.

Ну и еще один момент. Если у вас и обычный HDD и SDD имеется в одной системе, то и

Арму, и файл подкачки нужно держать именно на SDD, т.к. скорость чтения намного выше

(а значит игра, да и вся система, будут работать гораздо быстрее).

Итак, выбираем диск, на котором хотим сделать файл подкачки, ставим галочку напротив

”Размер по выбору системы”, нажимаем кнопку “Задать”. А в самом верху окна, ставим

галочку напротив «Автоматически выбирать объем файла подкачки”. Пусть винда сама

решает, сколько вам надо виртуальной памяти. Хотя, можете, конечно, поэкспериментировать.

Хотя обладателям SSD и быстрых HDD, наверное, особо нет смысла этим

заниматься. Можете оставить память как есть. У вас и так все будет работать

довольно быстро.

Насколько я помню, этот способ рекомендовали сами BISы на своем форуме.

Дело в том, что во время игры постоянно происходит обращение к папке вашего игрового

профиля ARMA. А папка эта, расположена на жестком диске. Файлики там все небольшие,

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

Мы сделаем так, что весь профиль, будет постоянно находиться в оперативке, а не на

жестком диске. Уже одно это ускорит работу игры.

- Итак, создаем с помощью указанной выше программы свой RAM диск на 300-500 мб (а

лучше выделите 1 гб, т.к. неясно, насколько этот профиль со временем может разрастись...).

В крайнем случае, всегда можно будет поместить на такой диск какое-либо portable

приложение или кэш браузера.

- В настройках RAM диска обязательно укажите, чтобы он сохранялся на жесткий диск

при каждом выходе из системы.

- После этого, в вашей системе появится еще один раздел (например, диск Z) и выглядеть

он будет как обычный раздел жесткого диска. Вы сможете просто копировать туда любые

файлы.

- Перезагрузите компьютер.

- Далее заходим в Стим -> Библиотека -> Все игры -> Правая клавиша мыши на Arma 3 ->

Свойства -> Установить параметры запуска.

В появившемся поле пишем -profiles=Z:\

Где Z - это буква вашего RAM диска.

Нажимаем OK.

Всё, теперь ваш профиль будет постоянно находится в ОЗУ и обращение к нему будет

очень быстрым.

Только, еще раз повторю, обязательно в настройках своего RAM диска укажите, чтобы

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

восстанавливался. В противном случае, RAM диск будет постоянно стираться при выходе

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

заново.

случае, просто нет смысла).

Если у вас игра и файл подкачки расположены на SSD (или очень быстром HDD), то данный

метод также поможет вам получить прирост производительности, но не настолько

заметно, как для владельцев обычных HDD. Поэтому, как уже было сказано выше, советую

не тратить на это время и драгоценную оперативку.

И, кстати, недавно я даже на своем медленном HDD отказался от этого способа, т.к.

разницы при переносе файлов обратно на винт, я больше не ощущаю (видимо последний

патч исправил взаимодействие игры с файлом подкачки или что-то в этом роде).

Но вы, конечно, можете попробовать. Если испытываете проблемы с фпс в крупных

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

помочь.

По проведенным мной тестам, ARMA 3 тратит огромное кол-во времени на “пережевывание”

файлов из папки “Addons” на жестком диске. Именно это и является причиной жутких

тормозов во время быстрых поездок через крупные города (такие как Кавала), фризов

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

по себе лагучий, то на выходе получается просто неиграбельная ARMA 3.

Итак, мы заставим движок игры брать наиболее громоздкие объекты, текстуры, звуки и т.д.

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

этого оперативки.

Для начала, определите, сколько оперативки вы готовы отдать Арме. При этом, нужно

оставить свободными хотя бы 4 гб для Windows и других приложений. В противном случае,

винда по каждому поводу будет активно использовать файл подкачки (в т.ч. и в игре), а это

значит, что всё будет работать очень медленно.

Приведу пример на своей системе. Как я уже говорил, у меня сейчас 6 гб ОЗУ. Первоначально,

я решил выделить Арме 4 гб из своих 6. В результате вся свободная оперативка забивалась

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

запустил игру, все те данные, которые я не добавил напрямую в ОЗУ, полностью работали на

файле подкачки, что снизило фпс до минимума, а жесткий диск пахал за троих. В результате,

игра вылетала через некоторое время.

Тогда я решил оставить свободными 4 гб, а на RAM диск отдать только 2 гб. Запихнул в RAM

профиль и самые проблемные файлы из папки Addons и все стало летать пошустрее.

Какие файлы перекидывать на RAM диск.

Тесты я проводил, используя бесплатную программу "Process Monitor". Вы можете и сами

скачать её и проверить, какие файлы игры имеют наибольшее время чтения. Просто запустите

программу, затем запустите игру и поиграйте часик в какой-либо мультиплеер режим.

Программа за это время соберет статистику, с которой уже можно будет работать. Описание

работы с программой выходит за рамки данного руководства, так что... я думаю вы и сами

найдете информацию, как с ней работать.

По проведенным тестам, самыми медленными файлами из папки "Addons" стали:

- map_altis.pbo

- structures_f.pbo

- structures_f_households.pbo

- structures_f_data.pbo

- sounds_f.pbo

- anims_f_data.pbo

- weapons_f.pbo

- structures_f_ind.pbo

- plants_f.pbo

- characters_f.pbo

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

поместить на RAM диск.

Как заставить игру читать свои файлы с RAM диска.

- Для начала, определитесь - сколько у вас места на RAM диске, выберите файлы из

папки "Addons", которые вы хотите перенести и просто переместите их (F6) из папки

с игрой в корневую директорию RAM диска.

На всякий случай, сделайте резервную копию этих файлов где-нибудь "в сторонке",

чтобы не потерять игровые данные в случае чего...

ОБРАТИТЕ ВНИМАНИЕ, что эти файлы нужно убрать из директории "Addons" игры.

В противном случае, вы не сможете выполнить операции, указанные далее. 

Перенаправлять игру считывать необходимые нам файлы с RAM диска, мы будем,

используя символические ссылки. Для этого:

Предупреждение: хочу сразу сказать, что я в командной строке "не бум-бум",

поэтому, мое описание может показаться знающим людям смешным. Ну... пишу

как могу. Я делал так сам и это работает.

- Откройте меню ”выполнить” (win+r), а затем введите в поле "cmd" (без кавычек).

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

что не имеете прав доступа (и т.п.), открывайте командную строку от имени

администратора (Гугл в помощь).

- Откроется командная строка. В командной строке будет стоять адрес:

C:\Windows\system32> (если указан путь C:\Users\.....> значит вы запустили

командную строку не от админа).

В конец этой строчки добавляем букву диска, на котором установлена ARMA и

двоеточие.

У меня ARMA установлена на диск F. Поэтому, у меня это выглядело так:

C:\Windows\system32>f:

Далее нажимаем Enter и получаем на следующей строке

F:\>

Теперь вводим так:

chdir f:\Games\Steam\SteamApps\common\Arma 3\Addons\

Т.е. в командной строке, полностью это будет выглядеть так:

F:\>chdir f:\Games\Steam\SteamApps\common\Arma 3\Addons\

Обратите внимание, чтобы не писать всё вручную, можно вставлять в командную строку

скопированный ранее текст, нажав правую клавишу мыши на заголовке окна командной

строки -> "Изменить" -> "Вставить".

У меня, папка Steam находится в папке Games, поэтому я ввел соответствующий путь

в командной строке. Вы же вводите свой путь к папке с игрой, а точнее – к папке

”Addons” игры.

Теперь снова нажимаем Enter. На следующей строчке получится такой путь:

f:\Games\Steam\SteamApps\common\Arma 3\Addons>

Это значит, что начальной директорией сейчас является директория "Addons" игры

ARMA3, и мы можем начинать задавать связи файлам в этой папке.

Далее вводим следующее:

mklink имя_файла.pdo  Z:\имя_файла.pbo

Где:

имя_файла.pbo - это название файла, который вы решили запускать с RAM диска

(например, structures_f.pbo).

Z - это буква вашего RAM диска (т.е. у меня это Z, а у вас может быть и другая буква).

Вся строчка будет выглядеть так:

f:\Games\Steam\SteamApps\common\Arma 3\Addons>mklink имя_файла.pdo  Z:\имя_файла.pbo

Нажимаем Enter.

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

создана, а в директории с игрой появится одноименный файл (ярлык) весом 0 kb. Так нужно будет

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

Минус этого способа в том, что нужно будет переделывать эту операцию каждый раз, когда

очередное обновление затронет данные файлы. Вот, например, не так давно вышла вторая

часть кампании. Пришлось прописывать некоторые линки заново.

диске (спасибо за подсказку, Avi). 

Я, кстати, так сделал на 32 битной семерке (которая стоит у меня вместе с восьмеркой

на одном компе), задействовав невидимую память (это позволяет сделать программа

Primo RAMdisk, о которой говорилось выше).

Система стала работать быстрее (только длительность загрузки ОС несколько

увеличилось, в связи с резервированием RAM диска на HDD).

По идее, данный метод может быть полезен для ARMA, т.к. при наличии достаточного

объема ОЗУ, существенно сократит обращение к вашему HDD.

НО!

На этот счет мнения расходятся. Видел я в Интернете высказывания и ЗА данный метод,

видел высказывания и ПРОТИВ (что, дескать, система начинает работать нестабильно).

Пробуйте! Всегда можно поменять настройки операционки. Винда от этого не слетит.

Как менять расположение файла подкачки, уже упоминалось в этом гайде выше (да вы

это и сами наверное прекрасно знаете).

Опять же, как пишет Avi, пользуйтесь примерно такими расчетами, чтобы определить

требуемый объем оперативки:

• 1,5-2 Гбайта - Windows, тимспик, браузер (при разумном кол-ве открытых вкладок).
• 2 - Гбайта - ARMA 3.
• Ну и ещё пару ГБ про запас.
• И 4-6 Гигов под файл подкачки (максимальный размер мемори коммита армы 6 гигов).

Опять же стоит помнить, что каждый гигабайт ОЗУ намного дороже, чем тот же

гигабайт на ССД или ХДД.

Чтобы сделать их (функции обратного вызова) ещё безопаснее, можно использовать "белые листы", состоящие из функций, которые разрешено вызывать с помощью обратного вызова. Для этого нужно лишь небольшое измененение:

KK_fnc_CB_WHITELIST = {
	_this in [
		"fnc_lolfunc",
		"function2",
		"function3"
	]
};
KK_fnc_CB_ERROR = {
	diag_log (format [
		"CB_ERROR! Вызов несуществующей функции '%1' (Переданные параметры: %2)",
		_this select 0,
		_this
	])
};
KK_fnc_CB = {
	private ["_fnc","_code"];
	_fnc = _this select 0;
	if (_fnc call KK_fnc_CB_WHITELIST) then {
		_code = missionNamespace getVariable [
			format ["%1", _fnc],
			KK_fnc_CB_ERROR
		];
		if ((_this select 2) == "call") then {
			_this call _code;
		} else {
			null = this spawn _code;
		}
	}
}; 

Несколько слов про compileFinal. Вы должны присваивать финальный код переменной. Это переменная содержит код, и эта переменная после финализируется, посредством этого, и содержащийся в ней код становится финализированным. Вы можете включить файл, содержащий несколько публичных функций, типа вот этого:

//хреновый пример
call compileFinal preprocessFileLineNumbers "myfile.sqf";

Или даже типа вот этого:

//ещё один хреновый пример
functions = compileFinal preprocessFileLineNumbers "myfile.sqf";
call functions; 

Никакая из публичных функций не будет финализирована. Вам придётся делать это непосредственно, полностью описывая процесс, вам придётся проделывать с каждой функцией индивидуально, либо помещая каждую из них в отдельный файл, а уже затем compileFinal preprocessFileLineNumbers'ить каждый файл.

//хороший пример
function1 = compileFinal preprocessFileLineNumbers "myfunction1.sqf"
function2 = compileFinal preprocessFileLineNumbers "myfunction2.sqf" 

Вместо этого, как было указано выше, можете сконвертировать функции в строки, а затем... compileFinal

Ведите себя хорошо

В Армочке (несравненной) есть презабавнейшая команда attachTo. Она позволяет прикрепить почти что угодно к чему угодно, но самый цимес (צִימעֶס) заключается в том, что все прикреплённые части перемещаются вместе. Чтобы продемонстрировать принцип КК прикрепил немножечко взрывчатки C4 к гражданскому.

Команда attachTo работает со следующими аргументами:

_objToAttach attachTo [_objAttachto, [_xOffset,_yOffset,_zOffset], _memoryPoint];

comment "Приведу переводы переменных, чтобы было лучше понятно, что к чему:_objToAttach - прикрепляемый объект_objAttachto - объект, к которому прикрепят прикрепляемый объект_xOffset,_yOffset,_zOffset - смещение по осям X, Y и Z, соответственно_memoryPoint - именованная точка привязки."; 

Если вы не укажете точку привязки (_memoryPoint - в приведённом выше примере), объект будет присобачен к дефолтному центру объекта, если вы указываете правильную точку привязки, то объект прикрепится к этой точке модели объекта. Массив смещений используется для тонкой подстройки местоположения прикрепляемого объекта. Смещение берётся относительно точки привязки. На картинке ниже показано, с помощью гаечных ключей, какие могут быть точки привязки у объекта, и видно, что их не особо и много.

Для примера с C4 КК использовал именованную точку привязки "Pelvis" с небольшой последующей тонкой подстройкой месторасположения C4. Чтобы найти точки привязки любого объекта, откройте его модешь в Oxygen 2 и выберите Memory LOD, тогда Oxygen выласт список точек привязки, которые можно использовать с командой attachTo (по каким-то причинам не все выдаваемые точки работают, но большинство - работает). В модели-примере в Армочке Третьей есть следующие точки привязки, которые можно найти в Memory LOD:

aiming_axis, aimPoint, BubblesDir, BubblesEffect, camera, footstepL, footstepR, granat, granat2, Head, head_axis, lankle, launcher, leaning_axis, LeftFoot, LeftForeArm, LeftForeArmRoll, LeftHand, LeftHandMiddle1, LeftShoulder, lelbow, lelbow_axis, lfemur, lknee, lknee_axis, lwrist, Neck, Pelvis, pilot, rankle, rearm, rearm2, relbow, relbow_axis, rfemur, RightFoot, RightForeArm, RightForeArmRoll, RightHand, RightHandMiddle1, RightShoulder, rknee, rknee_axis, rwrist, Spine3, water_surface, Weapon

Присобачивание объекта к объекту помещает объект в его дефолтной ориентации (направление по-умолчанию), и это может быть совсем не то, чего вы желаете. В примере с C4, ориентация взрывпакетов по-умолчанию - горизонтальная, с "мордой" направленной вверх, и выравнена по оси Х. КК же хотел, чтобы вона была выравнена по-вертикали, и "смотрела" наружу. В таких случаях нам нужна команда setVectorDirAndUp. Тут нужно отметить, что тех же результатов можно достичь, вызывая по-очереди две команды: setVectorDir и setVectorUp, но лучше всё-таки использовать комбинированную версию команды, причины я позже назову. Итак, чтобы лучше понять, как же работает вся эта векторная мутотень, КК сделал иллюстрированное краткое руководство из одной картинки:

Команде setVectorDirAndUp нужны две векторных массива (в математике это называется вектор-строка) - один для VectorDir, и один для VectorUp. Ориентация объекта по-умолчанию всегда направляет VectorDir на "север" вдоль оси Y, а VectorUp направлен вдоль оси Z, как показано на рисунке. Когда вы присобачиваете объект к объекту, оси устанавливаются относительно объекта, к которому присобачивают. Если это, например, объект player, то ось Х идёт слева-направо, а ось Y - сзади-вперёд, Z - сверху-вниз. Чтобы, например, повернуть наш кирпич (BRICK) так, чтобы ось Z шла слева направо, нам надо поменять лишь VectorDir, а VectorUp - оставить без изменений.

//поворачиваем по оси Z на 90 градусов по часовой стрелке
BRICK setVectorDirAndUp [[1,0,0],[0,0,1]];
//поворачиваем по оси Y на 90 градусов по часовой стрелке
BRICK setVectorDirAndUp [[0,1,0],[1,0,0]];
//Наклоняем вперёд на 90 градусов (поворачиваем по оси X)
BRICK setVectorDirAndUp [[0,0,-1],[0,1,0]]; 

Обратите внимание, что в этих примерах нам приходится одновременно менять оба вектора - и VectorDir, и VectorUp. Если вы ошибётесь на этом этапе, и создадите конфликтующую (саму с собой) команду, что невозможно, объект примет ориентацию по-умолчанию. вот почему лучше использовать комбинированную команду поворота векторов, а не две отдельных. Вот ориентация посложнее:

//наклоняем вперёд на 90 + вращаем влево на 90
BRICK setVectorDirAndUp [[1,0,0],[0,1,0]];
//Отклоняем назад на 45 градусов
BRICK setVectorDirAndUp [[0,0.5,0.5],[0,-0.5,0.5]]; 

Как видите, вы можете вращать объекты на любой градус, просто меняя соотношение осей; 0,5-на-0,5 даст поворот на 45 градусов, чтобы повернуть на 30, вам надо установить соотношение 0,33-к-0,66.

//наклон вперёд на 30 градусов
BRICK setVectorDirAndUp [[0,0.66,-0.33],[0,0.33,0.66]]; 

Сложим же 2 и 2, и присобачим 3 заряда C4 к игроку, правильно их направим... Код должен быть похож на вот это:

_expl1 = "DemoCharge_Remote_Ammo" createVehicle (position player);
_expl1 attachTo [player, [-0.1,0.1,0.15],"Pelvis"];
_expl1 setVectorDirAndUp [[0.5,0.5,0],[-0.5,0.5,0]];
_expl2 = "DemoCharge_Remote_Ammo" createVehicle (position player);
_expl2 attachTo [player, [0,0.15,0.15],"Pelvis"];
_expl2 setVectorDirAndUp [[1,0,0],[0,1,0]];
_expl3 = "DemoCharge_Remote_Ammo" createVehicle (position player);
_expl3 attachTo [player, [0.1,0.1,0.15],"Pelvis"];
_expl3 setVectorDirAndUp [[0.5,-0.5,0],[0.5,0.5,0]]; 

Ну вот и всё. Можете посмотреть в ютюбах примеры использования команд attachTo и setVectorDirAndUp, например, на канале КК.  А, да, чтобы отсоединить объект, используйте команду detach.

Как выяснилось, нельзя использовать команду setDir, ни до, ни после использования команды setVectorDirAndUp, потому что такой трюк отменяет действие команды. Да и зачем бы вам это? Одной setVectorDirAndUp должно быть достаточно для задания любой ориентации объекта в пространстве.

И я тут подумал, держите видеопримеров:

Ведите себя хорошо

В Армочке Третьей уже более 1400 команд. Из них 1200 или что-то около того - это команды из Армочки второй, новые же команды частенько плохо документированы. Поэтому, КК решил, что будет описывать свои находки в таких командах, для будущего документирования этих команд. И этот урок будет про distanceSqr, linearConversion, difficulty, setAmmo и drawIcon3D.

distanceSqr

Как вы должны помнить из школьной математики, чтобы найти расстояние между двумя точками в декартовой системе координат, вам нужно воспользоваться следующей формулой:

distance = sqrt ((x₂ - x₁)² + (y₂ - y₁)² + (z₂ - z₁)²)

Именно это делает обычная команда distance. А в команде distanceSqr отсутствует операция извлечения квадратного корня, поэтому, она бесполезна, если вам нужно знать точную дисстанцию, но она весьма полезна, когда вам нужно сравнить две дисстанции:

distanceSquared = (x₂ - x₁)² + (y₂ - y₁)² + (z₂ - z₁)²

Поскольку в ней на одну математическую операцию меньше, чем в distance, то работает команда distanceSqr быстрее (кстати, одно лишь извлечение корня забирает гораздо больше вычислительной мощи, нежели оставшаяся часть команды), и должна бы оказаться полезной для оптимизации скриптов. Но, как ни странно, эксперименты КК показали, что разница ничтожна, но всё же есть. Использование:

distanceSquared=ObjectOrPositionOrLocation distanceSqr ObjectOrPositionOrLocation;

//ObjectOrPositionOrLocation - это переводится как Объект или Позиция, или Месторасположение

linearConversion

Эта команда позволяет определить два диапазона, а затем взять значение из одного диапазона, и подобрать пропорциональное значение в другом диапазоне. Сложно? Давайте попробую объяснить на примере. У вас в ящике 390 яблок. Вы взяли из неё 20 яблок, и вам надо узнать, как это соотносится, в процентах, к общему числу яблок. Вы можете сделать это обычным путём:

_percentage = 20 * 100 / 390; 

или же можете воспользоваться командой linearConversion:

_percentage = linearConversion [0,390,20,0,100,false];

Результат будет один и тот же: 5,12821. Эта команда может оказаться полезной для разного рода преобразований, включая изменение размеров, но она несколько медленнее, чем пара-тройка математических команд, делающих то же самое. Исопользование:

R2Value = linearConversion[R1Start, R1End, R1Value, R2Start, R2End, allowClipping];

где:

• R2Value (число) - искомое значение;
• R1Start (число) - начало первого диапазона;
• R1End (число) - конец первого диапазона;
• R1Value (число) - значение в первом диапазоне (кстати, может быть за границами этого диапазона);
• R2Start (число) - начало второго диапазона;
• R2End (число) - начало второго диапазона;
• allowClipping (bool) - если true, выходное значение всегда в границах диапазона;
• 
  

Вы можете задать R1Value за границами первого диапазона, и это, естественно, приведёт к тому, что и R2Value окажется за пределами второго диапазона. Если параметр allowClipping установлен в значение true, то результат, который должен бы оказаться за пределами диапазона, окажется "обрезан" по границам диапазона:

linearConversion [0,390,-3,0,100,false]; //-0.769231
linearConversion [0,390,-3,0,100,true]; //0
linearConversion [0,390,400,0,100,false]; //102.564
linearConversion [0,390,400,0,100,true]; //100 

difficulty

эта команда просто возвращает индекс выбранной сложности, основываясь на CfgDifficulties. По-умолчанию, в игре 4 класса сложности: Recruit, Regular, Veteran и Mercenary (displayName "Elite"). КК добавил ещё одну и назвал её Insane.

Когда КК выбирает "Insane", команда difficulty возвращает 4. Если "Regular" - то 0.

Использование:

difficultyIndex = difficulty;

setAmmo

Эта команда установит нетипичное число снарядов/зарядов/патронов в заряженный магазин указанного оружия. Wiki-страничка на момент написания оригинала этой статьи безбожно врала (но уже вроде бы поправили). Использование:

unit setAmmo [TypeOfWeapon, ammoCountInWeaponMagazine];

Если вы попробуете установить большее количество патронов, чем вмещает магазин, то количество будет урезано до стандартной ёмкости магазина. Вот вам примеров:

//установить количество патронов в пистолете у игрока равным 10
player setAmmo [handgunWeapon player, 10];
//установить количество патронов в оружии игрока - 1 патрон
player setAmmo [currentWeapon player, 1];
//если игрок - стрелок в технике
// установить количество патронов в текущем оружии - 5 шт.
(vehicle player) setAmmo [currentWeapon (vehicle player), 5];

drawIcon3D

С помощью этой команды вы можете отобразить на экране изображение с текстом под этим изображением в трёхмерном пространстве. Очень полезно для навешивания тэгов (меток) на игроков и объекты. Но у этой команды есть хитрость - иконка, которая создаётся с помощью этой команды, существует доли секунды. Поэтому, если вы хотите видеть результат работы этой команды, вам нужно вызывать её, по меньшей мере, каждый кадр. Использование:

drawIcon3D [imgPath, color, pos3D, imgW, imgH, imgDir, text, effect, textSize, textFont];

где:

• imgPath (строка) - путь к изображению "pathimage.paa";
• color (массив) - цвет изображения и текста: [r, g, b, a] (красный, зелёный, синий, альфа-канал)
• pos3D (массив) - расположение иконки в трёхмерном пространстве: [x, y, z];
• imgW (число) - ширина изображения, по отрошению к иконке: 1 - совпадает с иконкой;
• imgH (число) - высота изображения, по отрошению к иконке: 1 - совпадает с иконкой;
• imgDir (число) - угол поворота изображения : 0..360, 0 = нет поворота;
• imgDir (строка) - Текст, который надо отобразить под изображением: "какой-то текст"
• effect (число) - эффект: 0 - простое отображение, 1 - добавить тень, 2 - добавить обводку;
• textSize (число) - размер текста, по отношению к размеру HUD : 0.03 - нормальный размер;
• textFont (строка) - гарнитура текста: "PuristaLight"

Например, чтобы отобразить синим цветом динамическое прозрачное изображение компаса над черепом головы игрока:

Воспользуйтесь вот таким кодом:

onEachFrame {
	private "_private"
	_playerPos = getPosATL player;
	drawIcon3D [
		"a3ui_fdataIGUICfgRfdarradar_ca.paa",
		[0,0,1,0.5],
		[_playerPos select 0, _playerPos select 1, 2.3],
		5,
		5,
		direction player,
		"COMPASS",
		0,
		0.03,
		"PuristaMedium"	];
};

Ведите себя хорошо

- Добавлены модули:

Случайная позиция - позволяет установить несколько позиций для появления синхронизированных с модулем объектов на одной из них (в том числе и бойцов). Перемещение происходит с сохранением относительных позиций между объектами. Основным (центральным) объектом будет являться лидер группы/старший по званию.

Эвакуация из зоны - завершение модуля по эвакуации указанного количества объектов/ящиков/игроков из зоны.

Носимые объекты (ящики/статичное вооружение), синхронизированные с модулем на время их нахождения в зоне не могут быть погружены в технику, ограничение снимается по выходу из зоны.

- ЛЦУ теперь корректно добавляется в инвентарь игроков.

КК подумал, а чего бы ему не добавить в уроки ещё парочку команд, которые оказались весьма полезны в его экспериментах.

boundingBox и boundingBoxReal

Во время экспериментов со второй Армой, я нашёл некоторые несоответствия между виртуальными размерами объекта и его (объекта) виртуальными габаритами - вымышленной коробкой, в которую полностью поместится объект, эта коробка, а правильно - габариты - и переводится как 'bounding box', предполагается, что габариты - это наибольшие размеры объекта в трёх измерениях. Поэтому, когда я увидел, что в Арме Третьей появилась новая команда габаритов, с припиской "Real" (Настоящий), я ожидал, что она окажется поточнее, и она правда оказалась точнее. Чтобы протестировать команду, я поставил в редакторе вертолёт КА-60, и результаты выполнения команд оказались различными:

• boundingBox Ka_60 : [[-8.09281,-9.60703,-2.9097],[8.09281,9.60703,2.9097]]
• boundingBoxReal Ka_60 :[[-6.74401,-8.00586,-2.42475],[6.74401,8.00586,2.42475]]

Обе команды возвращают вложенные архивы с крайними точками "коробки", в которую заключена модель в пространстве: [[X1,Y1,Z1],[X2,Y2,Z2]]. Похоже на то, что центральная точка у обеих габаритных коробок совпадает, но не всегда совпадает с центром по-умолчанию 3D-модели объекта. Поэтому, если, по каким-то причинам, вам нужно найти смещение, пользуйтесь командой boundingCenter. Проверка этой команды на нашем Ка-60 возвращает:[-0.0013752,-0.750013,0.582208].

Итак, чем же именно может быть полезна команда boundingBoxReal? Ну, для начала вы можете с лёгкостью вычислить максимальные ширину, высоту и длину объекта, зная крайние координаты его габаритной коробки:

_bbr = boundingBoxReal Ka_60;
_p1 = _bbr select 0;
_p2 = _bbr select 1;
_maxWidth = abs ((_p2 select 0) - (_p1 select 0)); //13.488
_maxLength = abs ((_p2 select 1) - (_p1 select 1)); // 16.0117
_maxHeigth = abs ((_p2 select 2) - (_p1 select 2)); //4.8495 

composeText и formatText

Возможно вы уже знаете из урока "ArmA Scripting Tutorials: Переменные (Часть Номер Три)" о существовании переменных типа STRING (строка) и о переменных типа TEXT (можно я это переводить не буду?). Последняя относится к структурированному тексту, то есть STRING (строка) с разметкой, навроде HTML, в этих переменных есть возможность изменять цвет, размер текста, добавлять изображения, и т.д. Чтобы переделать номральный STRING в TEXT, мы используем команду parseText. Есть одна загвоздка: если вы можете добавлять строки друг к дружке старым способом: STRING1 + STRING2 + и т.д., то с TEXT'ом такой фокус не пройдёт. К счастью, БИСы дали две довольно полезных команды для этих целей: composeText и formatText.

composeText берёт массив TEXT'ов или STRING'ов и преобразует это всё в TEXT, друг за дружкой, вплотную.

hint composeText [
	"Top",
	lineBreak,
	parseText "<t color='#ff0000' align='left'>Red Left</t>",
	parseText "<br />",
	parseText "<t color='#00ff00' align='right'>Green Right</t>",
	lineBreak,
	"Bottom"
]; 

Команда formatText делает то же самое, за одним исключением - первый элемент массива - это STRINGовый шаблон, где можно установить порядок элементов массива, с помощью %1, %2, %3 и т.д., прямо как в простой команде format.

Но самое крутое в этих командах - это то, что вам не придётся беспокоиться о HTML-подобных символах в текстовых строках, портящих ваш структурированный текст. В уроке "ArmA Scripting Tutorials: Массивы (Часть Номер Три)" КК показывал, как сделать санобработку ников, содержащих символы "<" и ">". Человеки используют самые разные символы для своих ников, тэгов, и т.п. и эти команды делают жизнь намного проще. Сравните:

hint formatText ["%1HTMLTags%2","<<<",">>>"]; //<<<HTMLTags>>>
hint composeText ["<<<HTMLTags>>>"]; //<<<HTMLTags>>>
hint parseText format ["%1HTMLTags%2","<<<",">>>"]; //>>
hint parseText "<<<HTMLTags>>>"; //>> 

Единственно что - это если вам нужно окрасить в какой-то особый цвет ваш TEXT, содержащий знаки разметки HTML, вы можете сделать это, поменять цвет по-умолчанию для текста, в управлении внутри класса управления (control class). Есть ещё одна команда, стоящая упоминания - text. Эта команда просто переделывает STRING в TEXT.

visiblePosition и visiblePositionASL

Даже не сомневаюсь, что вы уже слышали о командах position, getPos, getPosATL, getPosASL и даже о getPosASLW, поскольку они широко используются Армакодерами. Но слышали ли о visiblePosition и visiblePositionASL? Даже не смотря на то, что есть уже собранные списки скриптовых команд Армы 2 и Армы 3 (например, см. урок "ArmA Scripting Tutorials: Список Cкриптовых Команд Arma 2 / Arma 3"), и эти команды были в таких списках всегда, я как-то проходил мимо них, и не замечал их. Вот что говорит вики по поводу visiblePosition:

Returns an object’s rendered 3D position (z value above ground level).

(Возвращает отрендеренное положение 3D-объекта (значение Z над уровнем земли).

Поэтому я естественно предполагал, что она показывает, какую часть цели видно. НИХЕРА! Команду следовало назвать visualPosition, чтобы не вводить людей в заблуждение. Обе команды возвращают простое месторасположение объекта [x,y,z], только позиция эта берётся с вашего экрана (вариант ASL, очевидно даёт вам z над уровнем моря - Above Sea Level). Что видите, то и получаете, в общем говоря. Даже если я отвернусь от объекта на экране, я могу получить его видимую позицию (visiblePosition). Также, я подозреваю, что команда visiblePosition даёт лишь локальный эффект. Вот как разработчик из БИСов с ником neokika объясняет само существование этих команд:

This is because of the interpolation changes in Arma 2.

Back then, new commands [visiblePosition and visiblePositionASL] have been added, please use them instead.

(Это из-за изменений в интерполяции, сделанных в Амре2

И в те времена, когда произошли эти изменения мы сделали новые команды [visiblePosition и visiblePositionASL] - их и используйте).

Ну и когда же вам могут понадобиться эти команды? Когда вам нужно знать, что же другой клиент видит на своём экране. Когда вы хотите "повесить" метку на игрока так, чтобы она двигалась с игроком безо всяких рывков. А вот что получается, когда вы пробуете использовать getPosATL, чтобы получить расположение игрока, даже не смотря на то, что тут всё локально и никаких сетевых элементов не используется:

а вот как оно выглядит, когда вы используете команду visiblePosition:

Вот вам пример кода, который используется во втором варианте видео, тут исопользуется ещё недокументированное БИСами событие "Draw3D" для команды обработчика событий addMissionEventHanler, спасибо товарищу Xeno с БИСовских форумов за то, что поделился этой информацией. Побольше о команде drawIcon3D вы можете узнать в уроке "ArmA Scripting Tutorials: distanceSqr, linearConversion, difficulty, setAmmo, drawIcon3d".

addMissionEventHandler ["Draw3D", {
    drawIcon3D [
        "\A3\ui_f\data\map\vehicleicons\iconManMedic_ca.paa",
        [0,0,1,1],
        [
            (visiblePosition Bob) select 0,
            (visiblePosition Bob) select 1, 
            3
        ],
        1,
        1,
        45,
        name Bob,
        1,
        0.03, 
        "PuristaLight"
    ];
}]; 

Ведите себя хорошо

А вот и документация на использование RegEx-расширения для армы, предствленного здесь (клац). Эта целевая аудитория этого урока - люди, уже знакомые с Регулярными Выражениями. Расширения используют встроенные в C++ функции по работе с RegEx, и эти функции получают Регулярные Выражения, которые вы передаёте, без каких-либо изменений, поэтому, если вы знаете, что вы делаете, то у вас не должно быть никаких проблем. Оба расширения вызываются командой callExtension, которая использует в качестве аргумента одну единственную строку, и этот аргумент передаётся в расширение.

_result="extension" callExtension "arguments";

Самой большой трудностью для КК было придумать способ как передать все аргументы в .dll одной строкой, заставить .dll понять как разобрать эту строку и при этом добиться универсальности. Например, если я испльзую ':' для разделения аргументов, как многие делают, это может вызвать определённые трудности, поскольку ':' уже имеет особое значение в RegEx.

Синтаксис

regex_match: <separator> <regex> <separator> <subject>

где:

• <separator> - разделитель. Один символ, уникальный (не встречающийся) в <regex>
• <regex> - правильное Регулярное Выражение
• <subject> - субъект. Часть, к которой будет применено Регулярное выражение <regex>

regex_replace: <separator> <regex> <separator> <replacement> <separator> <subject>

где:

• <separator> - разделитель. Один символ, уникальный (не встречающийся) как в <regex> так и в <replacement>
• <regex> - правильное Регулярное Выражение
• <replacement> - замена. Отформатированное заменяющее выражение
• <subject> - субъект. Часть, к которой будет применено Регулярное выражение <regex> и замена <replacement>

Разделителем может быть любой символ, если он не конфликтует с собранным вами RegEx'ом. Поскольку именно вы составляете RegEx, вы можете легко решить, какой разделитель использовать. Например, в большинстве случаев можно просто использовать традиционный '/':

_result = "regex_match" callExtension "/w+(?=s)/hello beautiful world";

Код выше читается как: найди совпадения всех слов, за которыми следует пробел (но без самого пробела) в hello beautiful world. RegEx вернёт: [hello, beautiful]. Но если вы попробуете распарсить http://killzonekid.com и включить символ '/' в RegEx, вам нужно будет использовать другой разделитель, поскольку '/' будет конфликтовать с RegEx. В этих случаях можно взять '|':

_result = "regex_replace" callExtension "|http://||http://killzonekid.com"; 

Это читается как: замени  в http://killzonekid.com на ничего. RegEx вернёт в качестве результата: killzonekid.com. Если у вас в RegEx имеется символ кавычек ", то вы можете заключить строку-аргумент в апострофы ' вместо кавычек, и ничего не будет конфликтовать. Можно и наоборот - заменять апострофы на кавычки.

_result = "regex_match" callExtension '|"tro.{5}"|["trololol","tro","lol"]'; 

Это читается как: найди все вхождения кавычек ", закоторыми следует tro, за которым следует ещё 5 каких-нибудь символов, после которых стоят кавычки " в ["trololol","tro","lol"]. RegEx вернёт: ["trololol"].

Возвращаемый результат

Хотя в C++ есть команда regex_match, и сначала КК использовал именно её для простого поиска совпадений, позже он начал использовать команду regex_search и переделал её под нужды Армы, и оставил мод с названием regex_match.

regex_match

• возвращает [совпадение1,совпадение2,совпадение3...] - если совпадения найдены
• возвращает [], если совпадений не найдено.

Поэтому, если вам нужно просто узнать, были совпадения или же не было, вы можете просто проверить является ли результат "[]" или же нет. Если же вам нужно получить доступ к совпадениям, вы можете call compile'нуть результат. Только убедитесь, что результат - это правильный массив, если вы проделываете этот трюк. [tree,bush,tower] - неправильный массив (если только tree, bush и tower - не являются существующими переменными), ["tree","bush","tower"] - правильный массив.

regex_replace

• возвращает субъект, изменённый согласно правилам замены, если совпадение найдено
• возвращает оригинальный субъект, если совпадений не найдено

Безопасность

Команда callExtension принимает в качестве аргумента строку (STRING) и возвращает в качестве результата - тоже строку (STRING). Если вы не идёте дальше, чем обработка сток, вы можете использовать эти моды и на клиентах, и на сервере. Но, как только вы решите call compile'ить то, что вам возвращает .dll, вы должны понимать, что нет никаких способов помешать тому, что кто-то заменит вашу .dll своей собственной, и вы не можете уже доверять возвращаемым результатам от клиентских .dll (компилирование таких результатов из чужих .dll даст хакерам полный доступ к вашей миссии). Проще говоря, ограничьте подобное использование этих модов, пока БИСы не разработают решение проблемы.

Примеры

КК просто показывает несколько практических примеров, показывающих, почему RegEx очень нужны в Арме Третьей. Допустим, у вас по всей карте разбросаны маркеры спавна, а вам нужно выбрать только маркеры респавна синих: respawn_west. Да без проблем! Переделайте массив allMapMarkers в строку и ищите совпадения, выбирая лишь маркеры, чьи имена начинаются на 'respawn_west':

/* allMapMarkers 
[
    "respawn_west_1",
    "respawn_west_2",
    "respawn_west_3",
    "respawn_east_1",
    "respawn_guerrila_1",
    "respawn_civilian_1"
]
*/
_result = call compile (
    "regex_match" callExtension format [
        '/"respawn_west.*?"/%1',
        allMapMarkers
    ]
);
//Result: ["respawn_west_1","respawn_west_2","respawn_west_3"] 

КК ответственно заявляет, что этот метод в тысячу сотен миллионов раз быстрее и эффективнее, чем тот метод, который используется в арме сейчас. Допустим, у вас есть массив чисел, и вам нужно выбрать наибольшее число в этом массиве. Да не проблема! Переделайте массив в строку, замените все запятые командой max, так, что выражение выглядит как-то так: [5 max 17 max 3 max 66...max 77], call compile это, и получите значение, представляющее собой массив из одного элемента:

_array = [5,17,3,66,22,110,41,80,100,29,77];
_result = (call compile (
    "regex_replace" callExtension format [
        "/,/ max /%1",
        _array
    ]
)) select 0;
//Result: 110 

И снова обалденно быстро и эффективно. Как видите, использование RegEx может существенно ускорить и оптимизировать ваши SQF. И, как было упомянуто ранее, оба мода используют встроенную в C++ библиотеку regex, поэтому, теоретически они легко могут быть добавлены в Арму Третью на уровне движка, и могут быть предоставлены пользователям как обычные скриптовые команды. Ну что же, давайте посмотрим, как пойдёт дальнейшая разработка Армы третьей.

Кстати, на сайте оригинала этой статьи есть эмулятор работы поиска и замены с помощью регулярных выражений. Можете глянуть

Адрес ссылки, где можно за это голосовать: http://feedback.arma3.com/view.php?id=14494 (продублировано в соответствующей теме на форуме - тут)

Начнём с того, что эта функция не является частью Армы Третьей, она специально придумана, хотя КК собирается попытаться убедить БИСов включить что-нибудь подобное в стандартную библиотеку функций. Почему она нужна? Потому что compileFinal требует строкового аргумента, а когда вы кодите, вы пишете код. И когда вы наконец захотите финализировать свой код, вам придётся конвертировать его в строку, чтобы использовать compileFinal. КК уже седлал конвертер кода в компайлфайнал, с которым можно ознакомиться тут: (клац), чтобы упростить задачу, но теперь есть метод получше и поудобнее. О нём, собственно, этот пост.

Как бы то ни было, идея вот в чём: конвертировать код в строку на лету, передавая имя переменной, содержащей ваш код, в функцию, которая осуществляет конвертирование и компиляцию. Давайте в этот раз просто запостим весь код вместо того, чтобы объяснять, как он работает, а разбор будет вашим "домашним заданием".

BIS_fnc_compileFinal = { 
       /*
        Author: Killzone_Kid

        Description:
        Recompiles existing code to final

        Parameter(s):
        _this select 0: STRING 
            - name of the variable containing code
            - variables containing no code are ignored

        _this select 1: NAMESPACE (Optional)
            - namespace of the variable containing code
            - if no namespace provided missionNamespace is assumed
            
        Returns: BOOL
            - true on success 
            - false on failure

        Example 1:
            myCode = {
                hint "This is my code!"
            };
            //recompile myCode to final
            ["myCode"] call BIS_fnc_compileFinal;
        
        Example 2:
            with uiNamespace do {
                myCode2 = {
                    hint "This is my code too!"
                }
            };
            //recompile myCode2 to final and alert on success
            if (["myCode2",uiNamespace] call BIS_fnc_compileFinal) then {
                hint "Success!"
            };
    */
    
    private ["_var","_ns","_code","_arr"];
    _var = [_this,0,"",[""]] call BIS_fnc_param;
    _ns = [_this,1,missionNamespace,[missionNamespace]] call BIS_fnc_param;
    _code = _ns getVariable [_var, 0];
    if (typeName _code != typeName {}) exitWith {false};
    _arr = toArray str _code;
    _arr set [0,32];
    _arr set [count _arr - 1,32];
    _code = compileFinal toString _arr;
    _ns setVariable [_var, _code];
    true
}; 

КК протестировал этот код, и у него всё работает нормально (я - Avi ещё не тестировал, поэтому, буду рад комментариям)

Ведите себя хорошо

КК подумал, а чё бы ему не поделиться функцией, которую он написал, когда помогал делать мод ДеньГ (DayZ). Оригинальная БИСовская функция, которую использовал Рокет была просто колоссально неоптимизирована, а в моде использовалась очень интенсивно. У нас было несколько вариантов, как её улучшить, и вариант КК оказался самым быстрым. И КК думает, что эта функция и сегодня используется в ДеньГ.

Но как бы то ни было, вместо тупого копипастинга, в этом уроке будет представлена улучшенная версия, в которой даже встроенные БИСовские функции используются как у Про! 

Вот, держите:

KK_fnc_inString = {
    /*
    Author: Killzone_Kid
    
    Description:
    Find a string within a string (case insensitive)
    
    Parameter(s):
    _this select 0: <string> string to be found
    _this select 1: <string> string to search in
    
    Returns:
    Boolean (true when string is found)
    
    How to use:
    _found = ["needle", "Needle in Haystack"] call KK_fnc_inString;
    */

    private ["_needle","_haystack","_needleLen","_hay","_found"];
    _needle = [_this, 0, "", [""]] call BIS_fnc_param;
    _haystack = toArray ([_this, 1, "", [""]] call BIS_fnc_param);
    _needleLen = count toArray _needle;
    _hay = +_haystack;
    _hay resize _needleLen;
    _found = false;
    for "_i" from _needleLen to count _haystack do {
        if (toString _hay == _needle) exitWith {_found = true};
        _hay set [_needleLen, _haystack select _i];
        _hay set [0, "x"];
        _hay = _hay - ["x"]
    };
    _found
}; 

Возможно вам интересно, как же ведёт себя эта функция по сравнению с официальной БИСовской функцией - BIS_fnc_inString, чьё предназначение абсолютно такое же? КК думает, что в А3 функция уже улучшена, и может быть работает получше, чем в А2. (Хотя, я проверил - ничего не поменялось)

КК сделал некоторые тесты, в который иголка (needle) была в самом конце стога сена (haystack), но в самом стоге находилось куча похожих совпадений.

Функция КК примерно вчетверо быстрее, чем БИСовская. По коду понятно, что скорость функции зависит от длины стога за вычетом длины иголки. Поэтому, производительность функции довольно предсказуема и надёжна.

Но вот что хочется сказать. Всё это детские игрушки, по сравнению с тем, что делают нормальные парни, когда им нужно выполнить строковый поиск. Вот результат использования мода RegEx:

Да, детка! в 76 раз быстрее, чем функция КК, и в 290 раз быстрее БИСовской. Это вам не в чешки срать!

Ведите себя хорошо

Сегодняшний урок будет о небольшом трюке. Трюк этот о том, как найти месторасположение исходных медиа файлов (картинок, звуков) для миссий, благодаря чему вы сможете получить к ним доступ прямо из миссии. Позвольте объяснить, о чём это я.

По-умолчанию, миссия упакована в .pbo-файл, котоый потом загружается кем угодно, кто подключается к серверу. Чтобы получить прямой доступ к содержимому .pbo, типа звуков или изображений, которые вы поместили в миссию, вам нужно знать путь, который Арма поймёт.

В большинстве случаев Арме хватает относительных путей к файлам, навроде: "soundsmysound.wss", что означает корневая папка -> папка sounds -> файл mysound. Но вот некоторые команды, такие как drawIcon3D или playSound3d не поймут относительный путь от папки миссии, хотя эти команды прекрасно работают, когда ваши медиа-исходники лежат в АддОне.

Ну и как найти прямой путь к медиа-исходникам? Всё очень просто - спросить у препроцессора: препроцессор знает . В препроцессоре есть макрос __FILE__ - этот макрос заменяется абсолютным путём к файлу, включая  само имя файла. Поэтому. если вы включите его в файл init.sqf, результат будет чем-то вроде этого:

mpmissions__CUR_MP.Stratisinit.sqf 

Обратите внимание, что путь к миссии содержит в себе название карты. Конечно, мы можем вручную редактировать путь, в зависимости от карты, но нафига бы нам все эти уроки, если мы не сможем автоматизировать эту простую задачу? Во чё мы сделаем... Поместим путь в init.sqf, конвертируем в массив, избавимся от init.sqf, уменьшив массив на 8 элементов (угадайте зачем ), а потом конвертируем всё обратно в строку:

MISSION_ROOT = call {
    private "_arr";
    _arr = toArray __FILE__;
    _arr resize (count _arr - 8);
    toString _arr
}; 

Теперь, если мы запустим это из init.sqf, MISSON_ROOT будет содержать корневую папку нашей миссии

mpmissions__CUR_MP.Stratis 

и не только на клиентах, но и на сервере тоже, и эти упёртые команды теперь тоже заработают.

playSound3D [MISSION_ROOT + "sounds\mysound.wss", player];
drawIcon3D [MISSION_ROOT + "icons\myicon.paa", ...]; 

А для мультиплеера есть способ получше:

MISSION_ROOT = format ["mpmissions__CUR_MP.%1", worldName]; 

Правда, для синглплеера папка будет другой. А первый способ - универсален, и работает как для МП, так и для СП.

Обновление поста

Есть ещё один способ получения корневой папки миссии, в этот раз от Карела Морицки из БИСов. Этот метод использует файл description.ext, который просто обязан быть в папке вашей миссии. Используя str совместно с missionConfigFile как раз выдаст нужный нам путь к description.ext, и всё, что нам надо сделать - это убрать "description.ext" (15 символов) так же, как мы делали с init.sqf в примерах выше.

MISSION_ROOT = call {
    private "_arr";
    _arr = toArray str missionConfigFile;
    _arr resize (count _arr - 15);
    toString _arr
};

Похоже, что этот метод лучший из всех, представленных в этой статье, поскольку он универсальный, работает и в сингле, вы можете поместить код поиска корневой папки куда угодно, вам не нужно использовать препроцессор. Ну и, просто, чтобы напомнить, вам надо, чтобы description.ext был в вашей миссии.

Но и это ещё не всё, есть ещё один метод от угорающего по арме товарища Кунса. Конвертирование переменной, служащей держателем скрипта и возвращаемой execVMом в str показывает пусть к execVMленному скрипту:

_script = [] execVM "myScript.sqf";
hint str _script; //path to myScript.sqf
waitUntil {scriptDone _script};
hint str _script; //<NULL-script> 

Чтобы получить путь этим способом вам надо запустить программу "вытаскивания" пути перед тем, как execVMнутый скрипт будет завершён и переменная-держатель скрипта превратится в <NULL-script>. Но, тем не менее, это тоже работающий метод

Ведите себя хорошо

Область действия (scope) - это кода часть кода, заключённая между открывающейся { и закрывающейся фигурными скобками }, получаем, что область действия В случае отдельного скриптового файла, область действия начнётся с началом файла, а закончится - с его (файла) концом. Таким образом, приходим к тому, что область действия - это тот же блок из урока "ArmA: Скриптописание. Синтаксис SQF",- это так, чисто для справки. Области действия вполне могут находиться внутри других областей действия. Можно это представить себе как разделённое пространство, наподобие спальни или кухни внутри дома. Дом в этом случае выступает как основная область действия. Кухня внутри дома будет другой областью действия внутри основной области действия. Чтобы войти в кухню, вам сперва нужно войти в дом, а когда вы выходите из кухни, вы оказываетесь в доме, если, конечно вы не выходите из кухни через окно . В Армочке есть команды, которые делают именно это, и позже мы поговорим и о них.

Но сначала давайте научимся входить через двери. Область действия сама по себе {...какой-то код...} не обеспечит выполнения кода, хотя он и будет скомпилирован. Итак, чтобы ваш код исоплнялся, вам нужно как-то попасть в область действия. Самый простой путь - это команда call:

scopeName "outside"; // снаружи
call {
	scopeName "house"; // дом
	call {
		scopeName "kitchen"; // кухня
	};
	call {
		scopeName "bedroom"; // спальня
	};
}; 

Есть и другие Arma-команды, которые осуществляют вход в области действия. spawn {}; if () then {} else {}; while {} do {}; {} forEach, и т.д. Как вы видите, я использовал команду scopeName, чтобы определить каждую область действия. Выход из области действия происходит автоматически по достижении конца этой области действия. Но если вы хотите выйти из кухни через окно, т.е. выйти из области действия до того, как достигнете её конца, вам может  понадобиться команда scopeName вкупе с командами breakOut или breakTo.

Обе этих команды должны знать название области действия. Это либо название области действия, из которой вызывается команда (в случае breakOut), либо название какой-либо родительской области действия. Это важно. Указываемое вами название области действия не может быть названием дочерней либо никак не связанной области действия. Обе команды будут искать требуемое навзание, условно говоря, двигаясь назад и вверх.

Это означает, что если вы в "bedroom" (спальне), вы можете breakOut'нуть из спальни ("bedroom"), дома ("house") или с улицы ("outside"), или же можете "breakTo''шнуть в дом ("bedroom") или на улицу ("outside"). Вы не можете сослаться на какую либо из дочерних для "house" (дом) областей действия, таких как "kitchen" (кухня) или "bedroom" (спальня).

scopeName "outside";
call {
	scopeName "house";
	call {
		scopeName "kitchen";
		BreakTo "outside";
	};
	call {
		scopeName "bedroom";
	};
}; 

В скрипте выше мы выходим из кухни ("kitchen") через окно на улицу ("outside"), а в скрипте ниже мы "выбегаем" из кухни обратно в дом ("house"):

scopeName "outside";
call {
	scopeName "house";
	call {
		scopeName "kitchen";
		BreakOut "kitchen";
	};
	call {
		scopeName "bedroom";
	};
}; 

Есть и другая полезная команда для того, чтобы сваливать из областей действия, и эта команда не требует scopeName. Это конструкция if exitWith. Эта команда выходит из текущей области действия и только из неё - не верьте всему, что пишут в BIS wiki. Никакой мистики в работе этой команды нет, она делает ровно то, что вы напишете в аргументах.

scopeName "outside";
call {
	scopeName "house";
	call {
		scopeName "kitchen";
	};
	call {
		scopeName "bedroom";
		if true exitWith {};
	};
}; 

Код, представленный выше, выйдет из области "bedroom" и только из неё. Как в этом можно запутаться? Похоже, что вся путаница идёт от людей, которые пытаются по-дурацки завершить какие-то особенные циклы с помощью команд, предназначенных для выхода из областей действия.

Хотя это и сработает для обычных циклов, циклы, вызываемые каждый кадр, такие как onEachFrame или waitUntil, вполне закономерно не станут завершаться. Все три команды выйдут из области действия, как и должны, но код, указанный внутри таких особенных циклов, будет выполнен при отрисовке следующего кадра. Если вам нужно, чтобы эти циклы завершились, когда вы выходите из области действия, делайте так:

onEachFrame {
	if true exitWith { onEachFrame{} };
};
waitUntil {
	if true exitWith {true};
}; 

Также, при работе с областями действия, вам необходимо обращать внимание на то где и как вы определяете приватные переменные. Если вы их определите в "house", то они будут существовать и в "kitchen" и в "bedroom", но не в "outside". Об этом уже было рассказано в первой части урока по переменным: "ArmA Scripting Tutorials: Переменные (Часть Номер Раз)",- и вам нужно лишь вспомнить, что дочерние области действия могут включать в себя приватные переменные родительских областей, но не наоборот.

_parentVar = 123;
call {
	hint str isNil "_parentVar"; //false
	_childVar = 456;
};
if true then {
	hint str isNil "_parentVar"; //false
	_childVar = 456;
};
_null = [] spawn {
	hint str isNil "_parentVar"; //true
	_childVar = 456;
};
hint str isNil "_childVar"; //true

Ну а теперь самое время найти хорошее применение нашим вновь приобретённым знаниям. Помните команду switch do? Это неплохая команда, если вам нужна изящность кода, в отличие монструозных структур if then, только вот она слегка медленновата, что странно - в других языках программирования switch'и - молниеносны. Как бы то ни было:

private "_num2str";
_num = 0;
switch _num do {
	case 0: {_num2str = "0"};
	case 1: {_num2str = "1"};
	case 2: {_num2str = "2"};
	default {_num2str = "N/A"};
}; 

А можно получить изящность switch'ей, не теряя скорости? А можно!

private "_num2str";
_num = 0;
call {
	if (_num == 0) exitWith {_num2str = "0"};
	if (_num == 1) exitWith {_num2str = "1"};
	if (_num == 2) exitWith {_num2str = "2"};
	_num2str = "N/A";
}; 

Вот этот (вышеприведённый) код обеспечит вам нечувствительное к регистру сравнение строк, в то время как switch - регистрочувствителен.

Ведите себя хорошо.