×

Langue

Fermer
Atelier 801
  • Forums
  • Dev Tracker
  • Connexion
    • 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
  • Tribus
  • /
  • Hvezdokupa
  • /
  • Soutěže a Lua / Competitions and Lua
  • /
  • LUA - programovací jazyk / LUA - programming language
LUA - programovací jazyk / LUA - programming language
Hufdasr
« Citoyen »
Vudce Huf
1599198600000
    • Hufdasr#0000
    • Profil
    • Derniers messages
    • Tribu
#1
  2

https://i.imgur.com/BrUxGg7.png
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.

https://i.imgur.com/a0EifuL.png
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!

https://i.imgur.com/nSwNzoN.png
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
1
--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
1
print("hello world!")

Pokud máš vše správně, otevře se ti chat #lua a uvidíš svou první vytisklou zprávu https://i.imgur.com/r5fx8QI.png, 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í

Code Lua
1
2
3
print("Já jsem programátor")
print(-6)
print(false)

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í

Code Lua
1
2
3
4
5
6
7
8
9
x = 2
y = 1
z = 3

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


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í

Code Lua
1
2
3
4
5
6
7
8
9
10
11
print(false and false) --vytiskne false
print(false and true) --vytiskne false
print(not false) --vytiskne true
print(false or true) --vytiskne true
print(true or true) --vytiskne true
print(not true and true) --vytiskne false
print(true and true or false and true) --vytiskne true
print(false or not false and true) --vytiskne true
print((false or true) and not true) --vytiskne false
print(not(false and true) and true or false) --vytiskne true
print(false or true and (false or true)) --vytiskne true


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í

Code Lua
1
2
3
4
5
6
7
8
9
10
x = 2
y = 100

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

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í

Code Lua
1
2
3
4
5
6
7
8
9
10
x = 2
y = 5
z = 10

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


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í

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 --vytiskne 1

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

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

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


text = "ahoj"

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


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í

Code Lua
1
2
3
4
5
6
7
8
9
x = 254

if x < 0 then
	print("x je záporné číslo")
elseif x > 0 then
	print("x je kladné číslo")
else
	print("x je 0")
end

Nebo

Code Lua
1
2
3
4
5
6
7
8
9
x = 254

if x < 0 then
	print("x je záporné číslo")
elseif x > 0 then
	print("x je kladné číslo")
elseif x == 0 then
	print("x je 0")
end

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í

Code Lua
1
2
3
4
5
6
7
8
x = 2000
y = true

if (x == 1 or x == 150 or x == 2000) and y == true then
	print(true)
else
	print(false)
end

Nebo

Code Lua
1
2
3
4
5
6
7
8
9
10
x = 2000
y = true

if y == false then
	print(false)
elseif x ~= 1 and x ~= 150 and x ~= 2000 then
	print(false)
else
	print(true)
end


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í

Code Lua
1
2
3
4
5
6
7
8
x = 50
y = 45

if x >= y - 10 and x <= y + 10 then
	print("x je podobné y")
else
	print("x není podobné y")
end

Nebo například i jinak upravené rovnice

Code Lua
1
2
3
4
5
6
7
8
x = 50
y = 45

if x - y >= -10 and x - y <= 10 then
	print("x je podobné y")
else
	print("x není podobné y")
end

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í

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 --vytiskne 2

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 --vytiskne 4

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í

Code Lua
1
2
3
4
5
6
7
8
9
10
11
12
13
x = 10
operace = "plus" --může být "plus", "mínus", "krát" nebo "děleno"
y = 5

if operace == "plus" then
	print(x + y)
elseif operace == "mínus" then
	print(x - y)
elseif operace == "krát" then
	print(x * y)
elseif operace == "děleno" then
	print(x / y)
end


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
1
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í

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
a = {
	[1] = {1, 2, 3, 4, 5, 6},
	[2] = {10, 20, 30, 40, 50, 60},
}

b = {
	[1] = 19,
	[2] = 15,
	[3] = {3, 4, 8},
	[4] = 30,
}

c = {
	[1] = {9, 6, 1},
	[2] = {
		[1] = 9,
		[2] = {3, 3},
		[3] = 2,
		[4] = 1,
	},
	[3] = 3,
}

d = {
	[1] = 6,
	[2] = {
		[1] = {9},
		[2] = {
			[1] = 10,
			[2] = {15, 16, 17, 18},
			[3] = 11,
		},
	},
	[3] = 3,
	[4] = 4,
	[5] = {100, 200, 300},
}

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í

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]) --vytiskne 4
print(x[3][3]) --vytiskne 15
print(x[1][4]) --vytiskne 12
print(y[2][1]) --vytiskne 9
print(y[4]) --vytiskne false
print(y[5][2][2]) --vytiskne aha
print(z[1][2][3]) --vytiskne 400
print(z[1][3][1]) --vytiskne a
print(z[2][3][1]) --vytiskne 11

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í

Code Lua
1
2
3
4
5
6
7
8
9
10
11
12
13
x = {-9, 0.5, 3, 4, 100, 5, 6, "ahoj", 9}

table.remove(x, 1) --x = {0.5, 3, 4, 100, 5, 6, "ahoj", 9}
table.remove(x, 1) --x = {3, 4, 100, 5, 6, "ahoj", 9}
table.remove(x, 3) --x = {3, 4, 5, 6, "ahoj", 9}
table.remove(x, 5) --x = {3, 4, 5, 6, 9}
table.insert(x, 1, 1) --x = {1, 3, 4, 5, 6, 9}
table.insert(x, 2, 2) --x = {1, 2, 3, 4, 5, 6, 9}
table.insert(x, 7, 7) --x = {1, 2, 3, 4, 5, 6, 7, 9}
table.insert(x, 8, 8) --x = {1, 2, 3, 4, 5, 6, 7, 8, 9}
table.insert(x, 10) --x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

print(x)

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í

Code Lua
1
2
3
4
5
6
7
8
9
10
11
x = {-9, 0.5, 3, 4, 100, 6, "ahoj", 9}

x[1] = 1 --x = {1, 0.5, 3, 4, 100, 6, "ahoj", 9}
x[2] = 2 --x = {1, 2, 3, 4, 100, 6, "ahoj", 9}
x[5] = 5 --x = {1, 2, 3, 4, 5, 6, "ahoj", 9}
x[7] = 7 --x = {1, 2, 3, 4, 5, 6, 7, 9}
x[8] = 8 --x = {1, 2, 3, 4, 5, 6, 7, 8}
x[9] = 9 --x = {1, 2, 3, 4, 5, 6, 7, 8, 9}
x[10] = 10 --x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

print(x)

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
1
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í

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(seznam_krecku["Hryzalek"].rychlost) -- rychlost Hryzálka
print(seznam_krecku["Matla"].zdravi) -- zdraví Matly
print(seznam_krecku["Goldy"].specialni) -- jestli je Goldy speciální
print(seznam_krecku["Paula"].pozice[2]) -- druhá pozice Pauly
print(seznam_krecku["Goldy"].hlad) -- hlad Goldyho
print(seznam_krecku["Hryzalek"].pozice[1]) -- první pozice Hryzálka
print(seznam_krecku["Paula"].pozice) -- table s pozicemi Pauly
print(seznam_krecku["Matla"]) -- všechny statistiky Matly

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:
https://i.imgur.com/StICSK7.png

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,
	}
}

Zbytek tutorialu zatím není dokončený, chybí mi tu ještě 2 hlavní části. Jenže protože brzy končí tyto fóra, dám sem potřebné informace jiným způsobem, než jsem plánoval. Pomůžu si youtube videi a dál prozatím nebudou úkoly, proto si sám/sama pečlivě procvič vše, co se naučíš. Tutrial dodělám později, až budu mít hotové zkoušky v irl a jakmile najdu jiné místo na dokončení tutorialu než stránky Atelier801.

1.10. Cykly
Je to část kódu, která se dokáže několikrát opakovat. Jsou tři druhy cyklů: for, while a repeat until.
Tady je youtube tutorial na všechny cykly: https://www.youtube.com/watch?v=wZjkaHplAWs

Chci k tutorialu něco málo dodat:
• Youtuber využil v tutorialu break, který ukončí cyklus předčasně. Například:
Code Lua
1
2
3
4
5
6
7
8
9
10
11
12
for i = 1, 10 do
	print(i)
end
--vytiskne postupně 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

for i = 1, 10 do
	print(i)
	if i == 5 then
		break
	end
end
--vytiskne postupně 1, 2, 3, 4, 5

• Když máš ve for cyklu například for i = 1, 10 do, místo i si můžeš napsat cokoliv, třeba for day = 1, 10 do. Nejčastěji se ovšem jako nepsané pravidlo využívá i.

• Existuje ještě druhý způsob využití for cyklu, který projede celý table (indexy i klíče). Projíždí vždy jeden index/klíč po druhém. i se vždy rovná indexu nebo klíči a v je příslušná hodnota tomu indexu nebo klíči. Zápis cyklu je následovný: for i,v in pairs(table) do. Místo i a v můžeme opět napsat co chceme. Ukážeme si to přímo v kódu:
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
numbers = {10, 20, ["a"] = 50, ["b"] = 150}

for i,v in pairs(numbers) do
  print(i)
  print(v)
  print("---")
end

--[[
vytiskne:
1
10
---
2
20
---
a
50
---
b
150
---
]]

• Pokud místo pairs napíšeme ipairs, cyklus bude ignorovat klíče. Opět ukážu v kódu:
Code Lua
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
numbers = {10, 20, ["a"] = 50, ["b"] = 150}

for i,v in ipairs(numbers) do
  print(i)
  print(v)
  print("---")
end

--[[
vytiskne:
1
10
---
2
20
---
]]

• Samozřejmě je možné vnořit jeden cyklus do druhého:
Code Lua
1
2
3
4
5
6
for i = 1, 10 do
	for j = 1, 10 do
		print("ahoj")
	end
end
--vytiskne 100x ahoj

1.11. Vlastní funkce
Jedna z úplně nejdůležitějších a nejzajímavějších věcí v programování je tvorba vlastních funkcí.
Tady je tutorial z YouTube. Bohužel je torchu složitější, ale lepší jsem nenašel: https://youtu.be/9EVjBNjqU2U?si=jqKhLp_cuqEN3pfE

Opět chci k tutorialu něco dodat:
• V tutorial píše programátor před všechny funkce local. To nemusíš nutně psát. Ovšem local je velmi užitečné při vytváření hodnot ve funkcích, protože vytváří lokální hodnotu, která bude existovat pouze uvnitř dané funkce. Například:
Code Lua
1
2
3
4
b = 10

print(b) -- vytiskne 10
-- hodnota b existuje v celém kódu
Code Lua
1
2
3
4
5
6
7
8
9
function ahoj()
	local b = 10
	print(b)
end

print(b) --vytiskne nil
-- hodnota b existuje pouze ve funkci ahoj()

ahoj() --vytiskne 10

• Taky v kódu použil age = age or 5. To je zkrácená verze pro:
Code Lua
1
2
3
4
5
if age ~= nil then
     age = age
else
     age = 5
end

• Dále využil spojení stringu s další hodnotou, což se dělá pomocí dvou teček ..
Code Lua
1
2
3
4
5
6
7
8
9
10
a = "ahoj"
b = "dá"
print(a..b) --vytiskne: ahojdá

c = "věk: "
d = 22
print(c..d)  --vytiskne: věk: 22

e = "Huf"
print("Ahoj, já jsem "..e..", jak se máš?".) --vytiskne: Ahoj, já jsem Huf, jak se máš?

• Pokud funkce vrací pouze true nebo false, nazývá se predikátová a do jejího názvu doporučuji psát na konec P jako predikátová, aby byl kód o něco srozumitelnější. Predikátová funkce je například:
Code Lua
1
2
3
4
5
6
function vetsiNez10P(x)
	if x > 10 then
		return true
	end
	return false
end

• Pokud funkce volá sama sebe, nazývá se rekurzivní. Rekurzivní funkce může vypadat například takhle:
Code Lua
1
2
3
4
5
6
7
8
function printNumbers(x, y)
	if x <= y then
		print(x)
		printNumbers(x + 1, y)
	end
end

printNumbers(1, 50) --vytiskne čísla 1 až 50
Pro zajímavost: Rekurzivní funkce a celkově funkce jsou velmi mocné. Jak můžeš vidět, právě jsem naprogramoval jendoduchou verzi vlastního cyklu.

1.12. Math
Už umíš všechny nejdůležitější prvky programování. Ale ještě, než se vrhneš na svou epickou cestu programátora, ukážu ti některé velice užitečné funkce. Začnu s math funkcemi, které ti pomůžou při práci s čísly.

• math.random(x, y) - Funkce ti vrátí náhodné číslo v rozsahu od x do y. Například print(math.random(5, 10)) vytiskne náhodné číslo od 5 do 10.
• math.abs(x) - Funkce ti vrátí absolutní hodnotu x. Například print(math.abs(-90)) vytiskne 90.
• math.ceil(x) - Funkce ti vrátí x zaokrouhlené nahoru. Například print(math.ceil(5.65421)) vytiskne 6.
• math.floor(x) - Funkce ti vrátí x zaokrouhlené dolů. Například print(math.floor(5.65421)) vytiskne 5. Můžeme udělat zaokrouhlování od desetinné pětky nahoru, jak známe z matematiky, pokud k x přičteme 0.5. Například math.floor(5.65421 + 0.5).
• math.sqrt(x) - Funkce ti vrátí odmocninu z x. Například print(math.sqrt(9)) vytiskne 3.
• math.huge - Funkce ti vrátí tak velké číslo, že funguje jako nekonečno, print(math.huge) vytiskne inf.
• math.pi - Funkce ti vrátí číslo pi, print(math.pi) vytiskne 3.1415927.
Math dokáže pracovat například i se sinus, cosinus, tangens, cotangens, radiány nebo logaritmy, tady jsou všechny math funkce: https://www.tutorialspoint.com/lua/lua_math_library.htm.

1.13. Operace ^ a %.
Lua umí kromě +, -, *, / i další 2 operace, které jsem na začátku tutorialu zatajil.
• mocnina ^
• celočíselný zbytek po dělení %

Jak fungují:
Code Lua
1
2
3
4
5
6
7
8
x = 7
y = 2

print(x ^ y) --vytiskne 49
print(y ^ 2) --vytiskne 4
print(x % y) --vytiskne 1, protože 7 / 2 = 3 zbytek 1
print(50 % 20) --vytiskne 10, protože 50 / 20 = 2 zbytek 10
print)

Pomocí % jde vytvořit jednoduše kontrola, jestli je číslo sudé necho liché:
Code Lua
1
2
3
4
5
if x % 2 == 0 then
	print("x je sudé")
else
	print("x je liché")
end

Dernière modification le 1733744100000
Hufdasr
« Citoyen »
Vudce Huf
1733742600000
    • Hufdasr#0000
    • Profil
    • Derniers messages
    • Tribu
#2
  0
1.14. Něco víc ke stringu
Říkal jsem, že string se píše do " uvozovek. Co ale dělat, pokud chceme mít uvozovky přímo v textu? Jsou dva způsoby. První je, že před uvozovku v textu napíšeme obrácené lomítko \. Například "Potom řekla \"jak se máš?\"". Druhý způsob je, že string nezapíšeme do " uvozovek, ale do ' uvozovek. Potom můžeme používat dvojité uvozovky bez problému. Tady jsou i příklady přímo v kódu:
Code Lua
1
2
print("Zeptala se \"jak se máš?\", když jsem došel.") --vytiskne: Zeptala se "jak se máš?", když jsem došel.
print('Zeptala se "jak se máš?", když jsem došel.') --vytiskne: Zeptala se "jak se máš?", když jsem došel.

Někdy můžeme chtít napsat text na více řádků. To můžeme udělat opět dvěma způsoby. První je, že do textu přídáme znak pro nový řádek \n. Druhý způsob je, že string nezapíšeme do uvozovek, ale do dvou hranatých závorek, takhle: [[text]]. Ukážu příklady přímo v kódu:
Code Lua
1
2
3
4
5
6
7
8
9
10
11
12
print("Ahoj Hufe,\njak se máš?")
--[[vytiskne:
Ahoj Hufe,
jak se máš?
]]

print([[Ahoj Hufe,
jak se máš?]])
--[[vytiskne:
Ahoj Hufe,
jak se máš?
]]

Stejně jako existují funkce pro úpravu s čísly, existují také funkce pro úpravu stringů:
• string.lower(string) - Všechna písmena ve stringu změní na malá.
• string.upper(string) - Všechna písmena ve stringu změní na velká.
• string.sub(string, x, y) - Vrátí určitou část textu. Například, pokud x bude 1 a y -2, vrátí se nám string, který začíná od prvního znaku a končí předposledním znakem vstupního stringu.
Těchto funkcí existuje více, všechny najdeš tady: https://www.tutorialspoint.com/lua/lua_strings.htm.
Příklady string funkcí přímo v kódu:
Code Lua
1
2
3
print(string.lower("AhoJ, jAK sE Máš?")) --vytiskne: ahoj, jak se máš?
print(string.upper("AhoJ, jAK sE Máš?")) --vytiskne: AHOJ, JAK SE MÁŠ?
print(string.sub("AhoJ, jAK sE Máš?", 7, -2)) --vytiskne: jAK sE Máš

Připojovat do stringu proměnné nemusíš pouze pomocí dvou teček, ale také funkcí string.format(string, x1, x2, x3, ...). Funkce funguje tak, že do ní zadáš string, který má v sobě připravené zástupné symboly pro hodnoty.

Zástupné symboly mohou být následovné:
• %d nebo %i - číslo
• %f - desetinné číslo
• %s - string
• %x - číslo předělá na hexadecimální číslo
• %c - číslo předělá na znak z ASCII tabulky (https://cs.wikipedia.org/wiki/ASCII)

Příklad přímo v kódu:
Code Lua
1
2
3
4
5
6
7
8
9
jmeno = "Pája"
vek = 20
print(string.format("Ahoj, já jsem %s a je mi %d let", jmeno, vek)) --vytiskne: Ahoj, já jsem Pája a je mi 20 let

text = "tady mám tři čísla v šestnáctkové soustavě %x %x %x"
cislo1 = 20
cislo2 = 5000
cislo3 = 15
print(string.format(text, cislo1, cislo2, cislo3)) --vytiskne: tady mám tři čísla v šestnáctkové soustavě 14 1388 f

2. Pár slov na závěr
V budoucnu chci tento tutorial ještě vylepšit a rozšířit. Od cyklů je vše vysvětlené spíš v rychlosti a za použití YouTube videí, které nejsou úplně vhodně zasazené do tohoto tutorialu, ale snažil jsem se! xD Programování je nikdy nekončící učení a v Lua se toho skrývá mnohem více, než co jsem ukázal. Každopádně, tohle je skvělý způsob, jak ukázat nováčkům svět programování a jak poskytnout nejdůležitější informace postupně, srozumitelně a bez stovek hodin googlení. Děkuji, že jsi prošel můj tutorial a přeji hodně štěstí do tvé cesty programátora! :D

https://i.imgur.com/4Zn8YQi.png
https://i.imgur.com/q3aJTc8.png
  • Tribus
  • /
  • Hvezdokupa
  • /
  • Soutěže a Lua / Competitions and Lua
  • /
  • LUA - programovací jazyk / LUA - programming language
© Atelier801 2018

Equipe Conditions Générales d'Utilisation Politique de Confidentialité Contact

Version 1.27