LUA - programovací jazyk / LUA - programming language

Lua programovací jazyk.

Jak se Lua využívá? Je těžké se ji naučit?
Lua je programovací jazyk, pomocí kterého se programují všechny moduly, jako je #utility, #mycity, #deathmatch, všechny kmenové hry i Lua kmenový domek, jak napovídá název. V tomto topicu nejen že předám důležité odkazy na rychlý start do učení Lua, ale také tu najdeš můj vlastní tutorial a cvičení, které tě připraví na programování her přímo v TFM.

Jak mohu spustit Lua hru, kterou vytvořím?
Lua můžeš spustit, pokud máš na účtě nasbíráno aspoň 100 sýrů a pouze v kmenovém domku, pokud máš hodnost s povolením "Může načíst mapu (/np kód)". V našem kmenu se můžeš domluvit s kmenovými adminy, aby tvé hodnosti tohle oprávnění dali nebo aby tvůj druhý účet pozvali do kmene Lua programování, který slouží právě na testy s programováním. Lua se spouští v chatu příkazem /lua. Do konzole, která se zobrazí potom vložíš text s Lua kódem a stiskneš Potvrdit. Menší rada, pokud už v konzoli máš nějaký text, můžeš ho jednoduše vymazat ctrl + a, delete.

Pár důležitých odkazů, pokud se chceš naučit Lua.

Lua tutorialy
SkyVaultGames natočil celou sérii tutoriálů, které vás naučí důležité základy pro Lua.
1. epizoda (pro začátečníky): https://www.youtube.com/watch?v=4NKMtazVNe8
2. epizoda (pro začátečníky): https://www.youtube.com/watch?v=HD4vnM3fMDk
3. epizoda (pro pokročilé): https://www.youtube.com/watch?v=nzHIaIgMsY4

Jednoduché video od youtubera Pasieka je také možnost, jak se dostat do základů s Lua.
https://www.youtube.com/watch?v=f-v00iiqFOw

Oficiální stránka Lua: https://www.lua.org
Najdeš tu informace ohledně programovacího jazyka, knihy, dokumentaci a kompletní manuál. Občas je složité se ve všem vyznat.

Programy
Visual Studio Code: https://code.visualstudio.com/
Pro psaní kódu silně doporučuji Visual Studio Code. Je profesionální, srozumitelné, jednoduché na nainstalování a v základu má vše, co potřebuješ.

Fewfre's A801 Tools: https://projects.fewfre.com/a801/tools/toolsapp/downloads.html
Ne, není to virus, i když windows defender tento program nemá moc rád. xD Jedná se o úžasný nástroj, který funguje jako /dressing pro Transformice, Dead Maze, Nekodancer i Fortoresse, ale dokáže toho mnohem víc. Za mě nejužitečnější funkce je možnost uložit si libovolně velký obrázek jakkoliv oblečené myšky v jakémkoliv snímku jakékoliv animace nebo možnost uložit pouze hlavu pro jednoduché NPC dialogy.

Pomoc při programování v TFM
Module FAQ and Documentation: https://atelier801.com/topic?f=6&t=781139
Najdeš zde vysvětlení pro většinu TFM funkcí, návod jak používat tento programovací jazyk, kódy barev, id kláves, oblečení, animací a dalších věcí nebo další důležité odkazy. Navíc se v topicu můžeš ptát na otázky ohledně programování na TFM.

Lua Tree: https://atelier801.com/topic?f=5&t=451587
Aktualizovanější verzi všeho, co je v tomto odkazu najdeš přímo v TFM, pokud napíšeš přikaz /luahelp do chatu. Najdeš zde podrobnější vysvětlení všeho, co můžeš používat při programování v TFM včetně seznamu TFM funkcí i s vysvětlením, jako v předešlém odkazu.

Script Requests: https://atelier801.com/topic?f=6&t=462959
Zde si lidé navzájem pomáhají s programováním v TFM. Navíc v topicu najdeš spoustu užitečných kousků kódu, ze kterých se můžeš učit základy. Jen se ujisti podle komentářů, zda daný Lua kód funguje správně.

Miceditor: https://entibo.github.io/miceditor/
Pokud chceš vytvořit minihru, neobejdeš se bez vytváření map. K tomu ti může hodně pomoct miceditor, který je značně příjemnější pro výrobu TFM map.

Module Image Upload Center: https://atelier801.com/topic?f=6&t=893819
Chceš ve svých hrát používat vlastní obrázky? Můžeš je podle instrukcí nahrát v tomhle topicu a někdo z module memberů ti nahraje a nachystá obrázek k použití.

List of Useful Module Images: https://atelier801.com/topic?f=801101&t=938262
Pokud chceš najít rychle nějaký obrázek, který by se ti hodil do tvé hry, můžeš zkusit tento topic!

Hufův tutorial na programování her pro TFM.

Co v tutorialu najdu?
Dřív, než se začneš topit v různých návodech, knihovnách, webovkách a youtube videích, můžeš si jednoduše vyzkoušet můj tutorial, který tě postupně provede základy do programování a osobním přemýšlením nad tvorbou her! Stačí dodržovat jendotlivé pokyny a dostane se k tobě veškeré info, které potřebuješ. :D Doporučuji si otevřít Visual Studio Code, ať se v něm učíš hned od začátku a jdeme na to!

1. Začneme pěkně od základů.

1.1. Poznámky
Do svého kódu si můžeš psát poznámky, které nic neovlivňují, je to pouhý text, který ti může připomenout, že chceš doprogramovat tohle tam a tohle funguje takhle. Vše,co napíšeš za dvě pomlčky, je poznámka, například:

Code Lua

--já jsem poznámka

Poznámky je také možné psát na více řádků, pokud napíšeš dvě pomlčky a text napíšeš do dvou hranatých závorek, takhle:

Code Lua

1
2
3

--[[já jsem
poznámka
na více řádků]]

1.2. Proměnné
Lua má 3 základní typy hodnot. Číslo, string a boolean.

• Číslo je jakákoliv číselná hodnota včetně záporných a necelých čísel. Desetinná čárka se vždy píše jako tečka. Takže za číslo se považuje například:
100, 0, -6, 0.8, 0.9454, -6, ...

• String je jakýkoliv text. Texty se píšou do " uvozovek. Za text se tedy považuje například:
"ahoj", "jak se máš?", "Vítej, cestovateli, musíš být unavený, odpočiň si u táboráku...", ...

• Boolean je velice jednoduchá hodnota, protože má pouze 2 podoby. Buď je pravda nebo nepravda. K čemu přesně je boolean dobrý si vysvětlíme později. Za boolean se tedy považuje:
true, false.

Proměnnou v kódu vytvoříme tak, že napíšeme libovolný název pro naši proměnnou, rovná se a nakonec hodnotu, které chceme, aby se proměnná rovnala. Tady jsou příklady vytvoření všech třech typů proměnných:

Code Lua

1
2
3
4
5

x = 0.5 --já jsem číslo

y = "ahoj" --já jsem string

z = true --já jsem boolean

Pozor, do názvů proměnných se nikdy nepíše diakritika. Pokud chceš mít víceslovný název proměnné, tak slova neodděluj mezerou, ale podtržítkem. Například x_hodnota = 600

Proměnná se může rovnat i jiné proměnné:

Code Lua

1
2
3

x = 10 --mám hodnotu 10

y = x --mám také hodnotu 10

Hodnotu proměnné můžeš jednoduše změnit tím, že proměnné přiřadíš novou hodnotu:

Code Lua

1
2
3

x = 10 --mám hodnotu 10

x = 50 --teď mám hodnotu 50

Dokonce můžeš měnit i typ hodnoty:

Code Lua

1
2
3
4
5

x = 1 --teď jsem číslo

x = "ahoj" --teď jsem string

x = true --teď jsem boolean

1.3. print()
Print ti vypíše hodnotu do zprávy v #lua chatu, je to úžasný nástroj na testování nejrůznějších věcí a my ho budeme v hojném počtu využívat.

Konečně se dostáváme k prvnímu programování! Slavnostně si můžeš přímo v TFM poprve otevřít Lua konzoli příkazem /lua. Pokud se nic neotevřelo, podívej se znovu úplně na vrch tohoto topicu, jak se spouští Lua. Jako první si vytiskneme string "hello world!". Je to takový rituál pro nováčka, který tímto zdraví nový neprobádaný svět programování! Do konzole tedy napiš tohle a stiskni Potvrdit:

Code Lua

print("hello world!")

Pokud máš vše správně, otevře se ti chat #lua a uvidíš svou první vytisklou zprávu

, gratuluji! :D

1. Mám pro tebe první úkol! Vytiskni tři hodnoty: "Já jsem programátor", -6, false. (Odpovědi si vždy někam zapisuj a potom zkontroluj s řešením. Vždy pokračuj dál ve čtení tutorialu až jakmile splníš úkol. Pokud si úkol splnil špatně, prohlédni si zadání a řešení, pokračuj, jakmile pochopíš, co máš proč špatně.) c:

1. řešení

Print dokáže vytisknout i proměnné, například:

Code Lua

1
2
3

x = -150

print(x)

1.4. Operace s čísly
Přejdeme do jednoduché matematiky. Lua umí 4 základní operace:
• plus +
• mínus -
• násobení *
• dělení /

Operace je velice jednoduché použít, například:

Code Lua

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

x = 10
y = 2

print(x + y) --vytiskne 12
print(x - y) --vytiskne 8
print(x * y) --vytiskne 20
print(x / y) --vytiskne 5

print(x + x + y) --vytiskne 22

z = x * y
print(z) --vytiskne 20

z = z / 2
print(z) --vytiskne 10

Stejně jako v matematice, i v Lua můžeš využívat závorky například pro upřednostnění sčítání před násobením.

Code Lua

1
2
3
4
5

x = 10
y = 2
z = 5

print((y + z) * x) --vytiskne 70

2. Je tu druhý úkol! V kódu jsou tři proměnné x, y a z. V printech doplň proměnné místo otazníků tak, aby každý print vytiskl číslo, které je napsané v poznámce za printem.

Code Lua

1
2
3
4
5
6
7
8
9

x = 2
y = 1
z = 3

print(x + ?) --vytiskne 5
print(? + y) -- vytiskne 3
print((x + ?) * z) --vytiskne 15
print((y - ?) * ?) --vytiskne -4
print(9 / (9 * ?)) --vytiskne 0.5

2. řešení

1.5. Logické operátory
I když jsem říkal, že boolean je velice jednoduchá hodnota, zatajil jsem, že se v ní skrývá něco zajímavého, do čeho se právě ponoříme.
Jak jsem říkal, boolean může být buď pravda nebo nepravda. Ovšem pravda a nepravda jde díky logickým operátorům získat různými způsoby. Vysvětlíme si, co každý logický operátor dělá a jak se zapisuje:

• and - logická spojka a, píše se ve tvaru boolean and boolean. Oba booleany musí být true, aby byl výsledek true, v každém jiném případě dostaneme false.
• or - logická spojka nebo, píše se ve tvaru boolean or boolean. Jeden z booleanů musí být true, aby byl i výsledek true. Takže pouze pokud budou oba booleany false, výsledek bude false.
• not - logická spojka ne, píše se ve tvaru not boolean. Neguje boolean, to znamená, že true změní na false a false zmení na true.

Tady je pár příkladů přímo v kódu:

Code Lua

1
2
3
4
5
6
7
8

print(true and true) --vytiskne true, protože všechny booleany jsou true
print(true and false) --vytiskne false, protože aspoň jeden boolean je false

print(true or false) --vytiskne true, protože aspoň jeden boolean je true
print(false or false) --vytiskne false, protože ani jeden boolean není true

print(not true) --vytiskne false
print(not false) --vytiskne true

Logické operátory and a or je možné řetězit na libovolný počet booleanů. Tady je pár příkladů:

Code Lua

1
2
3
4
5

print(true and true and true and true) --vytiskne true, protože všechny booleany jsou true
print(true and false and true and false) --vytiskne false, protože aspoň jeden boolean je false

print(true or false or false or false) --vytiskne true, protože aspoň jeden boolean je true
print(false or false or false or false) --vytiskne false, protože ani jeden boolean není true

Stejně jako má násobení a dělení přednost před sčítáním a odčítáním, and má přednost před or; not má přednost před and i or.

Code Lua

1
2

print(false or false and true or true) --vytiskne true
print(not false and true) --vytiskne true

Ovšem opět je možné využít závorky, aby jsme upřednostnili operace, které chceme aby se staly jako první, stejně jako když napíšeme u operací 9 * (4 + 4), můžeme napsat například (boolean or boolean) and (boolean or boolean). Tady je příklad, jak mohou závorky změnit výsledek přímo v kódu:

Code Lua

1
2

print(false or false and true or true) --vytiskne true
print((false or false) and (true or true)) --vytiskne false

A ano, tyhle hodnoty je možné zadat do proměnné stejně jako všechny ostatní hodnoty:

Code Lua

1
2
3

x = false or false and true or true

print(x) --vytiskne true

3. Ve třetím úkolu tu máš nekolik printů s booleany a logickými operátory. Uhádni u každého printu, jestli vytiskne true nebo false.

Code Lua

1
2
3
4
5
6
7
8
9
10
11

print(false and false)
print(false and true)
print(not false)
print(false or true)
print(true or true)
print(not true and true)
print(true and true or false and true)
print(false or not false and true)
print(false or true and not true)
print(not(false and true) and false or true)
print(false or true and (false or true))

3. řešení

1.6. Srovnávací operátory ==, ~=, <, >, <= a >=
Aby toho nebylo málo, máme tu další důležité operátory, které nám také jako výsledek dají boolean. Všechny se píšou ve tvaru hodnota operátor hodnota. Naštěstí jsou jednoduché na pochopení:

• == (rovná se) - Pokud jsou hodnoty stejné, výsledek je true, pokud jsou jiné, výsledek je false.
• ~= (nerovná se) - Pokud jsou hodnoty jiné, výsledek je true, pokud jsou stejné, výsledek je false. Je to opak == operátoru.
• < (je menší) - Srovnává dvě čísla. Pokud je první číslo menší než druhé, výsledek je true. V jiném případě je výsledek false.
• > (je větší) - Srovnává dvě čísla. Pokud je první číslo větší než druhé, výsledek je true. V jiném případě je výsledek false.
• <= (je menší nebo rovno) - Srovnává dvě čísla. Pokud je první číslo menší nebo rovno druhému, výsledek je true. V jiném případě je výsledek false.
• >= (je větší nebo rovno) - Srovnává dvě čísla. Pokud je první číslo větší nebo rovno druhému, výsledek je true. V jiném případě je výsledek false.

Lua je v operátorech == a ~= hodná a nehodí chybu, i když srovnáváme dva úplně jiné typy hodnot. Tady je pár příkladů, jak se tyto operátory využívají:

Code Lua

1
2
3
4
5
6
7

print(1 == 1) --vytiskne true
print(10 == "ahoj") --vytiskne false
print(5 ~= 20) --vytiskne true
print(9 ~= "zdarec") --vytiskne true
print(5 < 8) --vytiskne true
print(10 > 10) --vytiskne false
print(100 >= 15) --vytiskne true

Opět je možné tyhle hodnoty zadat do proměnné stejně jako všechny ostatní hodnoty:

Code Lua

1
2
3

x = 9 ~= "zdarec"

print(x) --vytiskne true

4. Tentokrát tu máš několik printů s hodnotami a srovnávacími operátory. Uhádni u každého printu, jestli vytiskne true nebo false.

Code Lua

1
2
3
4
5
6
7
8
9
10

x = 2
y = 100

print("lua" == "lua")
print(6458 == 6458)
print(95 ~= 45)
print(100 > y)
print(64 <= 128 / x)
print(false == 78 * 9)
print(x == y)

4. řešení

Teď spojíme srovnávací operátory s logickými operátory and, or a not, protože se využívají společně a brzy si řekneme kde. Srovnávací operátory se vyhodnotí jako první, až potom se vyhodnocují logické operátory. Tady je pár příkladů přímo v kódu:

Code Lua

1
2
3
4
5
6
7
8
9

x = 5
y = 10

print(x < y and x == 5) --vytiskne true
print(x == 0 or x == 5) --vytiskne true
print(x ~= y and x == 5 and y == 10 and (y >= x or y == 0)) --vytiskne true

z = (x == y and x > 0 and y > 0)
print(z) --vytiskne se false

5. Tohle bude poslední test, jestli rozumíš logickým i srovnávacím operátorům. Uhádni u každého printu, jestli vytiskne true nebo false.

Code Lua

1
2
3
4
5
6
7
8
9
10

x = 2
y = 5
z = 10

print(x == 2 and y == 6)
print(x <= y and y <= z)
print(z == y or z ~= x)
print(not(y < 0 or not(y < z)))
print(z > 0 and z < 100 and (z > x or z > y))
print(((x == 0 or x < y) and (z == 10 or y == 5)) ~= true)

5. řešení

1.7. IF prohlášení
Konečně se dostáváme do něčeho, co vypadá jako pořádné programování! :D Využijeme tu pořádně naše logické a srovnávací operátory. If prohlášení je takzvané podmíněné vykonání příkazu. Ukážeme si, jak se zapisuje v kódu. Začneme jednoduše. Na začátek napíšeme slovíčko if, za něj nějaký boolean a nakonec slovíčko then. Vznikne nám if boolean then. Například if x > 9 then. Potom stiskneme 2x enter a napíšeme end. Tím si prohlášení uzavřeme a vše, co napíšeme mezi řádky s if a end se stane pouze, pokud boolean za if bude true. Ukážeme si to názorně v kódu:

Code Lua

1
2
3
4
5

x = 10

if x < 100 then
	print("x je menší než 100")
end

V tomto případě kód vytiskne x je menší než 100, protože hodnota x na začátku je opravdu menší než 100. Můžeš vidět, že jsem print odsadil od kraje tabem. Odsazení tabem se používá pro lepší čitelnost kódu.

K if můžeme dále využít komponent v podobě elseif boolean then. Napojuje se vždy pod if a můžeme jich pod sebou napsat kolik chceme. Pokud první if není pravda, vyzkouší se elseif pod ním. Pokud ani to není pravda, vyzkouší se další elseif pod ním a tak dále.

Code Lua

1
2
3
4
5
6
7
8
9
10
11

x = 10

if x == 100 then
	print("x je 100")
elseif x > 5 then
	print("x je větší než 5")
elseif x < 0 then
	print("x je záporné číslo")
elseif x == 0 then
	print("x je 0")
end

V tomto případě kód vytiskne x je větší než 5. protože elseif x > 5 then je jako první pravda. Všechny ostatní elseif se už ani nezkontrolují a přejde se rovnou k end.

Poslední slovíčko, které můžeme k if přidat je else. Napojuje se vždy až jako poslední, můžeme napsat pouze jedno a nepíše se k němu boolean ani slovo then. Pokud není if ani žádné elseif pravda, spustí se else.

Code Lua

1
2
3
4
5
6
7
8
9
10
11

x = 10

if x == 3 then
	print("x je 3")
elseif x == 7 then
	print("x je 7")
elseif x == 15 then
	print("x je 15")
else
	print("x není 3 ani 7 ani 15")
end

Kód vytiskne x není 3 ani 7 ani 15, protože žádné z prohlášení není pravda.

6. Máš tu kód s několika if prohlášeními. Urči u každého prohlášení, jaké číslo vytiskne.

Code Lua

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

x = -3
y = 0
z = 5

if x == -3 then
	print(1)
elseif y >= 10 then
	print(2)
end

if x == y then
	print(1)
elseif x == z then
	print(2)
else
	print(3)
end

if x ~= -3 then
	print(1)
elseif x ~= y then
	print(2)
elseif x == -3 then
	print(3)
end

if y > z then
	print(1)
elseif z < x then
	print(2)
elseif x < y then
	print(3)
else
	print(4)
end


text = "ahoj"

if text == "zdarec" then
	print(1)
elseif text == "ahoj" then
	print(2)
elseif text == true then
	print(3)
else
	print(4)
end

6. řešení

7. Dostaneš první opravdu programovací úkol. V kódu je hodnota x, za kterou můžeš dosadit libovolné číslo. Napiš takovou if strukturu, která vytiskne, jestli je x záporné číslo, kladné číslo nebo 0. Klidně si kód můžeš několikrát spustit s různými x hodnotami pro ověření, jestli ho máš naprogramovaný správně.

Code Lua

1
2
3

x = 254

--tady naprogramuj odpověď

7. řešení

Vyzkoušíme si do if prohlášení přidat i logické operátory, tady je příklad přímo v kódu:

Code Lua

1
2
3
4
5
6
7

x = 7

if x == 3 or x == 7 or x == 15 then
	print("x se rovná 3 nebo 7 nebo 15")
else
	print("x není 3 ani 7 ani 15")
end --vytiskne x není 3 ani 7 ani 15

8. V kódu jsou hodnoty x a y. Za x můžeš dosadit libovolné číslo a za y libovolný boolean. Napiš takovou if strukturu, která vytiskne boolean true, pokud je x rovno 1 nebo 150 nebo 2000 a zároveň y je true. V jiném případě se vytiskne boolean false. Využij i logické operátory. Klidně si kód můžeš několikrát spustit s různými x a y hodnotami pro ověření, jestli ho máš naprogramovaný správně.

Code Lua

1
2
3
4

x = 2000
y = true

--tady naprogramuj odpověď

8. řešení

9. Úkoly už začínají být obtížnější. V kódu jsou hodnoty x a y, za které můžeš dosadit libovolná čísla. Napiš takovou if strukturu, která vytiskne string "x je podobné y", pokud je x nejvíce o 10 menší nebo větší, něž y. Pokud to nebude pravda, vytiskne string "x není podobné y". Využij i logické operátory. Klidně si kód můžeš několikrát spustit s různými x a y hodnotami pro ověření, jestli ho máš naprogramovaný správně.

Code Lua

1
2
3
4

x = 50
y = 45

--tady naprogramuj odpověď

9. řešení

If se může vnořit do dalšího If:

Code Lua

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

x = 5
bool = true

if bool == true then
	if x == 4 then
		print("x se rovná 4")
	elseif x == 5 then
		print("x se rovná 5")
	else
		print("x se nerovná 4 ani 5")
	end
else
	if x > 0 then
		print("x je kladné číslo")
	elseif x < 0 then
		print("x je záporné číslo")
	elseif x == 0 then
		print("x je 0")
	end
end

10. V kódu jsou dvě if struktury. U obou urči, jaké číslo vytiskne.

Code Lua

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

x = 10
y = true
z = "ahoj"

if (10 == x or y == false) and (z == "ahoj" or z == "zdar") then
	if x == 5 then
		print(1)
	elseif x == 10 then
		print(2)
	end 
elseif 1 == 1 then
	print(3)
end

if not y == true then
	if x == 10 then
		print(1)
	end
elseif (x == 0 or x == 1) and x == 10 then
	if y == false or x > 100 then
		print(1)
	elseif z == "yo" then
		print(2)
	else
		print(3)
	end
else
	print(4)
end

10. řešení

11. Dám ti úkol, podle kterého se pozná, jestli opravdu rozumíš všemu, co jsme si zatím řekli. V kódu máš tři proměnné. Dvě čísla s názvy x a y a jeden string s názvem operace. Čísla mohou být libovolná a string může být jedna ze čtyř hodnot "plus", "mínus", "krát", "děleno". Naprogramuj jednoduchou kalkulačku pro hodnoty x a y, která vytiskne jejich součet, rozdíl, násobek nebo podíl podle toho, jakou string hodnotu bude mít operace.

Code Lua

1
2
3
4
5

x = 10
operace = "plus" --může být "plus", "mínus", "krát" nebo "děleno"
y = 5

--tady naprogramuj odpoveď

11. řešení

1.8. Hodnota nil
Když jsem poprve vysvětloval hodnoty, zatajil jsem, že v Lua existují další dva základní typy hodnot, aby toho nebylo na začátek tolik. Na první z nich se podíváme právě teď. Typ hodnoty nil má jen jedinou podobu a znamená prázdnou hodnotu. Používá se například, pokud chceme vytvořit proměnnou, která zatím nemá žádnou hodnotu, ale dá se s ní pracovat jako se všemi ostatními proměnnými.

Code Lua

x = nil --já jsem nil

1.9. Table
Table je druhý typ hodnoty, který jsem na začátku záměrně nezmínil, protože tenhle je nejsložitější. Table je velice speciální hodnota, protože v sobě dokáže ukládat jakékoliv další hodnoty. Ukážeme si, jak se vytvoří proměnná s hodnotou table:

Code Lua

1
2
3

x = {} --já jsem prázdný table

y = {2, 10, 100} --já jsem table se třemi číselnými hodnotami 2, 10 a 100

Na hodnoty tablu se dostaneme pomocí indexů. Index v Lua začíná od 1. Například, pokud máme y = {2, 10, 100}, číslo 2 je na indexu 1, číslo 10 na indexu 2 a číslo 100 na indexu 3. Pokud budeme chtít ve zmíněném tablu dostat hodnotu na určitém indexu, napíšeme název tablu a za něj do hranatých závorek index. Například y[2] má hodnotu 10. Ukážeme si to názorně v kódu:

Code Lua

1
2
3
4
5
6
7

x = {5, 10, 15, 20, 25, 30}

print(x[1]) --vytiskne 5
print(x[5]) --vytiskne 25

y = x[6]
print(y) --vytiskne 30

Pokud se pokusíme získat hodnotu na indexu, který v tablu není, například index 10 z tablu x = {5, 10, 15, 20, 25, 30}, dostaneme hodnotu nil.

Code Lua

1
2
3

x = {5, 10, 15, 20, 25, 30}

print(x[10]) --vytiskne nil

Další důvod, proč jsou tably tak úžasné je, že v sobě dokážou ukládat opravdu jakýkoliv typ hodnoty. To znamená, že v sobě dokážou uložit i další tably. Tím se dostáváme do vícedimenzionálních tablů. Pokud máme table, kderý má v sobě další table, nazývá se dvoudimenzionální table. Pokud zajdeme do větších extrémů a budeme mít table, který má v sobě další tably a ty v sobě mají další tably, nazývá se trojdimenzionální. Stejným způsobem mohou být čtyřdimenzionální, pětidimenzionální a tak dále. Vytvoříme si jednoduchý dvoudimenzionální a trojdimenzionální table a názorně si ukážeme, jak se dostat na všechny jejich hodnoty:

Code Lua

1
2
3
4
5
6
7
8
9
10
11
12
13
14

x = {10, "ahoj", nil, true, {}} --do tablu jde vložit jakýkoliv typ hodnoty

y = {{2, 3}, {9, 2}, {6, 7}}
print(y[2][1]) --vytiskne 9, protože na druhém indexu v tablu y je {9, 2} a na prvním indexu v tomto tablu je 9
print(y[3][2]) --vytiskne 7

z = {8, 2, {5, 6, 1}, 9, 5}
print(z[4]) --vytiskne 9
print(z[3][1]) --vytiskne 5

a = {5, 6, {3, 4, {9, 1, 3}, 3}, {9, 7, {8, 2, 3}, 5, {4, 5, 6}}}
print(a[3][3][2]) --vytiskne 1
print(a[4][3][1]) --vytiskne 8
print(a[4][5][3]) --vytiskne 6

Už trojdimenzionální tably dokážou být velice matoucí. Proto doporučuji nepřehledné vícedimenzionální tably zapisovat mnohem srozumitelněji na více řádků:

Code Lua

1
2
3
4
5
6
7

y = {
	{2, 3},
	{9, 2},
	{6, 7},
}
print(y[2][1]) --vytiskne 9
print(y[3][2]) --vytiskne 7

Pro ještě větší srozumitelnost můžeme v kódu i znázornit jednodlivé indexy. To už záleží na samotném programátorovi, jestli se rozhodne indexy rozepisovat nebo ne. Mně osobně se to někdy vyplatí a někdy ne. Zápis ukážu na tablech z posledních dvou kódů a nechám i printy pro srovnání, o kolik je jednodušší přečíst takhle rozepsané tably:

Code Lua

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

y = {
	[1] = {2, 3},
	[2] = {9, 2},
	[3] = {6, 7},
}
print(y[2][1]) --vytiskne 9
print(y[3][2]) --vytiskne 7

z = {
	[1] = 8,
	[2] = 2,
	[3] = {5, 6, 1},
	[4] = 9,
	[5] = 5,
}
print(z[4]) --vytiskne 9
print(z[3][1]) --vytiskne 5

a = {
	[1] = 5,
	[2] = 6,
	[3] = {
		[1] = 3,
		[2] = 4,
		[3] = {9, 1, 3},
		[4] = 3,
	},
	[4] = {
		[1] = 9,
		[2] = 7,
		[3] = {8, 2, 3},
		[4] = 5,
		[5] = {4, 5, 6},
	},
}
print(a[3][3][2]) --vytiskne 1
print(a[4][3][1]) --vytiskne 8
print(a[4][5][3]) --vytiskne 6

12. V kódu máš několik vícedimenzionálních tablů. Každý rozepiš na více řádků do srozumitelnější podoby.

Code Lua

1
2
3
4

a = {{1, 2, 3, 4, 5, 6}, {10, 20, 30, 40, 50, 60}}
b = {19, 15, {3, 4, 8}, 30}
c = {{9, 6, 1}, {9, {3, 3}, 2, 1}, 3}
d = {6, {{9}, {10, {15, 16, 17, 18}, 11}}, 3, 4, {100, 200, 300}}

12. řešení

13. V kódu máš několik vícedimenzionálních tablů. Urči u každého printu, co vytiskne.

Code Lua

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

x = {{3, 6, 9, 12}, {4, 8, 12, 16}, {5, 10, 15, 20}}

y = {2, {9, 6, 7, 6}, true, false, {1, {100, "aha", 300}, nil, 5}, 6, 7}

z = {{{10, 20, 30}, {200, 300, 400}, {"a", "b", "c"}}, {{9}, {10}, {11}}}

print(x[2][1])
print(x[3][3])
print(x[1][4])
print(y[2][1])
print(y[4])
print(y[5][2][2])
print(z[1][2][3])
print(z[1][3][1])
print(z[2][3][1])

13. řešení

Výborně, teď už víme, jak se orientovat v tablech a indexech. Teď si ukážeme způsob, jak můžeme do tablu přidávat další hodnoty nebo z tablu mazat hodnoty. K tomu slouží dvě funkce. Do teď jsme znali pouze funkci print(hodnota), tak teď si do našeho repertoáru přidáme další.

table.insert(table, index, hodnota) - Přidá do tablu novou hodnotu. Do funkce zadáváme tři věci:
• table - název tablu, do kterého chceme přidat hodnotu
• index - index, na který chceme v tablu přidat hodnotu
• hodnota - nějaká hodnota, kterou chceme přidat.
Není nutné zadávat index. Funkci můžeme použít i takhle: table.insert(table, hodnota). V tomto případě se hodnota dá na konec tablu.

table.remove(table, index) - Smaže z tablu určitou hodnotu. Do funkce musíme zadat dvě věci:
• table - název tablu, ze kterého chceme smazat hodnotu.
• index - index, ze kterého chceme smazat hodnotu.
Opět není nutné zadávat index. Funkci můžeme použít i takhle: table.remove(table). V tomto případě se smaže poslední hodnota.

Tady je několik příkladů, jak funkce použít:

Code Lua

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

x = {5, 2, 3}

table.insert(x, 8) --x = {5, 2, 3, 8}
table.insert(x, 2, 9) --x = {5, 9, 2, 3, 8} - všechny hodnoty od indexu 2 se posunou o místo dál, aby bylo místo pro nově vloženou hodnotu

table.remove(x, 4) --x = {5, 9, 2, 8} - všechny hodnoty za indexem 4 se posunou zpět, aby zaplnily prázdné místo po smazané hodnotě
table.remove(x) --x = {5, 9, 2}


y = {{10, 20}, {100, 200}}

table.insert(y[1], 30) --y = {{10, 20, 30}, {100, 200}}
table.insert(y[2], 2, "ahoj") --y = {{10, 20, 30}, {100, "ahoj", 200}}

table.remove(y, 1) --y = {{100, "ahoj", 200}}

Pokud budeme mít například table x = {1, 2} a na 7. index dáme číslo 4, tedy použijeme table.insert(x, 7, 4), můžeme si představit, že všechny indexy, mezi 2. indexem a 7. indexem, do kterých jsme nezadali žádné číslo, mají hodnotu nil. Takže výsledek bude x = {1, 2, nil, nil, nil, nil, 4}.

Code Lua

1
2
3

x = {1, 2}

table.insert(x, 7, 4) --x = {1, 2, nil, nil, nil, nil, 4}.

14. V kódu máš table x s čísly. Použij funkce table.insert() a table.remove() k uspořádání tablu tak, aby jeho finální podoba vypadala takhle x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}. Pokus se využít co nejméně table.insert() a table.remove() funkcí. Vytisknutím tablu pomocí print(x) na konci kódu si můžeš zkontrolovat, jestli máš úkol splněný správně.

Code Lua

1
2
3
4
5

x = {-9, 4, 0.5, 3, 4, 100, 5, 6, "ahoj", 9}

--tady naprogramuj odpověď

print(x)

14. řešení

Druhý způsob, jak můžeme v tablu manipulovat s hodnotami je přímo přepisování v podobě x[2] = 6. Tohle nám změní na druhém indexu v tablu x hodnotu na 6. Ukážeme si pár příkladů přímo v kódu:

Code Lua

1
2
3
4
5
6
7

x = {3, 6, 9, 12}

x[3] = 100 --x = {3, 6, 100, 12}
x[1] = "lol" --x = {"lol", 6, 100, 12}
x[5] = 60 --x = {"lol", 6, 100, 12, 60}
x[10] = 123 --x = {"lol", 6, 100, 12, 60, nil, nil, nil, nil, 123}
x[2] = nil --x = {"lol", nil, 100, 12, 60, nil, nil, nil, nil, 123}

15. Mám pro tebe ještě jeden podobný úkol. V kódu máš opět table x s čísly. Tentokrát změň hodnoty stylem x[index] = hodnota k uspořádání tablu tak, aby jeho finální podoba vypadala takhle x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}. Pokus se změnit co nejméně hodnot. Vytisknutím tablu pomocí print(x) na konci kódu si můžeš zkontrolovat, jestli máš úkol splněný správně.

Code Lua

1
2
3
4
5

x = {-9, 0.5, 3, 4, 100, 6, "ahoj", 9}

--tady naprogramuj odpověď

print(x)

15. řešení

Velice užitečný je také operátor #, který nám dá délku tablu. Píše se ve tvaru #table. Pozor, pokud je v tablu uložený nil, může způsobit zvláštní chování # operátoru, proto nedoporučuji používat #, pokud v tablu ukládáš nil. Ukážeme si příklady použití # přímo v kódu:

Code Lua

1
2
3
4
5
6
7
8

x = {10, 20, 30, 40}
print(#x) --vytiskne 4

table.remove(x)
print(#x) --vytiskne 3

y = {4, "abc", {1, 2, 3, 4, 5, 6}, true, false}
print(#y) --vytiskne 5

Index je první způsob, jak můžeme ukládat hodnoty do tablu a následně se v nich navigovat. Druhý způsob je klíč. V Lua je, oproti jiným programovacím jazykům, velmi malý rozdíl mezi tím, co je index a co klíč a to dokáže být matoucí. Proto si teď přesně definujeme, co budeme považovat za index a co za klíč.

• Index může být pouze celé číslo větší než 0. Například 1, 2, 10, 5000, 5413215, ...
• Klíč může být jakákoliv hodnota, která se nepovažuje za index. Jediný nil se nemůže použít jako klíč. I tak silně doporučuji jako klíč využívat pouze string, aby jste se vyznali v tom, co děláte. Například "ahoj", "age", "key_one", ...

Ukážeme si, jak table s klíči vypadá na tablu jménem pes:

Code Lua

1
2
3
4
5
6
7
8
9

pes = {
	["jmeno"] = "Azor",
	["vek"] = 2,
	["chytrost"] = 98,
	["zdravi"] = 99,
}

print(pes["jmeno"]) --vytiskne Azor
print(pes["zdravi"]) --vytiskne 99

Pro klíče neexistuje něco jako table.insert() a table.remove(), vše se dělá přímo přiřazením hodnoty. Pokud chceme do výše vytvořeného tablu pes přidat třeba rychlost, uděláme to takhle pes["rychlost"] = 30. Ukážu i příklad přímo v kódu:

Code Lua

1
2
3
4
5
6
7
8

pes = {
	["jmeno"] = "Azor",
	["vek"] = 2,
	["chytrost"] = 98,
	["zdravi"] = 99,
}

pes["rychlost"] = 30 --vytvořili jsme do tablu pes novou hodnotu 30 s klíčem "rychlost"

Pokud z tablu chceme smazat hodnotu s klíčem, dáme ji rovno nil. například pes["vek"] = nil. Opět ukážu příklad přímo v kódu:

Code Lua

1
2
3
4
5
6
7
8

pes = {
	["jmeno"] = "Azor",
	["vek"] = 2,
	["chytrost"] = 98,
	["zdravi"] = 99,
}

pes["vek"] = nil --vymazali jsme z tablu pes hodnotu 2 s klíčem "vek"

Je možné mít table, kde jsou zároveň indexy i klíče:

Code Lua

x = {1, 10, ["velikost"] = 500, ["vzdalenost"] = 300}

V takovém případě bych doporučil lepší zápis kvůli jednodušší čitelnosti kódu:

Code Lua

1
2
3
4
5
6

x = {
	[1] = 1,
	[2] = 10,
	["velikost"] = 500,
	["vzdalenost"] = 300,
}

Pozor, operátor # ignoruje klíče, takže pokud bude mít table 2 indexy a 3 klíče, jeho velikost bude 2. Žádný strach, jak zjistit velikost tablu i s klíči si ukážeme níže v tutorialu.

Code Lua

1
2
3
4
5
6
7
8
9

x = {
	[1] = 1,
	[2] = 10,
	["velikost"] = 500,
	["vzdalenost"] = 300,
	["vyska"] = 12000,
}

print(#x) --vytiskne 2

Klíče je možné zapisovat dvěma různými způsoby. Já mám ve většině případů raději druhý styl zápisu, který vám teď ukážu:

Code Lua

1
2
3
4
5
6
7
8
9
10
11
12

pes = {
	jmeno = "Azor",
	vek = 2,
	chytrost = 98,
	zdravi = 99,
}

print(pes.jmeno) --vytiskne Azor
print(pes.zdravi) --vytiskne 99

pes.rychlost = 30 --přidání hodnoty s klíčem
pes.vek = nil --smazání hodnoty s klíčem

Nezáleží na tom jakým stylem klíče zapíšeš. Například i když vytvoříš hodnotu pes["rychlost"] = 3 a vytiskneš ji jako print(pes.rychlost), vše bude fungovat bez problémů, ale kvůli jednodušší čitelnosti doporučuji využívat jednotně takový styl, ve kterém si klíč vytvoříš.

Code Lua

1
2
3
4
5
6
7
8
9
10

pes = {
    jmeno = "Azor",
    ["vek"] = 2,
}

print(pes.jmeno) --vytiskne Azor
print(pes.vek) --vytiskne 2

print(pes["jmeno"]) --vytiskne Azor
print(pes["vek"]) --vytiskne 2

16. Mám pro tebe poslední úkol v této sekci s tably. Na začátku kódu je velký table se seznamem křečků podle jmen a každý křeček má své statistiky. Dole v kódu je několik prázdných printů a u každého je komentář s požadavkem, co má vytisknout. Místo otazníku zapiš do každého printu takovou proměnnou, aby print vytiskl požadovanou hodnotu z tablu s křečky. Například, pokud budu chtít hlad Pauly, odpověď bude seznam_krecku["Paula"].hlad

Code Lua

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

seznam_krecku = {
	["Paula"] = {
		hlad = 10,
		rychlost = 5,
		zdravi = 100,
		pozice = {150, 620},
	},
	["Hryzalek"] = {
		hlad = 150,
		rychlost = 2,
		zdravi = 100,
		pozice = {928, 23},
	},
	["Goldy"] = {
		hlad = 9999,
		rychlost = 9999,
		zdravi = 7542,
		pozice = {12, 642},
		specialni = true,
	},
	["Matla"] = {
		hlad = 50,
		rychlost = 10,
		zdravi = 72,
		pozice = {482, 63},
	},
}

print(?) -- rychlost Hryzálka
print(?) -- zdraví Matly
print(?) -- jestli je Goldy speciální
print(?) -- druhá pozice Pauly
print(?) -- hlad Goldyho
print(?) -- první pozice Hryzálka
print(?) -- table s pozicemi Pauly
print(?) -- všechny statistiky Matly

16. řešení

Pozor, operátor == a ~= nepozná, jaký je obsah tablu, takže například print({1, 2, 3} == {1, 2, 3}) vytiskne false.

Code Lua

1
2
3
4
5
6
7
8
9

x = {1, 2, 3}
y = {1, 2, 3}
z = {200, 300}

print(x == y) --vytiskne false
print(x == z) --vytiskne false

print(x ~= y) --vytiskne true
print(x ~= z) --vytiskne true

Pozor, v TFM, funkce print tiskne špatně vícedimenzionální tably. Pokud budeme chtít vytisknout table x = {1, 2, {3, 4}}, dostaneme:

Přitom správně vytisknutý table x = {1, 2, {3, 4}} by měl vypadat takhle:

Code Lua

1
2
3
4
5
6
7
8

x = {
	[1] = 1,
	[2] = 2,
	[3] = {
		[1] = 3,
		[2] = 4,
	}
}

Work in progress, zbytek není zatím hotový...

Dernière modification le

English	Français
Português do Brasil	Español
Türkçe	Polski
Magyar	Română
العربية	Skandinavisk
Nederlands	Deutsch
Bahasa Indonesia	Русский
中文	Filipino
Lietuvių kalba	日本語
Suomi	עברית
Italiano	Česky
Hrvatski	Slovensky
Български	Latviešu
Estonian

Langue