80 replies to this topic

[Avi]

Мальчики и девочки, дамы и господа, сэры и сэрихи, ЗДРАВСТВУЙТЕ.

 

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

Поэтому, по совету товарищей я решил... нет, не купить автомобиль "Москвич", я решил выкладывать уроки по скриптописанию и созданию миссий в Арме. Писать сюда я буду только тот материал, который интересен мне и который мне не стыдно выложить. Но это же форум - любой ваш вклад приветствуется. Глядишь, совместными усилиями наберём материал, и сделаем методичку. А если совместных усилий не будет, то будут хотя бы несколько хороших статей.

 

Сегодня я представляю вам материал от

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

 

Перед началом работы рекомендую посетить вот эти две ссылочки:

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

Введение

 

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

 

Алгоритм

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

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

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

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

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

 

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

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

 

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

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

 

Исходный код

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

 

Синтаксис

Синтаксис - это набор команд и параметров, причём, иногда хватает лишь одной лишь команды, как в случае команды  - 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 (?) значений. Первое значение - это строка представляющая собой текст, который будет выведен на экран, а второе значение, в данном случае, говорит в каком месте экрана текст будет показан (см. руководство к команде 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

). Также, данная команда допускает третье значение в массиве - число, которое укажет, как долго текст будет появляться на экране , если значение не введено, будет использоваться значение по умолчанию (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: Начинаем",- поскольку там представлен более удобный и быстрый способ знакомства со скриптами. Но эта статья тоже должна быть полезна - тут первое упоминание того, как же добавлять скрипты в миссии.

 

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

 

 

ArmA Scripting Tutorials: Начинаем.

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

Ещё во времена альфы, а конкретнее, во время версии 0.54 была добавлена такая штука...

Added: improved public debug console

Добавлено: отладочная консоль для широкого круга пользователей

 

И она сильно упрощает тестирование и отладку скриптов. Добыть её можно, нажав в редакторе ESC во время предпросмотра (preview) миссии. Консоль позволяет осуществлять взаимодействие "на лету" с переменными и объектами в миссии.

На видео показано как создать и запустить простой скрипт, выводящий "hello world", как подсказку. Подсказки очень полезны, когда вы хотите быстро посмотреть значение переменной. Команда hint требует строкового аргумента, вот почему вам следует придерживаться нижепритведённого формата, при выведении на экран подсказок, и этот формат позволит вам выводить любые переменные, определённые, неопределенные, строковые, не строковые, нулевыи или вообще любые - hint format ["%1",вашаПеременная];

_somevariable = 123;
hint format ["%1", _somevariable];// показывает "123"
_somevariable = objNull;
hint format ["%1", _somevariable];//показывает "<NULL-object>"
_somevariable = compile "a = b";
hint format ["%1", _somevariable];//показывает "{a = b}"
_somevariable = call {};
hint format ["%1", _somevariable];//показывает "<null>"
_somevariable = nil;
hint format ["%1", _somevariable];//показывает "any" 

Подсказка висит на экране несколько секунд, потом плавно сходит на нет. Кроме того, любая последовательная команда hint[color=rgb(40,40,40);font-family:helvetica, arial, sans-serif;] [/color]затрёт подсказку, которая была до этого. Поэтому, если вы желаете вести лог нескольких выводов/значений переменных, вместо команды hint[color=rgb(40,40,40);font-family:helvetica, arial, sans-serif;] и[/color]спользуйте команду diag_log - diag_log forman ["%1" ,ваша переменная]; diag_log будет делать записи в .rpt-файл, каждый вызов diag_log создаст новую строку. Этот файл можно найти в C:Users[ИмяВасНенаглядного]AppDataLocalArma 3 Alphaarma3_[ШтампСамыхПоследнихВремениИДаты].rpt.

_somevariable = call {};
diag_log format ["%1", _somevariable];
_somevariable = nil;
diag_log format ["%1", _somevariable];
//Записи в .rpt файле
//"<null>"
//"any" 

Очень важно использовать format при вызовах как diag_log так и hint для отладочных целей, поскольку это позволяет вам видеть такие значения как any и <null>. <null> означает, что переменная имеет нулевое значение, поскольку call в нашем примере возвращает чуть меннее, чем ничего, в качестве результата. any означает, что переменная пока неопределена, и может иметь любое значение, поскольку мы сбросили её, присвоив ей значение nil. Также .rpt-файл позволяет узнать, были ли в скриптах какие-нибудь ошибки. Если в скрипте случается ошибка, он может быть отвергнут, так что убедитесь, что в ваших скриптах ошибочек нет. А сейчас немного веселья.

//заставим игрока плавать в воздухе
player playMove "AbswPercMrunSnonWnonDf";

//сделаем игрока невидимым
player hideObject true;

//Пущай человечек проходит сквозь твёрдые объекты
null = [] spawn {
	while {true} do {
		{
			player disableCollisionWith _x;
		} forEach ((position player) nearObjects 100);
		sleep 1;
	};
}; //в сортиры с этим чудным скриптом не пускает : ) 

Кстати, как уже показал в приведённом выше примере. если вы собираетесь использовать команду sleep со скриптом в отладочной консоли, то убидетесь, что не забыли инкапсулировать свой код в структуру навроде null=[]spawn{...ваш код...}; Это нужно делать, потому что скрипт в отладочной консоли вызывается командой call и вы не можете приостанавливать скрипт командами навроде sleep с call. Мы ещё вернёмся к этому вопросу в следующих уроках.

 

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

 

 

ArmA: Скриптописание. Синтаксис SQF

Автор: Community, с полным списком авторов можно ознакомиться здесь: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

Синтаксис SQF

 

Синтаксис SQF впервые был представлен в OFP:Resistance и является общим стандартным синтаксисом, начиная с Armed Assault. Альтернативой ему является синтаксис SQS (устаревший ещё во временя Armed Assault, поэтому, уроков по нему именно я переводить/добывать/делать не собираюсь).

 

Правила

 

Основные правила:

• Фигурные скобки {} группируют код в блок
• Выражения (кстати, тоже блоки) заканчиваются знаком точки с запятой ;

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

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

Блоки

 

Блок (Block) - это эдакий кода кусок, объединённый в одну группу. Блок начинается и заканчивается фигурными скобками: {кода кусок}. Блоки могут быть независимыми и вызываться командой call, или же принадлежать управляющей структуре.

 

Выражения

 

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

 

Виды выражений:

 

Выражения могут быть:

• присваиванием значения
• управляющей структурой
• скриптовой командой

 

Присваивание значения

Такое выражение просто присваивает значение переменной.

_variable = 15; 

Управляющая структура

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

if (_value > _limit) then {
	hint "oh no";
}; 

Команда

Любая скриптовая команда вместе с аргументами.

player sideChat "hello"; 

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

 

Пример:

STATEMENT 1;
STATEMENT 2;
BLOCK {
    STATEMENT 3;
    STATEMENT 4;
}; 

Если синтаксис SQS основан на строках, то синтаксис SQF основан на структурированных выражениях. Окончание строки не имеет никакого особого значения - он принимается эквивалентным пробелу или табуляции, и, таким образом, он не требуется, даже если и находится в конце выражения.

 

Комментарии

 

Комментарий - это любой текста кусок, который игнорируется игровым движком. В синтаксисе SQF вы можете написать комментарий с помощью команды comment.

comment "Это комментарий"; 

Если файл загружается одной из команд: preprocessFile, execVB или spawn то в нём могут быть Си-подобные комментарии (не работает с командой loadFile):

 

Строчный комментарий начинается с двух слэшей //, за которыми следует, собственно, комментарий.

Блочный комментарий начинается с /*, а заканчивается на */. Любой текст между ними считается комментарием.

// Это строчный комментарий
/*а это
ОЧНЕ длинный
блочный комментарий
*/ 

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

 

 

ArmA Scripting Tutorials: Основы.

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

Быть ; или не быть ; - вот в чём вопрос! Ответ прост - если вы в смятении, поставить ; лучше вам. Давайте объясню. Точка с запятой используется в SQF-скриптах, чтобы сказать движку (несравненной Армочки), где заканчивается одна команда, и где начинается другая. Если вы пропустите ; там, где оно требуется, скрипт остановится и в .rpt-файл будет записано сообщение об ошибке, которое и скажет вам ,что вы пропустили точку с запятой.

a = b;
c = d;
// всё чётко

a = b
c = d;
// нихрена не всё чётко. ошибка

a = {c = d;};
// ништяк

a = {c = d};
// и так ништяк.

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

while {true} do {hint "ok"; breakOut ""}
// Кашу маслом не испортить

while {true;} do {hint "ok"; breakOut "";};
// Машу пальцем тоже. В обоих случаях всё нормально и работать будет

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

a = {"ok"}; hint format ["%1", call a;];
//ошибк

аa = {"ok"}; hint format ["%1", call a];
//так гораздо лучше 

То же справедливо и для скобок (). Скобки используются для того, чтобы объяснить движку (несравненной Армочки) в каком порядке ему придётся обрабатывать выражение. Первыми выполняются те выражения, которые находятся в самой глубине иерархии, в самых внутренних скобках, затем родительские скобки, затем прародительские, и так далее (((1)2)3). Например, вам нужно выбрать массив внутри массива (ПРИМ: Используя выражение select, вы можете опустить скобки в некоторых простых случаях: _eight = _array select 3 select 4 select 0; работает просто прекрасно)

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

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

_array1 = _array select 3;
_array2 = _array1 select 4;
_eight = _array2 select 0; 

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

//НЕ НАДО ТАК ДЕЛАТЬ:
{diag_log format ["%1",_x]} forEach position player nearObjects 50;

//А ВОТ ТАК ПРАВИЛЬНО
{diag_log format ["%1",_x]} forEach ((position player) nearObjects 50);

Не смотря на то, что первое выражение не выдаст ошибки, результатом будут несколько рандомных чисел, но никак не то, чего хочется. А хочется получить список объектов на расстоянии не более 50 метров от игрока и второе выражение делает как раз это, да здравствуют скобки!

 

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

my_function = {
	a = 1;
	b = 2;
	c = a + b;
};
call my_function; //теперь c равняется трём 

[color=rgb(40,40,40);font-family:helvetica, arial, sans-serif;font-size:14px;]Функции могут и выдавать результаты и принимать аргументы. Чтобы переслать аргументы в функцию, используя команду [/color]call[color=rgb(40,40,40);font-family:helvetica, arial, sans-serif;font-size:14px;], поставьте перед ней переменную, содержащую аргументы.[/color]

// либо
my_function = {
	private ["_a","_b","_c"];
	_a = _this select 0;
	_b = _this select 1;
	_c = _a + _b;
	_c
};

// либо
my_function = {
	(_this select 0) + (_this select 1)
};
_result = [1,2] call my_function;
//_result = 3 

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

 

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

 

ArmA Scripting Tutorials: Список Cкриптовых Команд Arma 2 / Arma 3.

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

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

 

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

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

 

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

 

 

ArmA Scripting Tutorials: Как включить "ленивую" проверку условий.

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

Перевод свободный, поэтому, посещение 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

 лишь привествуется.

 

Стоит запомнить, что движок армы в своей повседневной работе слегка долбанутый - он очень любит создавать работу сам себе, и если вы не скажете ему остановиться и передохнуть, он будет продолжать и продолжать делать что-нибудь. Сегодня в фокусе нашего внимания - выражения с условными операторами, возвращающими нам значения 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 {}}}; Этот метод даёт выигрыш, если вещи идут в нужном вам порядке, и ухудшает производительность, если этот порядок нарушается, применение же БИСовской оптимизации не даёт почти никакого выигрыша, если вещи идут в нужном вам порядке, и ухудшает производительность, если этот порядок может быть нарушен.

 

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

КК

 

ArmA Scripting Tutorials: Переменные (Часть Номер Раз).

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

В несравненной Армочке есть 5 разных типов переменных: приватные, специальные приватные, публичные локальные, специальные публичные локальные и публичные глобальные. У каждого типа переменных своя область действия, и об этом надо знать и помнить.

 

Приватные переменные

 

Движок (несравненной Армочки) автоматически воспринимает любую переменную, чьё имя начинается с подчёркивания как приватную. Для имён переменных вы можете использовать стандартную алфавитно-цифровую нотацию: от A до Z, от a до z, от 0 до 9 и _ - все эти символы можно использовать для того, чтобы дать имя переменной. Таким образом, _hello, _HELLO_WORLD2000, _____hello, _123, ____123_______hello - все они имеют правильные, с точки зрения движка, имена и будут восприниматься как приватные. Приватные переменные создаются в тех местах, где они их определят, в рамках тех областей действия, в которых происходит это определение, и удаляются как только ход программы выходит за рамки их области действия. Таким образом, любая приватная переменная, определённая в какой-либо области действия, будет неопределена за рамками этой области.

//_i в этом месте ещё не определена и имеет значение nil
if true then { //начало области действия
    _i = 1; //определяем _i
    // в этом месте _i равна 1 и определена
}; // конец области действия
//_i имеет значение nil, поскольку мы за рамками области действия

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

_i = 1;
if true then {
    //в этом месте _i определена и равна 1
    if true then {
        //в этом месте _i определена и равна 1
        if true then {
            //в этом месте _i определена и равна 1
        };
    };
}; 

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

private "_a";
private "_b";
private "_c";
//это то же самое, что и
private ["_a","_b","_c"]; 

Использование команды private гарантирует, что если даже в родительской области действия уже определена переменная с таким же именем, то её (родительской переменной) значение не будет изменяться в дочерней области действия никоим образом и переменная, которую вы непосредственно объявили приватной будет неопределена в дочерней области действия, пока вы не определите её.

hint format ["%1", _i]; //"any"
_i = 1;
hint format ["%1", _i]; //"1"
if true then {
    hint format ["%1", _i]; //"1"
    private "_i";
    hint format ["%1", _i]; //"any"
    _i = 2;
    hint format ["%1", _i]; //"2"
};
hint format ["%1", _i]; //"1" 

Специальные приватные переменные

 

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

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

// описана только первая итерация
{
	{
		hint str _x; //_x = 1
	} forEach _x; //_x = [1,2,3]
} forEach [[1,2,3],[4,5,6],[7,8,9]]; 

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

// описана только первая итерация
{
	_x2 = _x;
	{
		hint str _x; // "1"
		hint str _x2; // [1,2,3]
	} forEach _x;
} forEach [[1,2,3],[4,5,6],[7,8,9]]; 

Больше мне нечего добавить о специальных приватных переменных, за исключением того, что не нужно создавать свои переменные с такими именами, которые используются для специальных приватных переменных. Также, в заключение этого урока, хочется сказать, что никогда не помешает проявить дополнительную осторожность и непосредственно объявить переменные в вашем скрипте, как приватные (за исключением случаев, когда у вас есть веские причины этого не делать), особенно если ваша функция вызывается командой call. Для этого есть неплохой инструмент вот в этой статье: (http://arma3.ru/foru...-oblegchaiusch/), называется этот инструмент "ArmA 2 / ArmA 3 Simple Private Variable Extractor".

_function = {
	_var = _var + 1;
};
_var = 10;
call _function;
hint str _var; // "11"
_var = 100; //определение _var где-то за пределами требуемой нам области действия
function = {
	private "_var";
	_var = _this select 0;
	_var = _var + 1;
	_var
};
hint str ([10] call function); //результат будет 11, а не 101 

На этом мы заканчиваем первую часть, смотрите, что изменится в части 2.

 

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

 

 

ArmA Scripting Tutorials: Переменные (Часть Номер Два).

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

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

 

Публичные локальные переменные

 

Чтобы дать имя публичной переменной вы можете использовать стандартый алфавитно-цифровой набор символов, как и в случае с приватными переменными. Но, имя публичной переменной не может начинаться с подчёркивания (очевидно же, что в этом случае, она будет считаться приватной), и имя не может начинаться с цифры. 123variable - является недопустимым именем, а variable123 - хорошее, годное имя для переменной. Также избегайте названия своих публичных переменных теми же именами, которыми названы команды Армочки или существующие функции БИСовской библиотеки. Не смотря, что во второй Армочке можно было такое творить, типа как в примере прямо под этим абзацем, в Армочке Третьей это уже невозможно по причинам безопасности и движок выдаст ошибку (да ещё и жаловаться будет!).

false = true;
call = "It's true!";
if (false) then {hint call}; // "It's true! 

Если вы просто напишете myvar = "somevar"; переменная myvar будет по умолчанию проинициализирована в пространстве имён (namespace) миссии и будет существовать до самого конца миссии, и пока вы не вернётесь в лобби. Для уничтожения публичной переменной во время сессии, вам нужно присвоить ей значение nil, вот так: myvar = nil;

 

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

 

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

 

missionNamespace

 

Пространство имён миссии - это основной раздел, также являющийся разделом "по умолчанию". Это пространство имён существует с момента загрузки миссии до момента её окончания. Все переменные, определённые в этом пространстве имён, прекратят существовать, как только вы вернётесь в лобби. Если вам нужно, чтобы ваши переменные существовали подольше, вам следует воспользоваться другими пространствами имён.

 

uiNamespace и parsing Namespace

 

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

 

profileNamespace

 

Это пространство имён будет хранить ваши переменные настолько долго, насколько вы пользуетесь одним профилем в игре. Если вы создаёте другой профиль, или переключаетесь на другой заранее созданный профиль, то публичные локальные переменные, которые вы создали в старом профиле, очевидно, не будут существовать в новом. Сохранение переменных в этом пространстве имён происходит автоматически, но вы можете принудительно сохранить их с помощью команды saveProfileNamespace.

 

В итоге, чтобы создать публичную переменную в пространстве имён миссии, вам можно просто написать что-то вроде myvar = "somevar"; потому что это пространство по умолчанию. Это значит, что по умолчанию, любое подобное действие будет восприниматься движком так же, как еслы бы вы писали:

with missionNamespace do {
	myvar = "somevar";
};//это то же самое, что просто написать:
myvar = "somevar"; 

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

with uiNamespace do {};
with parsingNamespace do {};
with profileNamespace do {}; 

Обратите внимание на то, что ваши публичные переменные из одного пространства не будут доступны в других пространствах. Даже если вы объявите переменную с тем же именем, но в другом пространстве имён, они не будут влиять друг на дружку. Это похоже на поведение приватных переменных в области их действия. Но со специальными публичными локальными переменными всё обстоит иначе  (о них мы поговорим чуть позже).

myvar = 123;
with uiNamespace do {
	hint str (isNil "myvar"); // true
	myvar = 456;
};
with profileNamespace do {
	hint str (isNil "myvar"); // true
	myvar = 789;
};
with uiNamespace do {
	hint str myvar; // 456
};
with profileNamespace do {
	hint str myvar; //789
};
hint str myvar; //123 

Также вы можете установить значение переменной, используя команду setVariable, а прочтитать - командой getVariable. При использовании данных команд, вам необходимо прикрепить их к чему-нибудь, например к пространству имён.

missionNamespace setVariable ["tro","lolol"];
//это то же самое, что и
with missionNamespace do {
	tro = "lolol";
};
//и то же самое, что
tro = "lolol"; 

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

var1 = 1;
var2 = 2;
for "_i" from 1 to 2 do {
	private "_myvar"; // обратите внимание на то, как необходимо предопределять _myvar
	call compile format ["_myvar = var%1;", _i];
	diag_log _myvar;
}; 

вам достаточно проделать такой:

var1 = 1;
var2 = 2;
for "_i" from 1 to 2 do {
	diag_log (missionNamespace getVariable (format ["var%1;", _i]));
}; 

Разумеется, вы можете проделать такой трюк и с другими пространствами имён. Есть несколько вещей, касающихся setVariable и getVariable, о которых надо упомянуть. У команды setVariable есть третий аргумент, который указывает, должна ли переменная быть глобальной или же нет. Я расскажу об этом позже, но на данный момент публичные переменные в пространстве имён могут быть только локальными, поэтому, если вы попробуете сделать их глобальными, выпадет ошибка. У команды getVariable есть альтернативный синтакстис, в котором вы можете назначить значение по умолчанию, которое будет использоваться, если переменная, к которой вы обращаетесь, ещё не определена.

_myrank = profileNamespace getVariable ["MY_RANK", "Private"]; 

Этот кусок кода установит _myrank в значение "Private", если

with profileNamespace do {
	hint str (isNil "MY_RANK"); //true
}; 

Кроме пространства имён вы можете прикреплять публичные переменные к объектам, технике, инструментам управления, группам, задачам, месторасположению, членам группы и местам. Тут есть свои ограничения, о которых будет вестись речь в следующей части. Чтобы разопределить локальную публичную переменную командой setVariable, используйте значение nil в качестве устанавливаемого значения.

profileNamespace setVariable ["MY_RANK", nil]; 

Специальные локальные публичные переменные

 

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

 

true false time enemy friendly sideLogic sideUnknown sideFriendly sideEnemy playerSide east west civilian resistance independent opfor blufor nil objNull grpNull netOnjNull locationNull taskNull controlNull displayNull teamMemberNull player

 

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

 

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

 

 

ArmA Scripting Tutorials: Переменные (Часть Номер Три).

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

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

_var = 0; hint typeName _var; //SCALAR
_var = ""; hint typeName _var; //STRING
_var = true; hint typeName _var; //BOOL
_var = []; hint typeName _var; //ARRAY
_var = {}; hint typeName _var; //CODE
_var = objNull; hint typeName _var; //OBJECT
_var = grpNull; hint typeName _var; //GROUP
_var = controlNull; hint typeName _var; //CONTROL
_var = teammemberNull; hint typeName _var; //TEAM_MEMBER
_var = displayNull; hint typeName _var; //DISPLAY
_var = taskNull; hint typeName _var; //TASK
_var = locationNull; hint typeName _var; //LOCATION
_var = opfor; hint typeName _var; //SIDE
_var = parseText ""; hint typeName _var; //TEXT
_var = configFile; hint typeName _var; //CONFIG
_var = missionNamespace; hint typeName _var; //NAMESPACE 

Если переменная неопределена, то typeName не вернёт никакого значения, но и ошибку тоже не выдаст. Фактически, вы даже сравнить результат команды typeName ни с чем не сможете, потому что это долбанное ничто!

_var = nil; hint typeName _var //ничего
if (typeName _var == "") then {
	diag_log "true";
} else {
	diag_log "false";
};
diag_log "neither";
//.rpt
//"neither" 

Кстати, в Армочке Третьей есть новая команда, которая на данный момент не документирована, и, возможно, не поддерживается. В любом случае, это зарезервированная переменная, которая возвращает значение false, поэтому, я думаю, что всё-таки расскажу о ней.

_var = netobjNull; hint typeName _var; //BOOL 

Глобальные публичные переменные

 

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

//компьютер номер раз
myvar = "somevar";

//компьютер номер два
hint format ["%1", myvar]; // "any"

//компьютер номер три
hint format ["%1", myvar]; // "any


//компьютер номер раз
myvar = "somevar";
publicVariable "myvar";

//компьютер номер два
hint format ["%1", myvar]; // "somevar"

//компьютер номер три
hint format ["%1", myvar]; // "somevar" 

Прекрасными особенностями такого типа обмена данными являются скорость и надёжность, также вы можете прикрепить обработчик событий публичных переменных addPublicVariableEventHandler к переменной, и она будет "выстреливать" максимально быстро, как только обнаружит, что значение наблюдаемой переменной изменилось. Хреновой же особенностью является сама возможность передавать данные с одного компьютера на другой - это открывает возможности эксплойтам, хакерству и прочим излишествам нехорошим. В то время, когда КК писал эту статью, разработчики Армочки Третьей как раз работали над улучшением безопасности.

 

Есть ещё парочка очень полезных команд для работы с публичными переменными: publicVariableClient и publicVariableServer. Разница между ними в том, что вы можете заставить клиент общаться только с сервером, а сервер - с указанным клиентом. Это может серьёзно уменьшить сетевой трафик, поскольку вместо передачи данных всем компьютерам в сети, вы можете передавать данные только выбранным клиентам.

 

Ещё один способ глобально обмениваться публичными переменными состоит в их прикреплении к объектам, которые имеются на всех машинах, к боевой технике, например. Правда, нет обработчика событий, который бы отслеживал изменения таких переменных, поэтому этот способ больше подходит для хранения вместе с объектами каких-нибудь дополнительных данных, и вычитыванию таких данных по запросу. Чтобы прикрепить переменную к объекту, можете воспользоваться командой setVariable. Это делает переменную публичной, но локальной на машине, на которой происходит такое прикрепление.

//компьютер номер раз
myobj = (typeOf player) createVehicle (position player);
myobj setVariable ["lastCreated", time];
hint str (myobj getVariable ["lastCreated", 0]); // время с начала миссии
publicVariable myobj;

//компьютер номер два
hint str (myobj getVariable ["lastCreated", 0]);//"0" 

Чтобы сделать переменную lastCreated глобальной, вам нужно установить 3-й параметр команды setVariable в значение true.

//компьютер номер раз
myobj = (typeOf player) createVehicle (position player);
myobj setVariable ["lastCreated", time, true];
hint str (myobj getVariable ["lastCreated", 0]); // время с начала миссии
publicVariable myobj;

//компьютер номер два
hint str (myobj getVariable ["lastCreated", 0]);// время с начала миссии 

Вы должны быть осторожны, объявляя глобальными переменные, прикреплённые к объектам, поскольку это то же самое, что и применение к переменным команды publicVariable. Если вы храните вместе с объектом часто изменяющиеся данные, то сделать такие переменные глобальными - откровенно отстойная идея, поскольку каждое изменение переменной будет транслироваться в сеть, увеличивая трафик.

 

Я должен успеть вставить ко-какое предупреждение, пока вы не убились об стену, борясь с вопросом: "Почему эта хня не работает с этим объектом?!?". Дома, например, как и другие картографические объекты (и я имею в виду те объекты, которые были добавлены при создании карты, а не миссии) - подгружаемые. Воспринимайте это как... ну... карты в Армочке огромны, поэтому, даже если вы можете загрузить всю карту сразу, это заберёт слишком много вычислительной мощи вашего процессора. Это означает, что если вы прикрепите переменную к объекту на карте и попытаетесь сделать её (переменную) глобальной, на других компьютерах этого предмета может ещё не существовать. А когда, позже, он появится на тех компьютерах, в них может и не оказаться той переменной, которую вы прикрепили, поэтому, стоит за помнить этот нюанс.

 

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

 

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

 

 

ArmA Scripting Tutorials: Специальные Приватные Переменные.

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

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

 

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

 

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

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

) приведён список всех специальных переменных, которые КК смог найти. Если вам известны другие частные переменные, используемые в Армочке, и они похожи на специальные, пожалуйста, поделитесь этой инфой.

 

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

 

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

 

 

ArmA Scripting Tutorials: Массивы (Часть Номер Раз).

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

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

 

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

_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 

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

 

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

 

ArmA Scripting Tutorials: Массивы (Часть Номер Два).

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

В первой части объяснялось, по большей части, то, как получить информацию из архивов. В этой части мы собираемся посмотреть как их изменять и как манипулировать ими. Но сначала позвольте рассказать о ещё двух командах, связанных с массивами, они вам понадобятся когда будете работать с записями в конфигах классов, 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] 

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

 

ArmA Scripting Tutorials: Массивы (Часть Номер Три).

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

Итак, во второй части мы научились манипулировать с массивами. Время перейти к кое-чему посложнее, навроде копирования массивов. Видите ли, если вы присваиваете значения одного массива другому, навроде _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; 

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

 

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

 

ArmA Scripting Tutorials: Чувствительность к Регистру.

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

Необходимо рассказать немного о РеГИстРоВОй чуВсТвиТЕЛЬнОсТи в Армочке, поскольку иногда она может вызвать замешательство и даже привести к ошибкам в коде. Давайте взглянем на некоторые примеры:

_variable = "_var";
hint _VArIAblE; //покажет "_var"
variable = "var";
hint VARIaBLE; //покажет "var"
with missionNamespace do {
	hint variaBLE; //покажет "var"
};
hint (missionNamespace getVariable "VArIAbLe"); //покажет "var"
missionNamespace setVariable ["VARIABLE","VAR"];
hint variable; //показывает "VAR"
_funCTION = {
	hint "func";
};
null = [] spawn _functioN; //показывает "func"
funCtioN = {
	hint "func";
};
call FUNCtiON; //показывает "func" 

Имена переменных и команды Армочки являются нечувствительными к регистру. Любая из команд HINT, HiNt и hint сработает как надо. Записи конфигов, кстати, тоже.

_result = getText (configfile >> "cfgWeapons" >> "arifle_MXC_F" >> "displayname");
//_result = "MXC 6.5 mm"
_result = GEtTeXt (configfile >> "cfgWEAPONs" >> "aRIFLE_mxc_f" >> "displayNAME");
//_result = "MXC 6.5 mm" 

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

a = "HELLO";
b = "hello";
_result = if (a==b) then {"true"} else {"false"};
//_result = "true"
_result = if (a!=b) then [{"true"},{"false"}];
//_result = "false" 

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

a = "HELLO";
b = "hello";
_result = if (a in [b]) then {"true"} else {"false"};
//_result = "false"
_result = if !(a in [b]) then [{"true"},{"false"}];
//_result = "true"
_result = if (([b] find a) >=0) then {"true"} else {"false"};
//result = "false"
_result = if (([b] find a) < 0) then [{"true"},{"false"}];
//result = "true" 

Или же, вы можете полностью заменить in/find  похожей консрукцией switch/case и достигнуть того же результата.

a = "HELLO";
b = "hello";
_result = switch a do {case b : {"true"}; default {"false"};
//_result = "false"
b = "HELLO";
_result = switch a do {case b : {"true"}; default {"false"};
//_result = "true" 

А в случае, если вы используете регистрочувствительные сравнения и вам небходимо переключить всё в один регистр, вам стоит запомнить пару команд: си toLower.

a = "HeLlO";
a = toUpper a;
//теперь a = "HELLO"
a = toLower a;
// теперь a = "hello"
_array = ["MARK","STEVE","HENRY"];
_firstName = "Steve";
_result = _firstName in _array;
//_result = false
_result = (toUpper _firstName) in _array;
//_result = true 

Если что-то упустил - не стесняйтесь, дополняйте, давайте знать

 

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

 

 

ArmA Scripting Tutorials: Циклы.

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

Цикл - это кода кусок, который повторяется, и повторяется, и повторяется, и повторяется, и повторяется, и ... Когда-нибудь такая хитрая штука понадобится и вам, и есть не так уж много путей, как организовать сие. Сейчас приведу пример. Допустим, вам необходимо добавить 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 {}; // отменяет цикл 

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

 

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

 

 

ArmA Scripting Tutorials: Циклы V2.

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

Мне хотелось бы вернуться к уроку по циклам и особое внимание уделить циклам, которые могут запускаться каждый кадр. Почему именно на них? Да потому что если вы привязываете код к 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 может, напротив, быть проверена множество раз за время отрисовки кадра.

 

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

 

 

ArmA Scripting Tutorials: Создание безопасных функций обратного вызова (коллбэков)

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

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

 

Создать функцию у каждого клиента - просто. Когда миссия загружается, загружается 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);
"; 

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

 

 

2013 09 03 Добавлены материалы по самым началам скриптописаний и SQF - синтаксису.. Изменён порядок изложения статей.

2013 09 04 Добавлен материал по циклам

2013 09 05 Добавлены первая и вторая части по работе с переменными. Изменён порядок изложения статей

2013 09 06 Закончен урок по переменным

2013 10 01 Обновлена информация по "ленивой" проверке, и изменен перевод БИСовского туториала - приведён к рабочему варианту, в отличие от того, что в бис вики.

Edited by Avi, 07 May 2014 - 07:47.

[Blender]

Думаю - это полезный гайд для многих!

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

Для тестов было взято числовое значение 100'000.

 

Цикл while обработал итерацию за 1.08398 секунды

Цикл for "_i" from 0 to 10000 за 0.0549316 секунды

Цикл for [{ _i = 0 }, { _i <= 10000 }, { _i = _i + 1 }] за 1.17102 секунды

 

Теже тесты но со значением в 1'000'000 циклов:

while за 10.975 с

for "_i"... за 0.457031 с

for [{ _i... за 11.816 с

 

Таким образом использование цикла for "_i"... дает двадцатикратное преимущество по производительности над остальными вариантами циклов!

[Avi]

Блендер, тоже не стесняйтесь, делитесь, ежели есть чем - должно же быть : )

[Avi]

Больше не могу редактировать первое сообщение в теме... Но нет худа без добра, - глядишь наберу больше лайков 

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

 

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

 

ArmA Scripting Tutorials: Создание безопасных функций обратного вызова (коллбэков). окончание

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

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

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

 

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

 

Сегодняшний урок будет о присобачивании одних объектов к другим. Как по мне - так интересная тема для экспериментов.

 

ArmA Scripting Tutorials: attachTo и setVectorDirAndUp

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

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

 

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

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

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

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

 

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

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

 и выберите 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 должно быть достаточно для задания любой ориентации объекта в пространстве.

 

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

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

 

 

 

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

 

ArmA Scripting Tutorials: distanceSqr, linearConversion, difficulty, setAmmo, drawIcon3d

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

В Армочке Третьей уже более 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"	];
};

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

 

Edited by Avi, 23 April 2014 - 16:50.

[Avi]

ArmA Scripting Tutorials: Области действия

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

Область действия (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 - регистрочувствителен.

 

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

 

Edited by Avi, 23 April 2014 - 17:01.

[Avi]

ArmA Scripting Tutorials: boundingBox, boundingBoxReal, composeText, formatText, visiblePosition, visiblePositionASL

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

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

 

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"
    ];
}]; 

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

 

ArmA Scripting Tutorials: regex_match и regex_replace - ЧТО ЭТО ТАКОЕ И С ЧЕМ ЕГО ЕДЯТ

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

А вот и документация на использование 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]. Но если вы попробуете распарсить

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

и включить символ '/' в RegEx, вам нужно будет использовать другой разделитель, поскольку '/' будет конфликтовать с RegEx. В этих случаях можно взять '|':

_result = "regex_replace" callExtension "|http://||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, поэтому, теоретически они легко могут быть добавлены в Арму Третью на уровне движка, и могут быть предоставлены пользователям как обычные скриптовые команды. Ну что же, давайте посмотрим, как пойдёт дальнейшая разработка Армы третьей.

 

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

 

Адрес ссылки, где можно за это голосовать: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

(продублировано в соответствующей теме на форуме - тут)

 

ArmA Scripting Tutorials: BIS_fnc_compileFinal

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

Начнём с того, что эта функция не является частью Армы Третьей, она специально придумана, хотя КК собирается попытаться убедить БИСов включить что-нибудь подобное в стандартную библиотеку функций. Почему она нужна? Потому что 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 ещё не тестировал, поэтому, буду рад комментариям)

 

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

 

ArmA Scripting Tutorials: Как Найти Строку Внутри Строки

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

КК подумал, а чё бы ему не поделиться функцией, которую он написал, когда помогал делать мод ДеньГ (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 раз быстрее БИСовской. Это вам не в чешки срать!

 

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

 

ArmA Scripting Tutorials: Корневая Папка Миссии

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

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

 

По-умолчанию, миссия упакована в .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>. Но, тем не менее, это тоже работающий метод

 

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

Edited by Avi, 24 April 2014 - 12:25.

[Avi]

 
Этим постом я начинаю серию из пяти уроков, посвящённую созданию графических пользовательских междумордий. Поскольку больших кусков свободного времени в последнее время у меня немного, это может затянуться. С другой стороны, есть материал, навроде того, как строить мосты в арме, как сделать вращающееся оружие, аптечку и т.п. для более удобного поднятия их с трупа (неплохо подойдёт для, например, симулятора вульфенштайна или дума в Арме), как улучшить текстуры на дальних расстояниях и т.п. и я могу прервать серию, чтобы выложить эти материалы - дайте знать, что вам это интереснее. Или если у вас есть какие-нибудь материалы, и вы хотели бы видеть их переведёнными на русский язык - смело пишите в личку.
 
ArmA Scripting Tutorials: GUI (Часть номер раз)
Автор: KillzoneKid
Оригинал:

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

Наверняка вы уже знаете как вывести сообщение на экран. Вы можете сделать это командами hint, cutText или даже sideChat. При использовании этих команд текст будет появляться в определённых местах на экране - у каждой из этих команд есть это определённое место. Но что делать, если вы хотите вывести текст где-нибудь в другом месте? Тогда вам придётся сделать свой GUI (Graphical User Interface - графическое пользовательское междумордие). Не пугайтесь: это только звучит сложно - сделать такое гораздо проще. А отладка этого интерфейса - так и вовсе простое дело, благодаря встроенной отладочной консоли (см. урок "ArmA Scripting Tutorials: Начинаем" в самом начале этой темы).

• Откройте редактор, поместите юнит на карту и сохраните миссию
• Откройте папку, в которую вы сохранили миссию и создайте пустой файл. Назовите его description.ext
• Скопипастите следующий код в description.ext и сохраните файл:

class RscTitles
{
	class ExampleTitle
	{    
		idd = -1;
		duration = 1;
		class controls
		{
			class ExampleControl
			{    
				idc = -1;
				type = 0;
				style = 0;
				x = 0; 
				y = 0;
				w = 1;
				h = 1;
				font = "EtelkaNarrowMediumPro";
				sizeEx = 0.1;
				colorBackground[] = {0,0,0,1};
				colorText[] = {1,1,1,1};
				text = "Example Text";
			};  
		};	
	};
}; 

• Зайдите в редактор и загрузите свою миссию
• Запустите PREVIEW и нажмите Esc, чтобы открыть отладочную консоль
• Копипастните следующий код и нажмите LOCAL EXEC:

cutRsc ["ExampleTitle","PLAIN"]; 

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

Получилось? Сложно было? Объяснение того, что это было ждите в следующей части этого урока. На этом всё.

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

 

ArmA Scripting Tutorials: GUI (Часть номер два)
Автор: KillzoneKid
Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

Так, и на чём же мы остановились? Начнём с самого начала первой части этого урока.

description.ext
 
Файл description.ext - это что-то вроде обрезанной версии config.cpp, и используется он в миссиях, а не в модах. В нём вы можете определять новые классы, прямо как в config.cpp, но есть довольно серьёзные ограничения на то, что именно вы можете определять, а что не можете. Например, вы не можете определять классы CfgVehicles, но когда дело касается интерфейсов - куда предпочтительнее использовать для разработки GUI description.ext, даже если вы планируете позже засунуть весь этот GUI в мод. Предпочтительнее это, потому что при внесении изменений в GUI куда проще перезагрузить миссию и посмотреть, что же поменялось, нежели перелопачивать аддон и перезапускать всю игру. Вам только нужно запомнить, что надо либо сохранять миссию в редакторе, либо перезагружать её, каждый раз, когда вы вносите какие-либо изменения в description.ext.

 

Думаю, стоит добавить, что для того, чтобы вычитать классы из description.ext вам нужно использовать команду missionConfigFile, а не используемую для config.cpp команду configFile.

RscTitles
 
Есть два способа отобразить ваш GUI, или, давайте пока будем называть его "ресурс". Вы можете использовать команду createDialog, которая представит ваш ресурс в виде диалога, или высветить его с помощью команд cutRsc / titleRsc (Rsc - означает resource или, если по-нашему, ресурс), в этом случае обращение с ним будет как просто с отображаемым элементом. Разница в том, что в режиме диалога вам придётся управлять курсором мыши. В этом уроке основной упор будет на команду cutRsc.

Класс RscTitle - это особый класс, и, что особо важно в данном случае, это то, что он служит контейнером для ваших ресурсов. Команда cutRsc ищет ваш ресурс внутри RscTitles и если его там нет, вы получаете сообщение об ошибке. Если вы используете команду createDialog, вам не следует помещать диалоговые ресурсы внутри RscTitles.

Вот как выглядит формат команды cutRsc:

layerNumber cutRsc [resourceClass, behaviour, durationMultiplier, showOverMap];

где:

• layerNumber - Номер слоя. Может быть опущен или же может быть любым числом от 0 до, по меньшей мере, 1 000 000 (миллион). Если вы последовательно выполняете две команды cutRsc на одном и том же слое, то более поздняя перепишет результат ранней. Именно поэтому, чтобы завершить отображение текущего ресурса, вам надо вызвать отображение пустого ресурса на том же слое. Вы можете создать и определить этот ресурс сами. Если вы хотите видеть вывод обоих элементов, вам придётся поместить их на разные слои. Слои с большими номерами лежат поверх слёв с меньшими номерами.
• resourceClass - класс ресурсов. Это имя вашего класса ресурсов в RscTitles, в нашем примере - "ExampleTitle"
• behaviour - поведение. Может принимать одно из следующих значений:
  • "PLAIN" - поведение по-умолчанию. Ничего особенного
  • "PLAIN DOWN" - то же самое, что и предыдущее, но внизу экрана.
  • "BLACK" - экран постепенно чернеет и остаётся чёрным, пока этот же Rsc-слой не будет переписан другим значением.
  • "BLACK FADED" - экран постепенно чернее, остаётся чёрным на указанное в конфиге ресурсов время, после чего становится нормлальным.
  • "BLACK OUT" - то же самое, что и "BLACK"
  • "BLACK IN" - то же самое, что и "BLACK FADED", только длительность равна нулю
  • "WHITE OUT" - то же, что и "BLACK OUT", только белый
  • "WHITE IN" - то же, что и "BLACK IN", только белый
• durationMultiplier - множитель длительности. Может быть опущен. Общее время отображения ресурса - это сумма времени появления (fade in), длительности (duration) и исчезновения (fade out). Все эти значения определяются в конфиге ресурса. durationMultiplier влияет на общее время отображения ресурса. 0.5 - уменьшит его наполовину, 2 - увеличит вдвое, 0 будет проигнорирован. По-умолчанию равен 1.
• showOverMap - показывать поверх карты. Если в нажмёте "M", и выведете на экран внутриигровую карту, по-умолчанию, ресурс будет показан поверх карты. Чтобы скрыть его, когда вы открываете карту надо установить этот параметр в false (только для Армы 3).

 

ExampleTitle
 
Это класс ресурсов. Имя может быть любым, только если оно не конфликтует с уже существующими именами классов. А ещё этот класс - наше полотно, наш холст, на котором мы будем рисовать GUI. Какие бы вы элементы (controls) не поместили внутрь этого класса, они будут отображаться, когда мы вызовем этот ресурс командой cutRsc. Для текстовых ресурсов необходимо добавить минимум два параметра в этот класс:

 

• idd - Display ID. Каждый отображаемый элемент и диалог должны иметь идентификатор (ID). Это может быть уникальный номер или просто -1, как в нашем случае, если мы не собираемся адресно обращаться к этому отображаемому элементу.
• duration - как долго (в секундах) наш ресурс должен быть на экране. В нашем случае - 1 секунду. Но, тем не менее, полная длительность включает в себя также время появления и исчезновения, которые, в нашем случае, мы не устанавливаем, и движок использует значения по-умолчанию. Чтобы задать и их длительность, нужно в ваш класс добавить параметры fadein и fadeout.

controls
 
Ещё один класс ресурсов. Этот - контейнер для отображаемых элементов. Другие спецклассы, которые можно использовать в качестве таких контейнеров - это backgroundControls и objects.

 

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

• idc - Control ID. Каждый элемент (control) должен обладать идентификатором, по которому к нему можно будет обратиться, в случае необходимости. Если ссылаться на этот элементы вы не намерены, подойдёт значение -1, но будьте осторожны - несколько элементов с idc = -1 в одном классе просто не будут правильно работать.
• type - тип элемента, такой как текстовое поле, кнопка, список, и т.п. У каждого типа элемента есть свой номер, который его определяет. Может быть десятичным или шестнадцатеричным. 0 - это однострочное текстовое поле.
• style - Стиль отображения элементов, такой как - с контуром, без контура, выравнивание текста, и т.п. Стиль так же, как и тип может определяться десятичным или шестнадцатеричным значением. 0 - (по-умолчанию) текст, с выключкой влево (выравненный по левому краю)
• x - относительная координата X левого верхнего угла элемента
• y - относительная координата Y левого верхнего угла элемента
• w - относительная ширина элемента
• h - относительная высота элемента
• font - гарнитура по-умолчанию
• sizeEx - кегль
• colorBackground - цвет фона элемента {r,g,b,a}
• colorText - цвет текста/переднего плана элемента {r,g,b,a}
• text - текстовая строка или путь к текстуре.

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

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

 

Edited by Avi, 24 April 2014 - 15:47.

[Stas200124]

СПС помогло

[Avi]

ArmA Scripting Tutorials: GUI (Часть номер три)
Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

Продолжаем урок по созданию GUI. Как уже было замечено выше, любой диалог в Арме - это комбинация ТИПА (TYPE) и СТИЛЯ (STYLE). Тип определяет базовую функциональность диалога, будет ли это простой прямоугольник или список кнопок или может быть слайдер (движковый регулятор). Есть даже отдельный тип для внутриигровой карты. Стилями определяется прочее разнообразие оформления диалогов и вариативность базовой функциональности. Иногда возникает нужда в дополнительных параметрах.

 

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

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

- весьма хороший источник для дальнейшего изучения. Поэтому тут я пока остановлюсь на type = 0; но покажу несколько стилей, которые подойдут этому типу. Ниже видео с некоторыми экпериментами с Армовскими диалогами:

 

Размер и позиционирование диалога

 

Взгляните на картинку, представленную ниже. Синий прямоугольник в центре - это зона привязки, она абсолютно одинакова на любом мониторе, на любом экране. Она всегда имеет соотношение сторон 4:3 и всегда расположена в точке с координатами 0,0 и её размер всегда 1Х1.

 

 

Поэтому, когда вы строите свой GUI, позиционирование и размеры элементов вашего интерфейса рассчитывается относительно этого опорного прямоугольника. Например, если вы укажете, что ширина вашего элемента равна 0,5 (w = 0.5;), это будет означать, что размер будет вполовину синего прямоугольника, поскольку ширина всего прямоугольника равна 1. Кроме того, всегда надо помнить, что этот прямоугольник не является квадратом, поэтому w = 0.5; не будет равна h = 0.5; ни по занимаемому пространству на экране ни по количеству пикселей.

 

Например, высота вашего объекта (которая берётся относительно синего прямоугольника) равна 0.7, теперь, чтобы создать квадратный элемент, вам нельзя выбрать ширину элемента равной 0.7, поскольку это значение возьмётся относительно ширины синего прямоугольника, а эта ширина в 4/3 больше, чем высота. Поэтому, вам придётся соответственно подстроить это значение:

//Делаем квадрат со сторонами, равными высоте h
h = 0.7;
w = 0.7 * 3 / 4;

//Делаем квадрат со сторонами, равынми ширине w
h = 0.7 * 4 / 3;
w = 0.7; 

Но как быть, если нам надо знать полную ширину или высоту экрана, а не только центрального прямоугольника? Есть пара команд, которые возвращают относительную ширину и высоту экрана: safeZoneW и safeZineH. Итак, если ширина синего прямоугольника равна 1; полная ширина вашего экрана будет w = safeZoneW; Есть ещё одна команда для измерения ширины экрана - это safeZoneWAbs. Эта команда возвращает полную ширину экрана в случае, если вы играете на нескольких мониторах., поэтому, если вы хотите, чтобы ваш прямоугольник закрывал весь экран:

//Один монитор
h = safeZoneH;
w = safeZoneW;

//несколько мониторов
h = safeZoneH;
w = safeZoneWAbs; 

Для позиционирования ваших элементов, вам тоже нужно помнить о синем прямоугольнике. С позиционированием элементов за пределами синего прямоугольника нам даны команды safeZoneY, safeZoneX и safeZoneXAbs для случаев с игрой на нескольких мониторах. Таким образом, верхний левый угол у нас:

//Один монитор
x = safeZoneX;
y = safeZoneY;

//несколько мониторов
x = safeZoneXAbs;
y = safeZoneY; 

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

• safeZoneX: -0.235402
• safeZoneY: -0.0882083
• safeZoneW: 1.4708
• safeZoneH: 1.17642
• safeZoneXAbs: -0.235402
• safeZoneWAbs: 1.4708

Как видите, у КК один монитор, поэтому safeZoneX == safeZoneXAbs и safeZoneW == safeZoneWAbs. Если вам нужно расположить ваш диалог в верхнем-левом углу, то это делается просто и без хитростей. Если вам нужно расположить его в правом-нижнем углу, вам нужно найти координаты правого нижнего угла и вычесть из них высоту и ширину вашего прямоугольника. Пользуйтесь рисунком в начале этой части урока как справочным материалом.

 

Ниже представлен код, проделывающий этот трюк (кстати, маленькая прямоугольная аномалия в правом нижнем углу не является частью кода):

class RscTitles
{
	class ExampleTitle
	{    
		idd = -1;
		duration = 10; //показывать в течение 10 секунд
		class controls
		{
			class ExampleControl
			{    
				idc = -1;
				type = 0;
				style = 2; //выключка текста по центру
				x = safeZoneX + safeZoneW - 0.6 * 3 / 4; 
				y = safeZoneY + safeZoneH - 0.6;
				h = 0.6;
				w = 0.6 * 3 / 4; //w == h
				font = "EtelkaNarrowMediumPro";
				sizeEx = 0.03;
				colorBackground[] = {1,1,0,1}; //желтый фон
				colorText[] = {0,0,1,1}; //синий цвет
				text = "Bottom Right Corner Square Box";
			};  
		};	
	}; 

На этом всё. В следующем уроке будем вести речь о стилях.

 

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

 

 

ArmA Scripting Tutorials: GUI (Часть номер четыре)
Автор: KillzoneKid
Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

В третьей части урока по междумордиям я обещал, что покажу несколько стилей, которые работают с type = 0; И я покажу вам стили. Стили меняются через через 16 и повторяются через 256. Звучит по-идиотски? Объясню на пальцах. Нумерация стилей начинается с 0, если мы выберем 16, мы получим следующий стиль, если 32 - ещё один, и т.д. Номер последнего уникального стиля, в данный момент, в Арме - это 176 (11*16), что даёт нам 12 стилей (0 тоже считается). Стиль 256 - это то же самое, что и стиль 0, как и 512 и т.д. Но есть и несколько исключений, вроде убирания границ прямоугольных областей для многострочного текста или  сохранения соотношения сторон для картинок.

 

В каждом стиле в качестве значения по умолчанию используется выключка текста влево (если там есть текст). Чтобы сделать выключку текста вправо, надо добавить 1 к номеру стиля. Таким образом, стиль 16 будет иметь выключку влево, а стиль 17 - выключку вправо, а стиль 18 будет иметь выключку по центру.

 

КК создал элемент GUI с универсальным текстовым параметром text = "foldernpic.paa"; В среде с многострочным текстом параметр n переносит строку, и мы бы увидели две строки вместо одной. В среде с картинками, показывается картинка радиобашни, поскольку текстовая строка является путём к нашей картинке.

Кстати, вот эта картинка: 

А вот код:

class RscTitles
{
	class ExampleTitle
	{    
		idd = -1;
		duration = 10;
		class controls
		{
			class ExampleControl
			{    
				idc = -1;
				type = 0;
				style = 0; //1 2 3...176
				x = 0.25; 
				y = 0.25;
				h = 0.5;
				w = 0.5;
				font = "EtelkaNarrowMediumPro";
				sizeEx = 0.05;
				colorBackground[] = {1,1,1,1}; //белый фон
				colorText[] = {0.5,0.5,0.5,1}; //серое начертание
				text = "folder\npic.paa";
				lineSpacing = 1; //нужно для многострочных стилей
			};  
		};	
	};
}; 

Стили диалога

 

Single Line Box (style = 0;). Прямоугольник без отрисовки контура, содержащий простой текст:

 

 

Multiple Line Box (style = 16;). Простой прямоугольник, окантованный слабым контуром, содержащий простой многострочный текст. Чтобы убрать отрисовку контура, добавьте 512 к стилю (стили 528, 529 и 530 - уже не будут иметь отрисовки контура вокруг прямоугольника). Этот стиль требует наличия дополнительного параметра lineSpacing = 1; - это обычный межстрочный интервал. Сочетание символов n воспринимается как перенос строки:

 

 

Single Line Title Box (style = 32;). Простой однострочный текст на полупрозрачном фоне и окантован чем-то вроде "вытянутого/выдавленного" контура:

 

 

Picture Box (style = 48;). Прямоугольник без контура, содержащий картинку. Выключка никакого эффекта не оказывает. По-умолчанию текстурка растягивается, чтобы полностью заполнить содержащий её прямоугольник, чтобы сохранить оригинальное соотношение сторон, добавьте 2048 к номеру стиля. Фон игнорируется, colorText управляет цветом и прозрачностью текстуры:

 

 

Frame Box (style = 64;). Прямоугольник без фона, но с текстом, отображаемым на краю прямоугольника. Выключка ни на что не влияет. colorText определяет цвет текста и окантовки (frame).

 

 

Background Box (style = 80;). Полностью чёрный непрозрачный прямоугольник, окантованный "скошенным" толстым контуром, содержащий однострочный текст:

 

 

Group Box (style = 96;). Однострочный текст на полупрозрачном фоне и слабо выделенным контуром. Изменять цвет можно только у текста:

 

 

Group Box 2 (style = 112;). Однострочный текст на сплошном фоне, похоже на стиль 0, но есть слабовыделенный контур, похожий на тот, что в стиле 16 (multi line box):

 

 

HUD Background Box (style = 128;). То же самое, что и стиль 0. Возможно, что не используется

 

Title Picture Box (style = 144;). Прямоугольник с картинкой, навроде стиля 48. Разница в том, что картинка в этом прямоугольнике имеет подчёркивание. Как и прежде, чтобы сохранить соотношение сторон, добавьте 2048 к номеру стиля:

 

 

Rectangular (style = 160;). Окантованный прямоугольник, похожий на стиль 64. Но текст отображается внутри прямоугольника, цвет контура и текста задаётся параметром colorText:

 

 

Line (style = 176;). Диагональная линия из верхнего-левого угла в правый-нижний. Чтобы изменить направление линиии, параметры ширины w и высоты h прямоугольника могут быть отрицательными. Цвет линии и текста устанавливается параметром colorText:

 

 

Стили 192, 208, 224 и 240 не отличаются от стиля 0, и, возможно, не используются. На этом заканчиваю четвёртую часть.

 

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

 

ArmA Scripting Tutorials: GUI (Часть номер пять)
Автор: KillzoneKid
Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

Ну что, продолжаем? В четвёртрой части я прошёл мимо некоторых параметров, что же, здесь их и раскроем. colorText и colorBackground - это довольно стандартные rgba-цвета. КК сделал конвертер цветов из НЕХ в арму, и у на этом форуме есть посвящённый этому пост, вот он (клац). Этот конвертер полезен к ознакомлению хотя бы уже по тому, что с его помощью проще понять, как вся эта хрень работает. Что до гарнитуры, то мы используем "EtelkaNarrowMediumPro",- похоже, что он является довольно стандартным, и присутствует и в Арме Второй, и в Арме Третьей, поэтому, для урока - он то, что надо. sizeEx используется, чтобы задать кегль и он относителен опорного синего прямоугольника, о котором было расписано в третьей части урока по GUI.

 

 

Теперь, когда мы прошли некоторые основы, я бы хотел обратить ваше внимание на некоторые более продвинутые вещи, такие как динамическая подгрузка классов. Видео, приведённое выше, демонстрирует как Rsc (ресурс) может быть подгружен с набором рандомных параметров при каждой прорисовке. Иногда этот метод может уменьшить количество необходимых скриптов, иногда вы можете изменять параметры, для изменения которых даже нет отдельной команды.

 

Например, чтобы изменить размер или расположение вашего Rsc, вам сперва нужно загрузить его с cutRsc, затем использовать обработчик событий UI onLoad, чтобы получить доступ к текущей отображаемой инстанции Rsc (которая будет передана в переменной _this), и вот теперь вы можете использовать displayCtrl, чтобы получить инстанцию текущего элемента, чтобы получить возможность использовать команду ctrlSetPosition. И даже после всего этого наворота, вам всё-равно надо ещё вызвать ctrlCommit для завершения действия. Вот как это будет смотреться, в случае нашего обобщённого примера:

//description.ext
class RscTitles
{
	class ExampleTitle
	{    
		idd = -1;
		duration = 60; //1 min
		onLoad = "_this call onRscLoad"; //обработчик событий UI
		class controls
		{
			class ExampleControl
			{    
				idc = -1; //ссылка на этот "контроль"
				type = 0;
				style = 0;
				x = 0; 
				y = 0;
				w = 1;
				h = 1;
				font = "EtelkaNarrowMediumPro";
				sizeEx = 0.1;
				colorBackground[] = {0,0,0,1};
				colorText[] = {1,1,1,1};
				text = "Example Text";
			};  
		};	
	};
};

//init.sqf
onRscLoad = {
    private ["_display","_idc","_ctrl"];
    _display = _this select 0;
    _idc = -1;
    _ctrl = _display displayCtrl _idc;
    _ctrl ctrlSetPosition newPosition;
    _ctrl ctrlCommit 10;
};
newPosition = [0.5,0.5,0.5,0.5];
cutRsc ["ExampleTitle","PLAIN"]; 

Как только ресурс "ExampleTitle" загружается, он вызывает функцию onRscLoad через обработчик событий UI onLoad, которая изменяет размер и месторасположение элемента. onLoad вызывается после того, как класс будет проинициализирован и работает с обеими командами: и с cutRsc и с createDialog. Есть ещё обработчик событий onLoad, который работает только с createDialog. Я ещё сделал так, чтобы переход продолжался в течение 10 секунд (ctrlCommit 10), чтобы у вас было время обозреть процесс. Для мгновенного эффекта значение должно быть установлено в 0. Также, чтобы сослаться на нужный нам элемент, мы должны указать его idc (в нашем случае -1). Одновременно отображаться может больше, чем 1 элемент, поэтому их idc должны отличаться друг от друга.

 

onLoad выполняется в missionNamespace, поэтому, любая пременная, которая есть внутри выражения onLoad будет использоваться как переменная из missionNamespace, если только вы не укажете использовать другое пространство имён. Интересной особенностью является то, что во время подгрузки классов, другие параметры классов проходят что-то вроде call compile, поэтому вы можете использовать тут переменные или даже скриптовые команды. Только для того, чтобы передать переменную в параметр класса вы должны указать пространство имён, которое вы хотите использовать. Итак, чтобы динамически подгружать параметры в класс ресурсов при загрузке этих самых ресурсов, мы может проделать вот такой трюк:

//description.ext
class RscTitles
{
	class ExampleTitle
	{    
		idd = -1;
		duration = 60; //1 min
		class controls
		{
			class ExampleControl
			{    
				idc = -1;
				type = 0;
				style = 0;
				x = "missionNamespace getVariable 'newPosition' select 0"; 
				y = "missionNamespace getVariable 'newPosition' select 1";
				w = "missionNamespace getVariable 'newPosition' select 2";
				h = "missionNamespace getVariable 'newPosition' select 3";
				font = "EtelkaNarrowMediumPro";
				sizeEx = 0.1;
				colorBackground[] = {0,0,0,1};
				colorText[] = {1,1,1,1};
				text = "Example Text";
			};  
		};	
	};
};

//init.sqf
newPosition = [0.5,0.5,0.5,0.5];
cutRsc ["ExampleTitle","PLAIN"]; 

В этом примере (который сразу над этими строками) трансформация Rsc будет мгновенной, и произойдёт поскольку ресурс будет подгружен сразу с указанными параметрами. Обратите внимание на то, как скрипты заключаются в кавычки. Иногда вы сможете обойтись без кавычек, но если вы хотите оставаться на светлой стороне силы (безопасной), вам лучше пользоваться ими. А ещё text - это особый параметр, и он не будет скомпилирован. Он распознаёт переменные, используемые для локализаций, и которые начинаются с $, но если вы хотите провернуть трюк с динамическим изменением текста, вам придётся это проделывать с помощью комбинации из onLoad и ctrlSetText.

 

Ещё одна специфическая особенность использования скриптов внутри параметров классов состоит в том, что только первое выражение компилируется и исполняется. Если у вас больше, чем одно, то всё, что следует после ; - игнорируется. В качестве костыля вы можете пользоваться командой call, что позволит использовать более, чем одно выражение. В этом случае, в вашу функцию по-умолчанию не передастся ничего, в отличие от использования обработчика событий onLoad. Теперь, возвращаясь к тому, с чего начали, вот код видеопримера:

//description.ext
class RscTitles
{
	class ExampleTitle
	{    
		idd = -1;
		duration = 0.1;
		fadein = 0;
		fadeout = 0.1;
		onLoad = "(\
			(_this select 0) displayCtrl -1) ctrlSetText ([\
				'DISCO',\
				'BALL',\
				'SUBLIMINAL',\
				'VERSES'\
			] select (floor (random 4)));\
		";
		class controls
		{
			class ExampleControl
			{    
				idc = -1;
				type = 0;
				style = 2;
				x = "random 1 min 0.5"; 
				y = "random 1 min 0.5";
				h = "random 1 min 0.5";
				w = "random 1 min 0.5";
				font = "EtelkaNarrowMediumPro";
				sizeEx = "random 0.2 min 0.08";
				colorBackground[] = {"random 1","random 1","random 1",1};
				colorText[] = {"random 1","random 1","random 1",1};
				text = "";
			};  
		};	
	};
};

//init.sqf
mytime = diag_tickTime + 10;
onEachFrame {
    if (mytime < diag_tickTime) then [
        {random 100},
        {100}
    ] cutRsc ["exampleTitle", "Plain"];
}; 

Теперь объясню, что же тут происходит. Наш Rsc вызывается при отрисовке каждого кадра, и отрисовывается на одном и том же слое (100) на 10 секунд. Rsc загружается с набором рандомных параметров цвета, цвета фона, размера и расположения на экране, текст тоже рандомен. Поскольку рисуется всё на одном и том же слое, каждая новая отрисовка элемента стирает предыдущий. После 10 секунд Rsc вызывается на рандомном слое, на каждом из которых он остаётся на 0,1 секунду, после чего исчезает. Именно поэтому, вы видите элемент в нескольких местах.

 

Ещё замечание по использованию обработчиков событий UI. Это лучший способ управляться с UI. Вам нет нужны использовать disableSerialization в функциях, которые вызываются из обработчиков событий UI. Это нужно только если вы собираетесь сохранять переменные UI для последующего их использования - в этом случае да - вы можете столкнуться с проблемами движка, и тут disableSerialization может понадобиться. Даже хранения переменных в uiNamespace может быть недостаточно.

 

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

 

Edited by Avi, 24 April 2014 - 15:59.

[Avi]

Я являюсь спина, что гугл транслейт переводит на англицкий, как I'm back, что, в обратном переводе даёт уже "я вернулся", что нам и нужно.

 

Сегодня я хочу выложить на обозрение русскоговорящим товарищам некоторые трюки и фишки KK:

 

ArmA Scripting Tutorials: Несколько фишек и трюков
Автор: KillzoneKid
Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

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

hint str [];
diag_log []; 

Или же вы можете воспользоваться командой format, но [] - это настолько просто и быстро, и даже показывает неопределённые переменные, как "any". Вот, глядите:

hint str [name player, player, _lol];
//["KK",B Alpha 1-1:1 (KK),any]
diag_log [123, isServer, vehicles];
//[123,true,[heli]] 

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

 

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

_eh = player addEventHandler [
    "Killed",
    format [
        "hint str (%1 distance (_this select 0))",
        position player
    ]
]; 

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

hint str ([2479.25,5668.04,0.00143433] distance (_this select 0)); 

Ну и чисто для справки, если вам очень интересно, что же лучше, передавать {} или "" в функцию обработчика событий, похоже, что разницы в производительности нет никакой, по крайней мере в экспериментах КК её не было (сам я ещё не проверял).

player addEventHandler ["fired", "hint name player"];
player addEventHandler ["fired", {hint name player}]; 

А ещё есть изящный трюк как подключить файл из любой папки к миссии. Команда препроцессора #include позволяет подключать файлы только из той же папки, из которой она исполняется:

//месторасположение скрипта: MISSION_ROOT\test.sqf
#include "includes.hpp"
//Место поиска: MISSION_ROOT\includes.hpp 

или же в подпапках той папки, откуда исполняется:

//месторасположение скрипта : MISSION_ROOT\a\test.sqf
#include "b\includes.hpp"
//место поиска: MISSION_ROOT\a\b\includes.hpp 

Если вам хочется, чтобы у вас был централизованный include-файл, то команда #include вам просто не помощник. Но вместо неё вы можете использовать команду preprocessFileLineNumbers, для этого вам нужно только обеспечить путь, относительно корневой папки миссии

//Месторасположение скрипта: MISSION_ROOT\test.sqf
call compile preprocessFileLineNumbers "a\b\c\includes.hpp";
//Место поиска: MISSION_ROOT\a\b\c\includes.hpp 

И вы можете подключать файлы из материнских папок, при исполнении скрипта из дочерних:

//Месторасположение скрипта: MISSION_ROOT\a\b\test.sqf
call compile preprocessFileLineNumbers "includes.hpp";
//Место поиска: MISSION_ROOT\includes.hpp 

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

 

Edited by Avi, 24 April 2014 - 16:05.

[Avi]

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

 

ArmA: Вращающиеся оружия
Автор: KillzoneKid
Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

 

Начну с введения англицизма Випон Холдер - от англ. Weapon Holder. Это тяжело перевести, но можно объяснить, холдер - это такая виртуальная коробочка, которая что-то содержит, в нашем случае - Випон, то есть, оружие. Саму коробочку не видно, она может быть и пустой, но туда можно поместить оружие, и его будет видно. А оружие в Арме - это не только оружие, но иногда и даже совсем противоположные вещи. Можно использовать термин "местодержатель", но он мне меньше нравится, к тому же не созвучен с командой. Так вот Випон Холдеры используются, чтобы "хранить" или "держать" в них мелкие объекты, такие как оружие, магазины и другие предметы, которые обычно можно найти у игрока. К випон холдерам добавляются пользовательские действия (addAction - об этом скоро отдельный урок), и их содержимое может быть просмотрено тем же образом, что и содержимое ящика или инвентаря игрока или трупа. Если в один Випон Холдер добавлено несколько предметов, то отображаться они будут как разбросанные вокруг.

 

В Арме второй такой объект, как Випон Холдер так и назывался - WeaponHolder. В Арме третьей же есть по меньшей мере два разных объекта Випон Холдера, это по крайней мере те, о которых мне известно. Один называется GroundWeaponHolder, а другой - это WeaponHolderSimulated. Разница в том, что симулированный Випон Холдер - это типа такой объект, на который распространяется действие окружающей среды. Если вы поместите симулированный випон холдер на какой-то высоте над землёй, то он упадёт под действием силы притяжения. "Приземлённый" випон холдер (GroundWeaponHolder), при этих же условиях, будет висеть в воздухе. И ещё меня терзают смутные сомнения, что симулированный випон холдер чаще синхронизируется по сети.

 

 

Заставить випон холдер вращаться довольно просто. Поскольку это объект, то вы можете указать его направление командой setDir. Но помните, что если поместить несколько объектов в один випон холдер, то объекты будут разбросаны вокруг? Это означает, что предмет, который вы поместили в випон холдер, скорее всего не попадёт в центр вращения випон холдера. В этом случае, возможно легче будет прикрепить випон холдер к другому объекту, отцентровать его по объекту, и вращать уже этот объект, а не випон холдер. В примере таким опорным объектом является баночка ред булла.

 

 

Разумеется, такой объект нужно потом скрыть, или, возможно, сразу использовать невидимый объект. Кроме того, випон холдер нужно ещё повернуть, поскольку по-умолчанию он горизонтальный. Код, представленный ниже - это лишь пример для ознакомления, он спавнит FN 2000, и вращает его 10 секунд, преед тем, как удалить.

fnc_pwrotate = {
    private ["_turntable","_holder","_time","_dir"];
    _turntable = createVehicle [
        "Land_Can_V3_F",
        _this select 0,
        [],
        0, 
        "CAN_COLLIDE"
    ];
    _turntable hideObject true;
    _holder = createVehicle [
        "WeaponHolderSimulated",
        _this select 0,
        [],
        0, 
        "CAN_COLLIDE"
    ];
    _holder addWeaponCargoGlobal [_this select 1, 1];
    _holder attachTo [_turntable, [0,-0.63,0.7]];
    _holder setVectorDirAndUp [[0,0,1],[0,-1,0]];
    _time = time + 10;
    _dir = getDir _turntable;
    waitUntil {
        _dir = _dir + (
            if (_dir > 360) then [{-360},{3}]
        );
        _turntable setDir _dir;
        time > _time
    };
    deleteVehicle _holder;
    deleteVehicle _turntable;
}; 

А спавнить это безобразие (а надо именно спавнить (spawn), а не вызывать (call), будем вот так:

_null = [
    player modelToWorld [0,2,0],
    "arifle_Mk20_ACO_pointer_F"
] spawn fnc_pwrotate; 

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

 

Edited by Avi, 24 April 2014 - 16:11.

[Avi]

Сначала я не обращал внимания на вот эту тему: http://arma3.ru/foru...vit-v-inventar/ , потому что думал, да нафига вообще эти сложности, и кому это может быть нужно. После, товарищ SteelRat контактировал со мной через личку. Я провёл собственные исследования, и пришёл к выводу, что в данный момент единственное решение - это заставить бойца выкидывать неполный магазин с помощью действия dropMagazine. Даже проверил дома, уже собирался запостить скрипт. Но, решил связаться с Killzone_Kid'ом, и он меня заверил, что "прямой команды нет, и ведутся переговоры с БИСами, чтобы сделали, но есть забавный костыль, и завтра же он напишет, как это сделать". И вот, я дождался "завтра" ... костыль оказался в спаме цивила, и использовании команды dropMagazine.

 

Тут я должен кое-что заявить, ранее я писал хоть и от лица Killzone_Kid'а, но в третьем лице. Тут же я уже позабыл об этом и делал как перевод. Поэтому, тут получилась дикая смесь первого и третьего лица. Но везде, где я выкладываю именно мое (Avi) мнение, я подписал это в скобках. Простите меня - я не успел поправить текст, а время поджимает. Поэтому вы видите это заявление.

 

 

ArmA Scripting Tutorials: addMagazineAmmoCargoGlobal
Автор: KillzoneKid
Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

 

 

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

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

 обсуждали, что надо бы сделать ТОП-10 самых бесполезных команд в арме чисто чтобы поржать. Кстати, если у вас есть идеи, то можете постить их в коммантах к данной теме в блоге автора (Киллзон Кида), ну или прислать мне в личку (Ави) : )

 

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

 

Не так давно я сделал

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

о том как найти смещение центра масс у техники, потому что, не смотря на то, что есть команда setCenterOfMass, нет команды getCenterOfMass. Так вот, это пофиксили! Это очень приятно осознавать, что БИСы слушают, что им говорят и что-то делают. Ещё кое-какие команды, например

getFOV

​, которая бы просто возвращала занчение Field Of View (ширину обзора) клиента или даже

vehicleLights

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

 

Ещё одной такой командой является та, что позволяла бы положить в контейнер магазин с заранее указанным числом патронов. Вы просто не можете заполнить ящик магазинами с разным числом патронов. Команда addMagazine позволяет добавить магазин с определённым числом патронов, но только в инвентарь персонажа, бойца.  Недавно эта команда начала принимать глобальные аргументы, т.е. вы можете использовать её на стороне сервера и раздавать магазины с определённым числом патронов клиентам. Уже что-то. И, наверное, лучшим способом было бы расширить область применения этой команды и на контейнеры (ящики, и т.п.) Или может быть добавить третий параметр в команду addMagazineCargoGlobal, который указывал бы, какое количество патронов должно быть в добавляемом магазине?

 

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

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

 - это БИСовский разработчик, который занимается всем этим волшебством, связанным с инвентарями. А сейчас же я принял челлендж сделать это в текущей версии игры. Это уродливо и забавно одновременно, но зато работает! Ниже представлено видео, в котором я добавляю 4 магазина в 300 ящиков и каждый раз в этих магазинах разное количество патронов. Видно поднимающихся на ящиках цивилов? Это можно поправить, а в данной версии это специально оставлено, чтобы показать принцип работы.

 

 

Вот как это сделано: создаётся цивил, ему даётся один магазин с определённым количеством патронов, потому что мы можем это сделать командой addMagazine. Потом цивил выбрасывает этот магазин в ящик, с помощью action "PutMagazine" (я - Avi, делал с помощью action "dropMagazine", и не испытвал проблем, с удалёнными контейнерами, сегодня ещё поиграюсь на эту тему). Поскольку вы не можете указать, какой именно магазин положить в ящик, приходится класть их по-одному. Звучит просто? Ну давайте, попробуйте.

 

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

 

А вот функция, которая заполняет контейнеры:

KK_fnc_addMagazineAmmoCargoGlobal = {
    _crate = _this select 0;
    _gr = createGroup civilian;
    _bob = _gr createUnit [
        "C_man_1",
        position _crate,
        [],
        0,
        "CAN_COLLIDE"
    ];
    _bob disableCollisionWith _crate;
    _bob allowDamage false;
    _bob addEventHandler ["Put", {
        _this select 0 setVariable ["ok", true];
    }];
    _bob disableAI "ANIM";
    _bob switchMove "amovppnemstpsnonwnondnon";
    {
        _bob addMagazine _x;
        _bob action ["PutMagazine", _crate, _x select 0];
        _bob setVariable ["ok", false];
        waitUntil {_bob getVariable "ok"};
    } forEach (_this select 1);
    deleteVehicle _bob;
    deleteGroup _gr;
}; 

А вот отрезочек кода, который я использовал в видео:

player addAction ["RANDOM AMMO CRATE FILL", {
    for "_i" from 1 to 300 do {
        _box = "Box_NATO_Ammo_F" createVehicle position player;
        clearMagazineCargoGlobal _box;
        [_box,[
            ["30Rnd_65x39_caseless_mag", random 30],
            ["7Rnd_408_Mag", random 7],
            ["16Rnd_9x21_Mag", random 16],
            ["30Rnd_556x45_Stanag_Tracer_Green", random 30]
        ]] spawn KK_fnc_addMagazineAmmoCargoGlobal;
    }
}];

Надеюсь, вам уже очевидно, что функцию надо спавнить, а не вызывать (spawn), поскольку мы используем команды приостанова скрипта, когда нам надо заполнить несколько ящиков. И цикл тоже надо именно спавнить. Это работает в Мультиплеере, и если вы запустите это на стороне сервера, цивил появится стоящим, но всё в порядке, потому что на сервере он лежит, а лёжа, кстати, он заполняет ящики чуточку быстрее. Как вы показано на видео, 300 ящиков, по 4 магазина в каждый, заполняются примерно за 12 секунд. Это, примерно, 100 магазинов в секунду. Если вы хотите заполнить однотипными магазинами с разным количеством патронов одну коробку, то всё может оказаться медленнее.

 

И вот ещё на что стоит обратить внимание. В скрипт передаются и магазины, которыми заполнять, и контейнеры, которые надо заполнять. Это довольно просто, если вы заполняете ящик или грузовой отсек машины, но если вы хотите заполнить WeaponHolder, вам следует принимать во внимание, что вам надо положить что-нибудь внутрь WeaponHolder'а сразу же после его создания, иначе он удалится. У персонажа помещение чего-нибудь в випон холдер занимает определённое время, поэтому, вновь созданный WeaponHolder будет удалён ещё до того, как вы им воспользуетесь. И если он удалён, то игрок создаст новый дефолтный WeaponHolder, но обработчик событий "Put" не сработает, и, поэтому, ничего не заработает. В общем, просто убедитесь, что в WeaponHolder'е что-то есть, когда вы передаёте его в функцию.

 

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

 

ОБНОВЛЕНИЕ:

Недавно была добавлена новая команда hideObjectGlobal, которую можно использовать, чтобы скрыть товарища, раскладывающего магазины по коробкам (того самого _bob). Но, если вы решите сделать это, вам надо кое-что знать. Команда выполняется только на сервере, поэтому, скрипт наполнения коробок надо запускать на стороне сервера. Если вы одновременно создаёте много ящиков, некоторые из hideObjectGlobal _bob; просто не сработают, как и заполнение некоторых ящиков. Но, если вы хотите создать небольшое количество кастомно заполненных ящиков, этот способ выглядит весьма симпатично.

 

 

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

 

Костыль с невидимым Бобби, раскладывающим неполные магазины по ящикам, не нужен, есть костыль получше. Можно использовать Logic как класс виртуального юнита в качестве базы для изменения кол-ва патронов. Беда в том, что нельзя просто взять и добавить магазин к Logic командой addMagazine.

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

А, и самое главное, помните, что вы должны спавнить (spawn) или экзекВМить (execVM) функцию:

KK_fnc_addMagazineAmmoCargoGlobal = {
    _gr = createGroup sideLogic;
    _lg = _gr createUnit [
        "Logic",
        [0,0,0],
        [],
        0,
        "NONE"
    ];
    _lg addUniform "U_Rangemaster";
    {   
        _lg addMagazine _x;
        _lg action [
            "PutMagazine",
            _this select 0,
            _x select 0
        ];
        waitUntil {
            magazines _lg isEqualTo []
        };
    } forEach (_this select 1);
    deleteVehicle _lg;
    deleteGroup _gr;
};

 

 

Edited by Avi, 24 April 2014 - 16:10.

[Avi]

 

ArmA Scripting Tutorials: выкрутасы с addAction
Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

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

 

Не так давно KK делал довольно серьёзную чистку на страничке в BIKI,

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

 

 

Вот, кстати, кусок кода для красного ветролёта, а остальное - то же самое, просто используются другие цвета:

player addAction [
    "<img 
        size='5' 
        color='#ee0000' 
        shadow='2' 
        image='\A3\Air_F\Heli_Light_01\Data\UI\Map_Heli_Light_01_CA.paa'
    />",
    {
        _heli = createVehicle [
            "B_Heli_Transport_01_F",
            player modelToWorld [0,10,0],
            [],
            0,
            "CAN_COLLIDE"
        ];
        _heli setDir (direction player - 90);
        _heli setVectorUp surfaceNormal position _heli;
        _heli setObjectTexture [0, "#(rgb,8,8,3)color(0.5,0,0,1)"];
        _heli setObjectTexture [1, "#(rgb,8,8,3)color(0.5,0,0,1)"];
    }
];

Как видите, ничего сложного, никаких заковырок

 

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

 

[Avi]

 

ArmA Scripting Tutorials: выкрутасы с addAction, версия 2
Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

Продолжаем разговор про выкрутасы с addAction. Восьмой элемент в массиве параметров addAction - это указание условия. Этот элемент обязан возвращать true, чтобы действие, которое вы добавляете появилось в меню. По-умолчанию, этот параметр всегда true. Это условие проверяется во время каждой прорисовки кадра, но есть определённые правила, когда оно должно проверяться. Вы должны находиться не далее, чем в 15 метрах от объекта, к которому вы добавили это действие, и вы должны смотреть на этот объект. Если эти два условия выполнены, то скрипт проверки условия будет выполняться при прорисовке каждого фрейма, пока вы достаточно близко к объекту и смотрите на него.

 

Если вы добавите действие к player'у - то есть, к игроку, к себе, то вы, очевидно, всегда достаточно близко к себе, и, так уж получилось, что и смотрите вы тоже на себя (с точки зрения Армы), поэтому, условие будет проверяться каждый фрейм постоянно. Помните об этом, когда добавляете действия к игроку (player), чтобы избежать ненужных нагрузок на CPU. Итак, пока ничего нового, чего же тут такого полезного?

 

А тут имеется огромный потенциал. Вы можете строить системы взаимодействия игроков с окружающими объектами при минимальных затратах. Добавляя действия к объектам, вы получаете возможность исполнять скрипты только когда вы достаточно близко к объекту, и ни чуточки не раньше этого. Например, вы можете создать триггер, прикрепить его к объекту, и заставить отслеживать игрока. Но это не так эффективно, как использование addAction. Конечно, вы можете просто запустить while-цикл с использованием приостанова с помощью sleep, и запускать команду nearObjects с определённым радиусом - но это ужасающе ужасная ужасность, а не решение.

 

Есть и ещё великолепных фич, связанных с этим методом: Действие, которое вы прикрепите к юниту, будет игнорироваться, когда этот юнит в машине; одновременно исполняется только одно условие, т.е. если у вас в достаточной близи есть два юнита, и вы смотрите на обоих, проверяться будет условие только у одного юнита. Вот тут KK сделал пару скриптов, один - на отображение имени над черепами голов бойцов, а другой - то же самое, но для машин с бойцами. И оба решения, хотя и выглядят не лучшим образом, зато невероятно эффективны.

 

 

Итак, как же конструируются такие вещи? Для начала вы можете заполнить первые 7 параметров команды addAction чем угодно, конкретные значения не важны - мы всё-равно не собираемся их выводить. Затем, восьмой параметр, код должен вернуть false, чтобы действие не появлялось в меню, поэтому, последняя строка всегда должна быть false. Обратите внимание ещё на то, что хотя вы и можете добавлять действия к многим объектам, в Раме третьей вы не можете, например, добавлять действия к животным. И это, на самом деле, сделано специально.

 

Доказательство концепции номер раз (добавление тэгов юнитам):

{
    _x setVariable ["tag", _x addAction ["", "", "", 0, false, false, "", "
        if (!alive _target) exitWith {
            _target removeAction (_target getVariable 'tag');
        };
        _dist = (_this distance _target) / 15;
        _color = getArray (configFile/'CfgInGameUI'/'SideColors'/call {
            if (playerSide getFriend side _target < 0.5) then [
                {'colorEnemy'},
                {'colorFriendly'}
            ]
        });
        _color set [3, 1 - _dist];
        drawIcon3D [
            '',
            _color,
            [
                visiblePosition _target select 0,
                visiblePosition _target select 1,
                (visiblePosition _target select 2) + 
                ((_target modelToWorld (
                    _target selectionPosition 'head'
                )) select 2) + 0.4 + _dist / 1.5
            ],
            0,
            0,
            0,
            name _target,
            2,
            0.03,
            'PuristaMedium'
        ];
        false
    "]];
} forEach (allUnits - [player]); 

Доказательство второй концепции (Добавление тегов машинкам):

{
    _x setVariable ["tag", _x addAction ["", "", "", 0, false, false, "", "
        if (!alive _target) exitWith {
            _target removeAction (_target getVariable 'tag');
        };
        if (
            cameraView != 'EXTERNAL' && 
            {_target == vehicle _this}
        ) exitWith {};
        _crew = {alive _x} count crew _target;
        if (_crew == 0) exitWith {};
        _color = getArray (configFile/'CfgInGameUI'/'SideColors'/call {
            if (side _target getFriend playerSide < 0.5) then [
                {'colorEnemy'},
                {'colorFriendly'}
            ]
        });
        _color set [3, 1 - (_this distance _target) / 15];
        drawIcon3D [
            '',
            _color,
            [
                visiblePosition _target select 0,
                visiblePosition _target select 1,
                (visiblePosition _target select 2) + 
                (boundingBox _target select 1 select 2) * 1.5
            ],
            0,
            0,
            0,
            name (crew _target select 0) + (
                if (_crew > 1) then [
                    {format [' + %1', _crew - 1]},
                    {''}
                ]
            ),
            2,
            0.04,
            'PuristaMedium'
        ];
        false
    "]];
} forEach vehicles; 

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

 

Edited by Avi, 24 April 2014 - 16:12.

[Avi]

 

ArmA Scripting Tutorials: Триггеры

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

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

 

Итак, что же такое триггер? Ну, в общем, это примерно как "выключатель света", к которому приделано какое-то условие. Когда условие удовлетворено, то есть true, то триггер ВКЛЮЧАЕТСЯ или ВЫКЛЮЧАЕТСЯ. Некоторые триггеры можно переключать туда-сюда, другие - нельзя. Это зависит от настроек триггера. Вот одно можно сказать точно - если триггер переключился (был активирован), потому что условие его сработки было удовлетворено, он сделает это лишь однажды, даже если условие выполнялось несколько раз. Давайте взглянем вот на этот пример скрипта:

while {true} do {
    if (call conditionStatement) then {
        if (!triggerActivated trigger) then {
            call onActivationStatement;
        };
    } else {
        if (triggerActivated trigger) then {
            call onDeactivationStatement;
        };
    };
    sleep 0.5;
};

Триггер с повторяемой активацией работает прямо как вот этот вот код, прямо над этим параграфом. conditionStatement, onActivationStatement и onDeactivationStatement - это некие гипотетические функции, которые, в данном случае, замещают реальные операторы установки триггеров. Возможно, вы заметили, что triggerActivated - это реальная команда Армы. И это очень полезная команда в Арме, которая показывает текущее состояние вашего триггера.

 

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

 

Как избежать такого отстоя? Делайте условия проверки красивыми и короткими. Не лишним будет использовать "Ленивую проверку условий" (смотрите урок на эту тему). Но самое важное - убедитесь, что триггер правильно установлен для решения ваших задач. Полсекунды - это вечность, по сравнению со скоростью исполнения скриптов, поэтому, у вас есть возможность установить много триггеров.

 

Ок, а теперь к самой мякотке. Триггер - это класс "EmptyDetector", определённый внутри класса CfgNonAIVehicles. А это означает, что его можно прикреплять к другим объектам с помощью команды attachTo. Это может быть весьма полезно, если вам надо прикрепить триггер к движущемуся объекту. А ещё триггеры можно удалять с помощью команды deleteVehicle. Давайте же создадим триггер:

tr = createTrigger ["EmptyDetector", position player]; 

А теперь давайте посмотрим, что за хрень мы создали, с помощью вот этого куска кода:

hint str [
    tr,
    triggerType tr,
    triggerArea tr,
    triggerActivation tr,
    triggerStatements tr,
    triggerTimeout tr,
    triggerActivated tr,
    list tr,
    triggerAttachedVehicle tr
]; 

А вот и результат:

[
    163994: <no shape>,         //trigger object
    "NONE",                     //trigger type
    [50,50,0,false],            //trigger area
    ["NONE","PRESENT",true],    //trigger activation
    ["this","",""],             //trigger statements
    [0,0,0,true],               //trigger timeout
    false,                      //trigger state
    [],                         //trigger list
    <NULL-object>               //trigger attachement
]

• trigger object - Объект триггера. Когда вы создаёте триггер, вы получаете ссылку на созданный триггер, как на объект, и эту ссылку вы можете позже использовать в скриптах. И вы можете получить ссылку на этот объект прямо внутри условий триггера, с помощью специальной переменной thisTrigger
• trigger type - Тип триггера. Вы можете настроить триггер так, чтобы он выполнял дополнительные действия, кроме тех, что определены в onActivationStatement, например, можете закончить миссию, установив тип триггера как "END1" (конечно, вы можете закончить миссию и напрямую в условии onActivationStatement, с помощью команды endMission). Тип нашего триггера установлен как "NONE", это означает, что никаких дополнительных действий производиться не будет. Для установки этого параметра имеется специальная команда setTriggerType.
• trigger area - зона триггера. Вы можете определить форму, размер и ориентацию зоны детектирования триггера. Форма задаётся булевым типом данных: false - эллиптическая форма, true - прямоугольная форма. Первые два числа - это ширина и высота. Одинаковые числа дадут круг или квадрат. Третье число - это угол, по которому ориентирован триггер. В нашем случае, зона детектирования - это круг, диаметром 50 метров, с центром, расположенным в точке триггера. Изменяется командой setTriggerArea
• trigger activation - активация триггера. Тут определяется кто или что может активировать триггер, и при каких условиях. Если триггер детектирует, что условие активации исполнено в зоне детектирования, он устанавливает специальную переменную this в значение true. Но само по себе это не активирует триггер. Триггер активируется только если его conditionStatement возвращает true, а это не то же самое, что критерий активации триггера, возвращающий true. Поэтому, специальная переменная this должна быть передана в conditionStatement триггера. И только когда this имеет значение true, триггер срабатывает. Ели оказывается, что ничего не включает наш триггер в данный момент, то специальная переменная this возвращает значение false. Булевым типом указывается, может ли триггер быть повтроно активирован или нет. В нашем случае - true. Команда для установки этого параметра - setTriggerActivation
• trigger statements - условия триггера. Это внутренняя работа триггера - conditionStatement, onActivationStatement и onDeactivationStatement. conditionStatement проверяется каждые полсекунды независимо ни от чего. Если вы создали триггер, то эта штука уже проверяется каждые полсекунды. Что вы засунете в это условие - это ваше дело. По-умолчанию, как вы видите из вышеприведённого примера, специальная переменная this (результат активации триггера, описанной выше) уже содержится в условии триггера conditionStatement. onActivationStatement будет исполняться только когда conditionStatement вернёт true и только если триггер ещё не активирован (см. пример в начале статьи). Если триггер установлен так, что позволена повторная активация триггера, то onDeactivationStatement будет исполнено, когда conditionStatement вернёт false. После этого триггер возвращается в начальное состояние и может быть активирован снова. Команда для установки этого параметра - setTriggetStatements
• trigger timeout - таймаут триггера. Это задержка между тем как conditionStatement установлено в true и тем, как триггер выполнит onActivationStatement. Первые три числа - это значения задержки min mid и max, в случае, если вам нужна некоторая рандомность. Булевым типом задаётся, может быть эта задержка отменена или нет. Если это условие true и при этом, во время этой задержки conditionStatement возвращает false, отсчёт отменяется и onActivationStatement не выполняется. Наш триггер настроен на немедленное исполнение. Команда для изменения этого параметра - setTriggerTimeout
• trigger state - состояние триггера. Когда триггер активирован, этот параметр выдаёт true. Наш триггер ещё не активирован
• trigger list - список триггера. Это список всех объектов, которые удовлетворяют критериям, указанным в активации триггера. Тут надо немного объяснить: если этот список не пуст, специальная переменная this принимает значение true. Изнутри выражения триггера этот список можно получить с помощью специальной переменной thisList.
• trigger attachment - прикрепление триггера. Вы можете заставить триггер следить за чем-нибудь, например, за одним юнитом. Триггеры выполняют свои условия на том компе, на котором они установлены. Это делает их идеальными для детектирвоания того, находится ли игрок внутри зоны детектирования, и подобных вещей. На данный момент мы не приказывали триггеру следить за чем-нибудь. Если бы мы прикрепили триггер к технике (например, к такой технике, как игрок - player), активация триггера изменилась бы, соответственно с "NONE" на "VECHICLE". Команда для изменения этого параметра - triggerAttachVehicle.

 

Как это использовать на практике? Акеюшки, сейчас... Простейший спосов - это создать взаимодействие между игроком (player) и объектом. Как вы уже знаете, в Арме 3 вы уже не можете прикреплять действия к животным, это связано с какими-то там оптимизациями. Но к игроку вы вполне в состоянии прикреплять действия. Допустим, вы убили животинку и вам нужно выпотрошить тушку. ВЫ можете прикрепить триггер к животному, когда оно умрёт, и активируется этот триггер когда вы, игрок (player) будете близко к нему. А затем, в свою очередь, уже триггер добавить действие "выпотрошить" к вам, к игроку (player).

_sheep1 = createAgent [
    "Sheep_random_F",
    position player,
    [],
    0,
    "NONE"
];
_sheep1 addEventHandler ["Killed", {
    _tr1 = createTrigger [
        "EmptyDetector",
        position (_this select 0)
    ];
    _tr1 setTriggerArea [1.5,1.5,0,false];
    _tr1 setTriggerStatements [
        "this",
        "actionGutID = player addAction [
            'Gut the sucker!',
            {
                hint 'Your Code Goes Here';
                player removeAction actionGutID;
                deleteVehicle (_this select 3);
                player playActionNow 'Medic'
            },
            thisTrigger,
            10,
            true,
            true
        ]",
        "player removeAction actionGutID"
    ];
    _tr1 triggerAttachVehicle [player];
}];

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

 

Или может быть вы хотите детектировать, не едет ли машина по дороге, и причинять ей урон, когда она съедет с дороги? В  этот раз мы можем создать триггер где угодно, поскольку мы не собираемся использовать его область детектирования. Вместо этого мы будем передавать команду isOnRoad в поле триггера conditionStatement:

car1 = "C_SUV_01_F" createVehicle position player;
_tr1 = createTrigger ["EmptyDetector", [0,0,0]];
_tr1 setTriggerStatements [
    "!isOnRoad position car1",
    "
        car1 setDamage 1;
        deleteVehicle thisTrigger
    ",
    ""
];

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

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

, может быть его даже пофиксят. А, да, не забудьте удалить триггер после того, как всё это закончится. Даже одноразовый триггер, который срабатывает лишь однажды, потом исполняет свой код в onActivationStatement и становится бесполезным всё-равно будет проверять свой conditionStatement каждые полсекунды. Вот вам ещё идея для оптимизации, БИСы!

 

Триггеры проверяются в том порядке, в котором они были добавлены, и выражения в триггерах, таким образом, тоже исполняются в том порядке, в котором были добавлены триггеры. Поэтому, имеет смысл называть триггеры по типа trigger1, trigger2, trigger3 и т.д.  А ещё вы можете установить несколько триггеров и добавить последний триггер, который будет собирать условия со всех триггеров. Поскольку onActivationStatement включается лишь однажды, вы можете спокойно spawn'ить скрипты из триггеров и затем terminate'ить их, когда триггер деактивируется без необходимости проверять выполняется ли уже скрипт или нет.

 

В остальном списке команд есть, например: triggerAttachObject, которая на данный момент

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

, но делалась для того, чтобы следить за статичными объектами. Есть и такие команды как triggerTimeoutCurrent, setEffectCondition, setMusicEffect, setTitleEffect и setSoundEffect, чтобы установить эффекты триггеров при активации, прямо как вы это делаете в редакторе. Думаю, для начала этого более, чем достаточно.

 

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

а к выходу готовятся ещё две статьи по триггерам

 

Edited by Avi, 24 April 2014 - 16:12.

[Avi]

 

ArmA Scripting Tutorials: Триггеры v2

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

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

 

Когда триггер активируется, вы можете задать задержку исполнения onActivationStatement просто установив таймаут триггера командой setTriggerTimeout. Как только заданный таймаут завершается, выражение onActivationStatement запускается. Это нампомнило мне о команде setTimeout на JavaScript'е. В JavaScript'е вы можете передать функцию в эту команду вместе с требуемой задержкой, которая, в свою очередь задаст таймер и задержит на определённое время исполнение функции. Можно ли сделать в SQF? Да без проблем!

 

Нам надо только установить триггер с желаемым таймаутом и сделать так, чтобы он сработал сразу по создании. Для этого вполне достаточно установить conditionStatement этого триггера в true, и триггер подумает, что он сработал (хотя, triggerActivated вернёт true только когда onActivationStatement будет выполнено). Когда мы закончим все эти дела с таймаутами, мы удалим триггер. Вот вам кусок кода, с которым можно поиграться, поисследовать всяко.\

 

• Функция, которая создаёт и возвращает таймаут

KK_fnc_setTimeout = {
    private "_tr";
    _tr = createTrigger [
        "EmptyDetector",
        [0,0,0]
    ];
    _tr setTriggerTimeout [
        _this select 2,
        _this select 2,
        _this select 2,
        false
    ];
    _tr setTriggerStatements [
        "true",
        format [
            "deleteVehicle thisTrigger; %2 call %1", 
            _this select 0,
            _this select 1
        ],
        ""
    ];
    _tr
}; 

• Функция, которая возвращает количество оставшихся секунд

KK_fnc_currentTimeout = {
    if (isNull _this) exitWith {0};
    if (triggerTimeoutCurrent _this < 0) exitWith {
        (triggerTimeout _this) select 0 
    };
    triggerTimeoutCurrent _this
};

• Функция, которая останавливает таймаут во время его работы (возвращает true при удачном останове)

KK_fnc_clearTimeout = {
    if (isNull _this) exitWith {false}; 
    deleteVehicle _this;
    true
};

• Простенький пример функции, которую можно вызывать

fnc_hello = {hint "hello"};

• Активация 10-секундного таймаута

_timeout = [fnc_hello, [], 10] call KK_fnc_setTimeout;

• Запрос оставшегося времени

_remaining = _timeout call KK_fnc_currentTimeout;

• Проверка, активен ли ещё таймаут

_active = !isNull _timeout;

• Останов таймаута

_success = _timeout call KK_fnc_clearTimeout;

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

 

• Функция, которая создаёт и возвращает таймаут

KK_fnc_setInterval = {
    private "_tr";
    _tr = createTrigger [
        "EmptyDetector",
        [0,0,0]
    ];
    _tr setTriggerTimeout [
        _this select 2,
        _this select 2,
        _this select 2,
        false
    ];
    _tr setTriggerStatements [
        "thisTrigger getVariable ['act', true]",
        format [
            "thisTrigger setVariable ['act', false]; %2 call %1", 
            _this select 0,
            _this select 1
        ],
        "thisTrigger setVariable ['act', true]"
    ];
    _tr
};

• Пример того, как можно устанавливать интервал:

fnc_time = {player sidechat str time};
myInterval = [fnc_time, [], 3] call KK_fnc_setInterval;

Продолжаем разговор. Триггеры - вещь не очень точная по своей природе. Если вам нужны точные интервалы, используйте циклы while и выполняйте проверку времени. Триггем будет проверять свой таймаут раз в полсекунды. И из-за этого всегда есть ошибка до полусекунды в каждом таймауте. И это ещё не учитывая то, что после создания, триггеру нужно полсекунды чтобы "ожить". Поэтому, если вы устанавливаете интервал, скажем, 3 секунды, это буквально означает: "проверяй интевал НЕ более чем ПРИМЕРНО один раз в три секунды". Для проверки раз в полсекунды, вы можете передать 0 в качестве параметра таймаута.

 

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

 

 

Это видео выше - демонстрация простого обратного отсчёта, который KK сделал, чтобы продемонстрировать новую команду triggerTimeoutCurrent. Но, но, но триггеры же неточны? Ну, пока триггер проверяет свой собственный таймаут каждые полсекунды, нет никаких причин нам делать то же самое. Мы можем проверять таймаут каждый фрейм, для большей точности, благодаря новой команде. Вот код из видео:

_tr1 = createTrigger ["EmptyDetector", [0,0,0]];
_tr1 setTriggerTimeout [10, 10, 10, false];
_tr1 setTriggerStatements [
    "true",
    "deleteVehicle thisTrigger",
    ""
];
0 = _tr1 spawn {
    waitUntil {triggerTimeoutCurrent _this > 0};
    waitUntil {
        if (floor triggerTimeoutCurrent _this <= 0) exitWith {true};
        hintSilent parseText format [
            "<t size='10' color='#ff0000' shadow='2'>%1</t>",
            floor triggerTimeoutCurrent _this
        ];
        false
    };
    hint "";
    "HelicopterExploSmall" createVehicle position player;
}; 

Кстати, после выпуска этого поста, БИСы кое-что поменяли в работе скриптов, и отстчёт куска кода с видео начнётся не с 10, а с 9.

 

На подходе третья часть по триггерам.

 

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

 

Edited by Avi, 24 April 2014 - 16:12.

[Avi]

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

 

Особенно, если он до этого знакомился с триггерами по материалам на БИСовской ВИКИ, там описание, до определённого момента (до конца января 2014), было неправильным.

 

 

ArmA Scripting Tutorials: Триггеры v3

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

Эта третья часть серии статей про триггеры от KK.

 

Не так давно КК заметил что триггеры, вопреки информации на BIKI (инфу уже подкорректировали), являются глобальными объектами, прямо как любой другой мультиплеерный объект, который вы создаёте с помощью createVehicle. Несколько экспериментов стало ясно, что создание триггера на клиенте оставит сервер с мёртвым триггером, когда клиент разлогинится. Более того, любой, кто присоединится к серверу, получит этот дохлый триггер при синхронизации. Потенциально, это может создать лавинное зафлуживание сети дохлыми триггерами. Поэтому, КК запостил

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

 

А потом

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

 ответил на тикет, объясняя, что так и задумано, так оно и должно быть. Сначала были мысли, типа: "Ну что за ....?" Но потом Карел помог разобраться с вопросами, и теперь можно сказать, что, в общем-то это правильное решение. Вот что понял КК:

• Триггер должен создаваться только на сервере, чтобы не бомбардировать дохлыми триггерами сеть при дисконнектах клиентов
• Триггеры, которые создаются в редакторе (mission.sqm Sensors) определённо создаются только на сервере
• Один серверный триггер может использовать всеми клиентами и сервером
• Вы можете переключать "владение" триггером между клиентами и сервером туда и обратно, и это не влияет на работу триггера у других клиентов
• Триггер всегда становится собственностью сервера, когда клиент отключается от сервера
• Параметры триггера должны настраиваться индивидуально для каждого клиента, если вы делаете настройку с помощью скрипта, поэтому, если вы пожелаете, вы можете сделать так, что один триггер будет вести себя по-разному у разных клиентов.

Сейчас об этом поподробнее.  Когда вы создаёте сетевой объект, вы можете задать локальную переменную в пространстве имён этого объекта: obj setVariable ["myvar", someval]. И эта переменная будет существовать только на том компе, на котором вы выполните команду setVariable, если только вы не захотите сделать её глобальной, задав третий параметр: obj setVariable ["myvar", someval, true]. Думайте о настройке триггера, как о настройке локальной переменной. Настройка триггера, которую вы создадите на одном клиенте существует лишь локально на этой клиентской машине, а сам триггер существует глобально на всех клиентах, подключённых к этому серверу.

 

Итак, если я создам триггер на сервере, а затем выполню команду setTriggerActivation как "WEST" и "PRESENT" у одного клиента, а у другого клиента - как "EAST" и "PRESENT", экземпляр триггера на первом клиенте выполнит выражение при активации когда BLUFOR'овский унит будет в данной области, но у другого клиента сработка триггера не произойдёт, даже если это точно такой же триггер в точно этом же месте. Поэтому, если вы хотите, например, создать триггер, который будет следить за игроком, и вы используете команду triggerAttachVehicle [player] на каждой клиентской машине, экземпляры триггеров на каждом клиенте будут следить за своим игроком.

 

Так чего же в этом решении хорошего? У вас может быть лишь один триггер, ассоциированный с 1 техсредством во всей сети на каждом клиенте, и он будет следить за каждым игроком, а на сервере этот же триггер можно заставить следить за чем-нибудь ещё. Компактно и эффективно. Поскольку триггеры - это объекты типа "EmptyDetector", вы всегда можете узнать, сколько триггеров у вас сейчас есть с помощью команды allMissionObjects "EmptyDetector" и таким образом отслеживать их.

 

А вот настроить триггер с помощью скрипта может быть совсем не просто. Сначала, вам надо убедиться, что вы создаёте триггер только на сервере, затем, вам придётся убедиться, что триггер существует, когда вы будете настраивать параметры триггера у клиентов. В следующем примере, который предполагается использовать в init.sqf, команда waitUntil - это вполне себе обязательное требование, необходимое, если, вдруг серверный init.sqf залагает по какой-нибудь причине:

//добавляем триггер на сервере (на "хостированном" или на выделенном)
if (isServer) then {
    tr = createTrigger ["EmptyDetector", _somePos];
    publicVariable "tr";
};
//настраиваем триггер на каждом клиенте 
if (!isDedicated) then {
    waitUntil {!isNil "tr"};
    tr triggerAttachVehicle [player];
    tr setTriggerStatements [
        "this",
        "hint str player",
        "hint str allMissionObjects 'EmptyDetector'"
    ];
};

Также необходимо упомянуть, что в команды вида triggerXXXX - существуют в дополнение к командам setTriggerXXXX которые возвращают результаты команд установки локальных триггеров. КК отредактировал BIKI страничку по триггерам и добавил заметки на соответствующие командам странички. И, кажется, что и WayPoint'ы работают таким же способом.

 

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

 

Edited by Avi, 24 April 2014 - 16:13.

[Avi]

 

ArmA Scripting Tutorials: Основы написания кода для мультиплеера

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

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

 

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

_myFunction = {
    //доступна только в этом скрипте
};
myFunction = {
    //доступна во всех скриптах (Напилась? Веди себя доступно!)
};

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

 

Один из способов определения myFunction на каждом компе - это использовать широкое вещание. Это можно достаточно просто осуществить с помощью команды publicVariable. Команда publicVariable распространит вашу переменную на каждый комп, подключённый к вашей миссии, кстати, она будет отправлять эту переменную и на компы, которые подключатся уже позже того, как переменная распространится через широкое вещание. Присоединившиеся в процессе клиенты называются JIP (от вражьего Join In Progress). Так вот JIP-ики стопудово получат вашу вещаемую переменную, когда они присоединятся.

myFunction = {
	//доступно только на этом компе
};
publicVariable "myFunction";
//а теперь она доступна на всех компах

А, да! Позвольте мне разлиться мысию по древу и раccказать, что же происходит, когда вы запускаете сервер и подключаетесь к нему. Как правило, у вас есть 3 файла в миссии: mission.sqm, description.ext и init.sqf. Обычно эти файлы PBO-шатся и помещаются в папку MPMissions на выделенном сервере (всё дальнейшее объяснение будет вестись, подразумевая, что вы используете выделенный сервер).

 

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

 

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

 

А сейчас, я позорно признаю, что реально с огромным трудом понял чем друг от дружки отличаются команды isServer и isDedicated и для чего же они служат. Обе команды показывают является ли среда, в которой они запущены сервером или нет. Когда вы хостите миссию, ваш комп становится сервером и команда isServer вернёт значение true, когда она (команда) будет запущена на нём (сервере). Но ваш комп не является выделенным сервером, поэтому isDedicated вернёт false. Кстати, вы легко можете запустить и выделенный сервер на вашем компе и подключиться к нему, поэтому вам может пригодиться мультиплеерная песочница (кстати, скоро будет пост об обновлённой версии). А вот и пример использования isDedicated внутри init.sqf:

if (isDedicated) then {
	//этот кусок кода будет запущен только один раз на выделенном сервере
} else {
	//а этот кусок кода будет запускаться на каждом присоединяющемся клиенте
};

Эту команду используют в тех скриптах, которые будут запускаться и на клиентах и на сервере, навроде init.sqf, mission.sqm и description.ext. Если у вас есть скриптец, который запускается, например, из init.sqf, то этот скрипт будет выполнен и на сервере и на клиенте, и скрипт, вызванный из этого скрипта будет выполнен на сервере и на клиенте, и ... и т.д. Вот для того, чтобы управлять тем, что, где и когда у вас запускается и выполняется, и служит команда isDedicated.

 

Ну и вернёмся к основному вопросу статьи. Как, чёрт его дери, из клиента запустить функцию, которая определена только на сервере? Единственный способ вести "разговор" с сервером - это использование широкого вещания переменных. когда вы посылаете publicVariable из клиента, все, включая сервер, получат её. И есть способ заставить клиент или сервер "слушать" вещательный канал и выполнять заранее определённый код при получении переменной.

 

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

"broadcastVar" addPublicVariableEventHandler {
	_broadcastVarName = _this select 0;
	_broadcastVarValue = _this select 1;
	//тут вы можете всяко надругатьсся над данными
};

А что же теперь делать, если вам надо получить ответ от сервера? Да, в общем-то, то же самое - добавляете обработчик событий на клиенты, и сервер может отвечать тем же способом. В этом случае вы можете воспользоваться командами типа publicVariable, которые лучше подходят для таких задач - publicVariableServer и publicVariableClient. Взгляните на пример использования этих команд в init.sqf. Вы отправляете на сервер два числа, сервер их складывает и отправляет назад:

if (isDedicated) then {
	"packet" addPublicVariableEventHandler {
		_pcid = owner (_this select 1 select 0);
		_nubmer1 = _this select 1 select 1;
		_number2 = _this select 1 select 2;
		_thesum = _number1 + _nubmer2;
		packet = _thesum;
		_pcid publicVariableClient "packet";
	};
} else {
		"packet" addPublicVariableEventHandler {
		_thesum = _this select 1;
	hint str _thesum;
	};
}; 

А теперь давайте разберёмся, что тут происходит. Мы используем команду isDedicated, чтобы гарантировать, что предназначенный серверу код будет исполняться только на сервере, а предназначенный клиентам - только на клиентах, поскольку код, содержащийся в init.sqf исполняется и на клиенте и на сервере. После чего мы используем переменную, которая называется, скажем "packet" как некую тару, в которой мы передаём данные туда и обратно. На стороне сервера мы ожидаем, что "packet" будет массивом вот этакого формата: [player, number1, number2], то есть, имя игрока, и два числа, которые надо сложить. Зачем параметр player? Затем, что команде publicVariableClient надо знать, на какой комп отправлять переменную, а мы можем получить индентификтор владельца того компа из объекта player.

 

После извлечения данных из переменной мы складываем числа и отправляем в широковещательный канал результат их сложения, в той же переменной "packet". Можно тут лишнего не мудрить: обработчик событий не срабатывает на той машине, с которой мы отправляем переменную в широкое вещание. А на клиентской машине мы ожидаем, что "packet" будет числом, потому мы отправляем число. А когда оно приходит мы просто выводим его на экран с помощью hint str. После того, как эти подготовительные шаги сделаны, мы тестируем сие действо, передавая наш "packet" с клиента:

packet = [player, 22, 44];
publicVariableServer "packet"; 

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

 

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

 

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

Первая из двух статей - ЛОКАЛЬНОСТЬ.

 

Edited by Avi, 24 April 2014 - 16:13.

[Avi]

 

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

 

Недавно была добавлена новая команда hideObjectGlobal, которую можно использовать, чтобы скрыть товарища, раскладывающего магазины по коробкам (того самого _bob). Но, если вы решите сделать это, вам надо кое-что знать. Команда выполняется только на сервере, поэтому, скрипт наполнения коробок надо запускать на стороне сервера. Если вы одновременно создаёте много ящиков, некоторые из hideObjectGlobal _bob; просто не сработают, как и заполнение некоторых ящиков. Но, если вы хотите создать небольшое количество кастомно заполненных ящиков, этот способ выглядит весьма симпатично.

 

Edited by Avi, 04 April 2014 - 10:55.

[Avi]

 

ArmA Scripting Tutorials: Локальность

Автор: KillzoneKid

Оригинал: 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

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

Продолжаем разговор™ на тему написания кода для мультиплеера, и продолжаем мы его очень важной для понимания концепцией "локальности" объектов. Итак, несколько моментов для начала...

 

У каждого объекта в игре есть владелец, хозяин (за исключением объектов, интегрированных в карту). Владелец - это подключённый комп. Каждый владелец имеет свой ID (идентификатор). Если владелец, например, сервер его идентификатор владельца (owner id): 1, первый присоединившийся человеческий клиент имеет идентификатор: 3, и т.д.

 

Созданные объекты принадлежат компу, который их создал. Объекты, интегрированные в карту принадлежат одновременно всем и никому, их owner id: 0. Некоторые объекты могут туда-сюда менять владельцев, а другие - вообще не менять. Например, объект player всегда принадлежит компу того человека, которые им управляет. А техника, например, машинка может принадлежать любому компу, в зависимости от того, кто за рулём.

 

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

 

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

 

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

 

 Аргументы команды должны быть локальными. Если аргумент - это мой персонаж, я могу запустить команду только на моём компе, потому что на остальных компах мой персонаж УДАЛЁННЫЙ (в смысле, он далеко- REMOTE), то команда не сработает

 

 Команда принимает глобальные аргументы. Если аргумент - машинка, мне не надо искать, кто её овладевает, я могу сослаться на неё откуда угодно.

 

 Эффект от исполнения команды локальный, т.е. ощущается только на компе, на котором была исполнена эта команда, и не будет вещаться в сеть.

 

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

 

Давайте вернёмся к команде 

Пожалуйста Войдите или Зарегистрируйтесь чтобы увидеть скрытое содержание

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

 

Чтобы узнать, является ли объект локальным на том компе, на котором вы запускаете скрипт, вы можете использовать команду local. Результат будет true, если проверяемый объект принадлежит компу, на котором выполняется команда. Локальность объекта также становится очевидной при конвертировании объекта в строку. Не локальные объекты будут содержать суффикс REMOTE. Для демонстрации можно "хинтануть" объект, представляющий вашего персонажика на сервере. Поскольку объект player всегда локальный к тому компу, с которого им управляют, серверный вариант этого объекта будет содержать суффикс REMOTE:

 

 

В Арме 3 есть удобный обработчик событий "local", который сработает как только объект, к которому прицеплен обработчик событий, меняет свою локальность. Например, когда вы спавните машину на сервере, а затем садитесь на место водителя. Овладевание машинки сменится с сервера на ваш комп, машинка станет локальной для вашего компа и обработчик событий сработает.

 

Обработчик событий "local" использовался в отдоне DayZ для Армы 2, чтобы отслеживать клиентских зомбей, чтобы заставить их оставаться на сервере когда клиент отсоединяется. Эта попытка была потом похерена создателем, но на частном сервере DayZ, конкретно на том, для которого писал KK, это было оставлено и выполняло свою задачу.

 

И релоггеры - те, кто злоупотреблял Alt+F4 для того, чтобы сбежать от зомбей, получали премилейший подарок, когда логинились снова в окружении сагренных зомбаков, которые терпеливо ждали возвращения героя на сервер. 

 

Ну, как бы то ни было, правильная процедура для определения овладевания объектом должна быть таковой:

1. Находите, принадлежит ли объект вам, с помощью команды local
2. Если он не локальный, ищете того, кто владеет этот объект
3. Шлёте запрос серверу с подвопросным объектом
4. Проверяете, не является ли он локальным для сервера
5. Если и сервер не овладевает этот объект, вы спрашиваете сервер, кто в данный момент владеет интересующий вас объект, используя команду owner на сервере.
6. Выполняете интересующую вас команду на нужном компе - на том самом, который владеет интересующий вас объект

Вот как будет выглядеть код, если мы хотим сделать исполнение команды setFuel глобальным:

//init.sqf
KK_fnc_setFuel = {
	private ["_veh","_fuel"];
	_veh = _this select 0;
	_fuel = _this select 1;
	if (local _veh) then {
		_veh setFuel _fuel;
	} else {
		PVsetFuel = _this;
		if (isDedicated) then{
			(owner _veh) publicVariableClient "PVsetFuel";
		} else {
			publicVariableServer "PVsetFuel";
		};
	};
};
"PVsetFuel" addPublicVariableEventhandler {
	(_this select 1) call KK_fnc_setFuel;
};

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

//init.sqf
KK_fnc_setFuel = {
	private ["_veh","_fuel"];
	_veh = _this select 0;
	_fuel = _this select 1;
	if (local _veh) then {
		_veh setFuel _fuel;
	} else {
		PVsetFuel = _this;
		publicVariable "PVsetFuel";
	};
};
"PVsetFuel" addPublicVariableEventhandler {
	_veh = _this select 1 select 0;
	_fuel = this select 1 select 1;
	if (local _veh) then {
		_veh setFuel _fuel;
	}
}; 

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

[vehicles select 0, 0.5] call KK_fnc_setFuel; 

Пользуйтесь наздоровье!

KK

 

Edited by Avi, 24 April 2014 - 16:10.