“Polní” hrátky v Arma

 

Základní příkazy

Pole se tvoří velmi snadno. Všechny objekty, co jsou zapsány mezi
hranatými závorkami jsou součástí pole.

_pole = [jirka, honza, marek, tonda];

K jednotlivým prvkům pole se přistupuje za pomoci příkaz
select, jehož druhý parametr udává index prvku. Ty jsou
v poli číslovány od nuly. Tudíž pokud chceme vytáhnout třetí
parametr:

_unit = _pole select 2;

Do pole často vkládáme prvky protože s nimi chceme nějak pracovat.
Nejčastěji se používá v kombinaci s příkazem forEach.
Ten spouští předanou funkci a v každém průchodu do ní postupně vkládá
jeden prvek pole za druhým jako parametr _x.

{_x setDammage 0} forEach _pole;

Neméně často potřebujeme vědět velikost pole. Příkaz count, který
toho v enginu zvládá opravdu hodně, nám velikost vrátí.

_pocet_prvku = count _pole;

Pro manipulaci s polem můžeme použít klasické plus a minus.

_pole = _pole + [michal, honza, jakub]; // do pole se přidají tři nové prvky

_pole = _pole - [michal, jakub]; // z pole budou odstraněny prvky michal a jakub

Jenže dle několika měření se pro vkládání jako optimální řešení
hodí využít příkazu set. Ten přijímá jako parametr pole
obsahující dva prvky – index a objekt. A právě na předaný index pole
vloží onen parametr. Pro vložení nového prvku tak využijeme count a set a
měli bychom dosáhnout rychlejšího výsledku na úkor nepatrného snížení
čitelnosti.

_pole set [count _pole,trevor];

Podstata je v tom, že count vrátí velikost pole a index je číslován od
nuly. Tudíž bude prvek zařazen na konec pole.

V dalším příkladu si ukážeme, jak se příkaz set dá použít pro
prohození dvou prvků pole v pořadí.

_pole = [michal, jakub, martin];
// prohodim druhy a treti prvek pole
_pom = _pole select 1;
_pole set [1,_pole select 2];
_pole set [2,_pom];
// pole ted bude [michal, martin, jakub]

Občas může nastat problém, že nám nestačí pracovat jen
s jednoduchými objekty v poli, ale potřebujeme, aby těmito objekty bylo
další pole. Vytváříme tak vícerozměrná pole.

_arr = [
   [1,5,7],
   [2,3,6],
   [4,2,8]
];

K jednotlivým položkám přistupujeme pak postupně, což bude
pochopitelné z dalšího příkladu:

_val = (_arr select 1) select 2; // _val bude obsahovat 6

To byly základní příkazy se kterými byste měli být schopni s polem
pracovat a využívat jeho výhod naplno. Ale práci si lze ještě více
usnadnit či urychlit.

Functions Library

Functions Library v Arma 3 obsahuje některé funkce pro práci s polem, které se vám při práci s pole můžou velmi hodit. Pojďme si je projít.

BIS_fnc_arrayCompare

[[564, "trdlo", true], [564, "trdlo", true]] call BIS_fnc_arrayCompare; // true
[[564, "trdlo", true], [564, "trdlo", false]] call BIS_fnc_arrayCompare; // false

BIS_fnc_arrayFindDeep

[[100, 101, 102, 103, 104], 102] call BIS_fnc_arrayFindDeep; // vrátí 102

BIS_fnc_arrayInsert

[[jirka, honza, marek], [michal, martin, tonda], 1] call BIS_fnc_arrayInsert; // vrátí [jirka,michal,martin,tonda,honza,marek]

BIS_fnc_arrayPop

_units = [jirka, honza, michal, martin];
_unit = _units call BIS_fnc_arrayPop;
// _unit bude martin a _units bude obsahovat jen [jirka, honza, michal]

BIS_fnc_arrayPush

[[jirka, honza, michal], martin] call BIS_fnc_arrayPush;
//vrácené pole bude [jirka, honza, michal, martin]

BIS_fnc_arrayPushStack

[[1, 2, 3], [4, 5, 6]] call BIS_fnc_arrayPushStack;
// spojí pole dohromady a vrátí [1,2,3,4,5,6]

BIS_fnc_arrayShift

_arr = [1, 2, 3, 4];
_first = [_arr] call BIS_fnc_arrayShift;
// _first bude obsahovat 1 a _arr bude [2,3,4]

BIS_fnc_arrayUnShift

_arr = [2,3,4];
_arr = [_arr, 1] call BIS_fnc_arrayUnShift;
// _arr bude [1,2,3,4]

Pokud budeme chtít vytáhnout z pole nějaké prvky splňující určitou
podmínku, pak použijeme funkci BIS_fnc_conditionalSelect.

_nad_sto=[[95, 12, 203, 104, 95, 26], {_x > 100}] call BIS_fnc_conditionalSelect;
// _nad_sto bude [203,104]

A pokud chcete najít nejvyšší či nejnižší hodnotu v poli, pak tu
máme funkci BIS_fnc_findExtreme, která dle má dva
paremtry – pole a parametr zda chceme nejnižší (0) či nejvyšší (1)
hodnotu

_arr = [1, 5, 3, 2, 4];
_min = [_arr, 0] call BIS_fnc_findExtreme; // _min bude 1
_max = [_arr, 1] call BIS_fnc_findExtreme; // _min bude 5

Pokud máme zanořené složitější pole a chceme najít na kterém indexu
je hledaný prvek, pak BIS_fnc_findNestedElement je to, co
hledáme. Funkce vrátí výsledek jako pole indexů případného
vícerozměrného pole.

_arr = [ [1,2,3] , 4, [5,jirka,6,7] ];
_indexs = [_arr,jirka] call BIS_fnc_findNestedElement;
// _indexs bude pole [2,1] .. platí tedy, že jirka == (_arr select 2) select 1;

A abychom nemuseli k takovému prvku přistupovat přes selecty, pak
použijeme funkci BIS_fnc_returnNestedElement a výsledky
předchozího hledání.

_jirka = [_arr, _indexs] call BIS_fnc_returnNestedElement;
// _jirka bude skutečně jirka

Takový prvek můžeme případně změnit za pomoci funkce
BIS_fnc_setNestedElement

_arr = [_arr,_indexs,tomas] call BIS_fnc_setNestedElement;

A k odstranění prvku z víceúrovňového pole použijeme
BIS_fnc_removeNestedElement předanému jako druhý parametr
hned po poli.

[_arr, tomas] call BIS_fnc_removeNestedElement; // vrátí[ [1,2,3] , 4, [5,6,7] ]

Pokud mám v poli více číselných hodnot a chci znát největší rozdíl
mezi prvky, pak použijeme funkci BIS_fnc_maxDiffArray

[25, 20, 30, 45, 80] call BIS_fnc_maxDiffArray; // vrátí 60 (protože 80 - 20)

Náhodný index vytáhneme přes BIS_fnc_randomIndex

[100, 200, 300] call BIS_fnc_randomIndex; // vrátí 0,1 nebo 2

Pokud chceme z pole odstranit nějakou jeho část a známe indexy, pak za
pomocí funkce BIS_fnc_removeIndex v parametrech můžeme udat
buď počáteční a koncový index, či výčet indexů, které chceme
odstranit. Z příkladu to snad bude jasné:

[[100, 200, 300, 400, 500], 2] call BIS_fnc_removeIndex; // vrátí [100,200,400,500]
[[100, 200, 300, 400, 500], [0, 2, 3]] call BIS_fnc_removeIndex; // vrátí [200,500]
[[100, 200, 300, 400, 500], 1, 3] call BIS_fnc_removeIndex; // vrátí [100,500]

Pokud chceme získat náhodný prvek pole, pak použijeme
BIS_fnc_selectRandom

[a, b, c] call BIS_fnc_selectRandom; // vrátí a,b nebo c

Další funkcí pro náhodné vytažení je BIS_fnc_selectRandomWeighted.

A na závěr vytažení podpole přes BIS_fnc_subSelect Ten
jako parametr v poli dostává jak zdrojové pole, tak počáteční index a
volitelně i koncový index (záporné číslo se odpočítá od konce).

[[10, 20, 30, 40, 50], 2] call BIS_fnc_subSelect; // vrátí [30,40,50]
[[10, 20, 30, 40, 50], -2] call BIS_fnc_subSelect; // vrátí [40,50]
[[10, 20, 30, 40, 50], 1, 3] call BIS_fnc_subSelect; // vrátí [20,30,40]
[[10, 20, 30, 40, 50], 1, -2] call BIS_fnc_subSelect; // vrátí [20,30]

EDIT:

Doplňuji ještě funkci resize díky níž můžete rychle
zkrátit pole či ho prodloužit o prázdné prvky.

_arr = [10, 20, 30, 40, 50]
_arr resize 3; //[10,20,30]
_arr resize 5; //[10,20,30,<null>,<null>]

Další funkcí je pushBack díky níž můžete rychle přidat do pole nové prvky na konec (která od Arma 3 v1.26 nahrazuje BIS_fnc_arrayPush).

_arr = [10, 20, 30, 40, 50]
_arr pushBack 60; //[10,20,30,40,50,60]

Zajímavou alternativou je pushBackUnique, které ohlídá, zda v poli již prvek neexistuje a vrací případně jeho index. V opačném případě vrací -1.

Novinkou, kterou přinesl update 1.82 je příkaz, označený jako hash, který používá právě znak # a jde o ekvivalent slova select.
Tudíž dnes namísto

_arr = [10,20,30,40,50];
hintSilent format ["Third item is %1",_arr select 2]

můžete napsat

hintSilent format ["Third item is %1",_arr # 2]