# generated automatically from known prototypes (metadata only, no behavior)
from Core.module import Module
from Core.categories import DefaultCategories
from Core.io import Input, Output, Display
from Core.fields import Int32Field, Fix32Field, Int64Field, BooleanField, StringField

class Arithmetic_Display_16SEG_B(Module):
    name = "Aritmetika: 16segmentový"
    symbol = "16S-NB"
    width = 2
    description = "Rozsvítí 16segmentový displej a aktivuje čáry podle bitů jediného čísla"
    categories = [DefaultCategories.Arithmetic]
    inputs = [Input("V", "Číslo")]
    outputs = [Output("bits", "Bity"), Output("rest", "Zbytek")]
    displays = [Display.Text("val", "Hodnota", ""), Display.Text("bits", "Bity", "")]

class Arithmetic_Display_7SEG_B(Module):
    name = "Aritmetika: 7segmentový"
    symbol = "7S-NB"
    width = 2
    description = "Rozsvítí 7segmentový displej a aktivuje čáry podle bitů jediného čísla"
    categories = [DefaultCategories.Arithmetic]
    inputs = [Input("V", "Číslo")]
    outputs = [Output("bits", "Bity"), Output("rest", "Zbytek")]
    displays = [Display.Text("val", "Hodnota", ""), Display.Text("bits", "Bity", "")]

class Average(Module):
    name = "Průměr"
    symbol = "~A"
    width = 2
    description = "Udržuje běžící průměr <b>input</b> z až <b>count</b> vzorků (výchozí 10). Vypisuje aktuální počet vzorků na <b>count</b> a běžící průměr na <b>average</b>. Chybu hlásí, pokud je count < 1."
    categories = [DefaultCategories.Arithmetic]
    inputs = [Input("input", "Vstup")]
    outputs = [Output("count", "Průměr"), Output("average", "Průměr")]
    fields = [Int32Field("count", "Počet", "", 10)]

class Boolean_And_2(Module):
    name = "Logika: AND (2 piny)"
    symbol = "AND"
    width = 2
    description = "Vypisuje <b>a</b> = 1 na <b>c</b>, pokud jsou všechny 2 vstupy (<b>a</b>..<b>b</b>) > 0, jinak 0; <b>b</b> (<b>not_c</b>) je inverzní."
    categories = [DefaultCategories.Boolean]
    inputs = [Input("a", "A"), Input("b", "B")]
    outputs = [Output("b", "not C"), Output("a", "C")]
    displays = [Display.LED("not_c", "not C"), Display.LED("c", "C")]

class Boolean_Latch(Module):
    name = "Logika: NOR-Latch"
    symbol = "NORL"
    width = 2
    description = "Když je signál <b>set</b> aktivován, výstup drží hodnotu 1; když je signál <b>reset</b> aktivován, výstup drží hodnotu 0. Lze sestrojit ze dvou OR hradel propojených přes <b>not_c</b>."
    categories = [DefaultCategories.Boolean, DefaultCategories.Control]
    inputs = [Input("set", "Nastavit"), Input("reset", "Reset")]
    outputs = [Output("on", "Uložený signál")]
    displays = [Display.Text("_", "", ""), Display.LED("on", "Uložený signál")]

class Boolean_Not(Module):
    name = "Logika: NOT"
    symbol = "nA"
    width = 1
    description = "Vypisuje <b>a</b> = 1, pokud je vstup <b>a</b> 0 nebo záporný, jinak 0. Logická inverze jednoho vstupu."
    categories = [DefaultCategories.Boolean]
    inputs = [Input("a", "A")]
    outputs = [Output("a", "not A")]
    displays = [Display.LED("a", "not A")]

class Boolean_Or_2(Module):
    name = "Logika: OR (2 piny)"
    symbol = "OR"
    width = 2
    description = "Vypisuje <b>a</b> = 1 na <b>c</b>, pokud je alespoň jeden ze 2 vstupů (<b>a</b>..<b>b</b>) > 0, jinak 0; <b>b</b> (<b>not_c</b>) je inverzní."
    categories = [DefaultCategories.Boolean]
    inputs = [Input("a", "A"), Input("b", "B")]
    outputs = [Output("b", "not C"), Output("a", "C")]
    displays = [Display.LED("not_c", "not C"), Display.LED("c", "C")]

class Boolean_Xor(Module):
    name = "Logika: XOR"
    symbol = "XOR"
    width = 2
    description = "Vypisuje <b>a</b> = 1 na <b>c</b>, pokud je právě jeden z <b>a</b>, <b>b</b> > 0 (logické XOR); jinak 0. <b>b</b> (<b>not_c</b>) je inverzní."
    categories = [DefaultCategories.Boolean]
    inputs = [Input("a", "A"), Input("b", "B")]
    outputs = [Output("b", "not C"), Output("a", "C")]
    displays = [Display.LED("not_c", "not C"), Display.LED("c", "C")]

class Button_1(Module):
    name = "Tlačítko (zap/vyp)"
    symbol = "0/I"
    width = 1
    description = "Ruční přepínač zap/vyp. Výstup <b>value</b> je 1, dokud je přepínací displej aktivní, a 0, když je neaktivní. Hráč klepnutím na displej hodnotu přepíná."
    categories = [DefaultCategories.Control]
    inputs = []
    outputs = [Output("value", "Zap – 1, Vyp – 0")]
    displays = [Display.Text("toggle", "Přepnout", "")]

class Button_Pass(Module):
    name = "Tlačítko (propustit hodnotu)"
    symbol = "0/I"
    width = 1
    description = "Ruční brána. Pokud je přepínací displej aktivní, propustí vstup <b>value</b> přímo na výstup <b>value</b>; v neaktivním stavu vrací 0."
    categories = [DefaultCategories.Control]
    inputs = [Input("value", "Hodnota")]
    outputs = [Output("value", "Hodnota")]
    displays = [Display.Text("toggle", "Přepnout", "")]

class Compare_Int_Equal(Module):
    name = "Porovnání: A = B"
    symbol = "A=B"
    width = 2
    description = "Vypisuje <b>c</b> = 1, pokud se <b>a</b> rovná <b>b</b> (vstup nebo konstanta <b>field_b</b>, je-li zapnuta), jinak 0. <b>not_c</b> je inverzní."
    categories = [DefaultCategories.Boolean, DefaultCategories.Arithmetic]
    inputs = [Input("a", "A"), Input("b", "B")]
    outputs = [Output("not_c", "not C"), Output("c", "C")]
    fields = [BooleanField("field_b", "Použít přímou konstantu", "", False), Fix32Field("b", "B", "", 0)]
    displays = [Display.LED("not_c", "not C"), Display.LED("c", "C")]

class Compare_Int_Greater(Module):
    name = "Porovnání: A > B"
    symbol = "A>B"
    width = 2
    description = "Vypisuje <b>c</b> = 1, pokud je <b>a</b> ostře větší než <b>b</b> (vstup nebo konstanta <b>field_b</b>, je-li zapnuta), jinak 0. <b>not_c</b> je inverzní."
    categories = [DefaultCategories.Boolean, DefaultCategories.Arithmetic]
    inputs = [Input("a", "A"), Input("b", "B")]
    outputs = [Output("not_c", "not C"), Output("c", "C")]
    fields = [BooleanField("field_b", "Použít přímou konstantu", "", False), Fix32Field("b", "B", "", 0)]
    displays = [Display.LED("not_c", "not C"), Display.LED("c", "C")]

class Compare_Int_GreaterOrEqual(Module):
    name = "Porovnání: A ≥ B"
    symbol = "A≥B"
    width = 2
    description = "Vypisuje <b>c</b> = 1, pokud je <b>a</b> větší nebo rovno <b>b</b> (vstup nebo konstanta <b>field_b</b>, je-li zapnuta), jinak 0. <b>not_c</b> je inverzní."
    categories = [DefaultCategories.Boolean, DefaultCategories.Arithmetic]
    inputs = [Input("a", "A"), Input("b", "B")]
    outputs = [Output("not_c", "not C"), Output("c", "C")]
    fields = [BooleanField("field_b", "Použít přímou konstantu", "", False), Fix32Field("b", "B", "", 0)]
    displays = [Display.LED("not_c", "not C"), Display.LED("c", "C")]

class Compare_Int_LessGreater(Module):
    name = "Compare: A vs B"
    symbol = "A<>B"
    width = 2
    description = "Combined less/greater compare. Drives <b>L</b> (Lesser) and <b>G</b> (Greater) at the same time so you don't need three modules to cover &lt;, &gt;, =. The <b>mode</b> field picks the encoding: 0 = binary 0/1 flags (default; L=1 when A&lt;B, G=1 when A&gt;B); 1 = positive 0/1/2 (0 = equal, 1 = own match, 2 = inverse); 2 = sumup -1/0/+1 (G is +1 when A&gt;B and -1 when A&lt;B, L is its negation). <b>field_b</b> switches <b>b</b> to a constant."
    categories = [DefaultCategories.Boolean, DefaultCategories.Arithmetic]
    inputs = [Input("a", "A"), Input("b", "B")]
    outputs = [Output("l", "L (Lesser)"), Output("g", "G (Greater)")]
    fields = [BooleanField("field_b", "Override input 'b'", "", False), Fix32Field("b", "B", "", 0), Int32Field("mode", "Mode", "", 0)]
    displays = [Display.Text("l", "L", ""), Display.Text("g", "G", "")]

class Compare_Int_Lower(Module):
    name = "Porovnání: A < B"
    symbol = "A<B"
    width = 2
    description = "Vypisuje <b>c</b> = 1, pokud je <b>a</b> ostře menší než <b>b</b> (vstup nebo konstanta <b>field_b</b>, je-li zapnuta), jinak 0. <b>not_c</b> je inverzní."
    categories = [DefaultCategories.Boolean, DefaultCategories.Arithmetic]
    inputs = [Input("a", "A"), Input("b", "B")]
    outputs = [Output("not_c", "not C"), Output("c", "C")]
    fields = [BooleanField("field_b", "Použít přímou konstantu", "", False), Fix32Field("b", "B", "", 0)]
    displays = [Display.LED("not_c", "not C"), Display.LED("c", "C")]

class Compare_Int_LowerOrEqual(Module):
    name = "Porovnání: A ≤ B"
    symbol = "A≤B"
    width = 2
    description = "Vypisuje <b>c</b> = 1, pokud je <b>a</b> menší nebo rovno <b>b</b> (vstup nebo konstanta <b>field_b</b>, je-li zapnuta), jinak 0. <b>not_c</b> je inverzní."
    categories = [DefaultCategories.Boolean, DefaultCategories.Arithmetic]
    inputs = [Input("a", "A"), Input("b", "B")]
    outputs = [Output("not_c", "not C"), Output("c", "C")]
    fields = [BooleanField("field_b", "Použít přímou konstantu", "", False), Fix32Field("b", "B", "", 0)]
    displays = [Display.LED("not_c", "not C"), Display.LED("c", "C")]

class Connection_AnimalFarm(Module):
    name = "Connection: Animal Farm"
    symbol = "A-FARM"
    width = 4
    description = "Drives and reads the linked animal <b>farm</b> (chicken farm, cattle ranch, …). Outputs the operating <b>state</b> (0 paused, 1 working, 2 missing workers, 3 missing food, 4 missing water, 5 no animals, 6 full output), the current <b>slaughter</b> slider step (-1 when slaughtering is off) and the <b>starving</b> / <b>nowater</b> (missing-water) flags. Writes the slaughter slider step from the <b>slaughter</b> input/field (0–10, &lt;0 turns slaughtering off) and breeding from the <b>growth</b> input/field (0 allow, &gt;0 pause); each write only happens while its pin is wired or its override toggle is on, so an unconnected module never fights the manual UI. Optional output extensions expose animals <b>born</b> and <b>carcass</b> produced per month. Animal head-count / capacity and the food / water / produce levels are intentionally omitted — read them with the Connection: Storage (STOCK) module by setting its watched product. Errors if no animal farm is linked."
    categories = [DefaultCategories.ConnectionRead]
    inputs = [Input("slaughter", "Slaughter step (0-10, <0 = off)"), Input("growth", "Breeding (0 allow, >0 pause)")]
    outputs = [Output("state", "State (0-6)"), Output("slaughter", "Slaughter step"), Output("starving", "Animals starving (0/1)"), Output("nowater", "Missing water (0/1)")]
    fields = [BooleanField("field_slaughter", "Override input 'slaughter'", "", False), Int32Field("slaughter", "Slaughter step (0-10, <0 = off)", "", -1), BooleanField("field_growth", "Override input 'growth'", "", False), Int32Field("growth", "Breeding (0 allow, >0 pause)", "", 0)]
    displays = [Display.Icon("animal", "Animals", ""), Display.Text("count", "Count", ""), Display.Text("slaughter", "Slaughter", ""), Display.Icon("feed", "Animal feed", ""), Display.Icon("water", "Water", "")]

class Connection_Boost_Set(Module):
    name = "Připojení: Unity Boost"
    symbol = "BST"
    width = 1
    description = "Řídí stav Unity boostu připojené <b>entity</b> ze vstupu <b>boost</b> nebo z pole <b>boost</b> (přepínač <b>field_boost</b>) a aktuální požadavek odráží na výstupu <b>boost</b>. Chyba, pokud entita podporující boost není připojena nebo budova nemá BoostCost."
    categories = [DefaultCategories.ConnectionRead]
    inputs = [Input("boost", "Unity boost aktivní")]
    outputs = [Output("boost", "Unity boost aktivní")]
    fields = [BooleanField("field_boost", "Nastavit boost podle nastavení", "", False), BooleanField("boost", "Nastavit boost podle nastavení", "", False)]
    displays = [Display.Icon("boost", "Boost", "")]

class Connection_Controller_Input(Module):
    name = "Připojení: Řadič (4 piny, vstup)"
    symbol = "C-IN"
    width = 4
    description = "Čte 4 piny z párového modulu <b>Connection_Controller_Output</b> na vzdáleném řadiči, párováno podle pole <b>name</b>. Vypisuje vzdálené vstupy <b>a</b>, <b>b</b>, <b>c</b>, <b>d</b>; pokud žádný odpovídající modul neexistuje, vrací 0."
    categories = [DefaultCategories.ConnectionRead]
    inputs = []
    outputs = [Output("a", "A"), Output("b", "B"), Output("c", "C"), Output("d", "D")]
    fields = [StringField("name", "Název výstupu", "", "C")]
    displays = [Display.Text("name", "Název spojení", "")]

class Connection_Controller_Output(Module):
    name = "Připojení: Řadič (4 piny, výstup)"
    symbol = "C-OUT"
    width = 4
    description = "Vystavuje 4 vstupy (<b>a</b>, <b>b</b>, <b>c</b>, <b>d</b>) pod jménem nastaveným v poli <b>name</b>, aby je vzdálený modul <b>Connection_Controller_Input</b> mohl číst. Funguje jako pasivní koncový bod – neřídí žádnou entitu."
    categories = [DefaultCategories.ConnectionRead]
    inputs = [Input("a", "A"), Input("b", "B"), Input("c", "C"), Input("d", "D")]
    outputs = []
    fields = [StringField("name", "Název", "", "C")]
    displays = [Display.Text("name", "Název spojení", "")]

class Connection_Datacenter_Racks(Module):
    name = "Připojení: Datové centrum – Racky"
    symbol = "RACK"
    width = 2
    description = "Řídí počet racků připojeného datového centra podle vstupu/pole <b>target</b> – chová se jako síťový přepínač, který zapíná a vypíná racky podle potřeby. Při každém tiku modul přidává racky (spotřebovává zvolený produkt racku ze skladu) nebo je odebírá (vrací produkt), dokud počet neodpovídá cíli. Typ racku přichází z prototypového pole/vstupu <b>rack</b>; pokud není nastaven, modul znovu použije typ, který už je v datovém centru nainstalován, a v krajním případě sáhne po prvním odemčeném ServerRackProto. Vypisuje aktuální <b>count</b> a <b>capacity</b>. Pro běh přepínací logiky spotřebovává 1 jednotku výpočetního výkonu. Chyba, pokud není připojeno žádné datové centrum."
    categories = [DefaultCategories.ConnectionRead]
    inputs = [Input("target", "Cílový počet racků"), Input("rack", "Typ racku")]
    outputs = [Output("count", "Aktuální počet racků"), Output("capacity", "Kapacita")]
    fields = [BooleanField("field_target", "Přepsat vstup 'target'", "", False), Int32Field("target", "Cílový počet racků", "", 0), BooleanField("field_rack", "Přepsat vstup 'rack'", "", False)]
    displays = [Display.Text("value", "Racky", "")]

class Connection_Display(Module):
    name = "Připojení: Displej – aktivní"
    symbol = "DIA"
    width = 1
    description = "Spojuje světla a displej pro aktivaci"
    categories = [DefaultCategories.Devices, DefaultCategories.DevicesDisplay]
    inputs = [Input("active", "Aktivovat displej")]
    outputs = []
    fields = [BooleanField("field_active", "Aktivovat displej", "", False), BooleanField("active", "Aktivovat displej", "", False)]

class Connection_Display_16SEG_B(Module):
    name = "Připojení: Displej – 16segmentový (2 vstupy)"
    symbol = "16-SEG"
    width = 2
    description = "Rozsvítí 16segmentový displej a aktivuje čáry podle bitů jediného čísla"
    categories = [DefaultCategories.Devices, DefaultCategories.DevicesDisplay]
    inputs = [Input("N", "Bity"), Input("DP", "Tečka")]
    outputs = []
    fields = [BooleanField("field_N", "Kódované číslo (Bity, 0–65 535)", "", False), Int32Field("N", "Kódované číslo (Bity, 0–65 535)", "", 0), BooleanField("field_DP", "Tečka", "", False), BooleanField("DP", "Tečka", "", False)]
    displays = [Display.Text("bits", "Bity", "")]

class Connection_Display_7SEG_8(Module):
    name = "Připojení: Displej – 7segmentový (8 vstupů)"
    symbol = "7-SEGMENT"
    width = 8
    description = "Rozsvítí 7segmentový displej a aktivuje čáry podle signálu"
    categories = [DefaultCategories.Devices, DefaultCategories.DevicesDisplay]
    inputs = [Input("A", "A"), Input("B", "B"), Input("C", "C"), Input("D", "D"), Input("E", "E"), Input("F", "F"), Input("G", "G"), Input("DP", "Tečka")]
    outputs = []
    fields = [BooleanField("field_A", "Signál: A", "", False), BooleanField("A", "Signál: A", "", False), BooleanField("field_B", "Signál: B", "", False), BooleanField("B", "Signál: B", "", False), BooleanField("field_C", "Signál: C", "", False), BooleanField("C", "Signál: C", "", False), BooleanField("field_D", "Signál: D", "", False), BooleanField("D", "Signál: D", "", False), BooleanField("field_E", "Signál: E", "", False), BooleanField("E", "Signál: E", "", False), BooleanField("field_F", "Signál: F", "", False), BooleanField("F", "Signál: F", "", False), BooleanField("field_G", "Signál: G", "", False), BooleanField("G", "Signál: G", "", False), BooleanField("field_DP", "Tečka", "", False), BooleanField("DP", "Tečka", "", False)]
    displays = [Display.Text("_", "", ""), Display.Text("bits", "Bity", "")]

class Connection_Display_7SEG_B(Module):
    name = "Připojení: Displej – 7segmentový (2 vstupy)"
    symbol = "7-SEG"
    width = 2
    description = "Rozsvítí 7segmentový displej a aktivuje čáry podle bitů jediného čísla"
    categories = [DefaultCategories.Devices, DefaultCategories.DevicesDisplay]
    inputs = [Input("N", "Bity"), Input("DP", "Tečka")]
    outputs = []
    fields = [BooleanField("field_N", "Kódované číslo (Bity, 0–127)", "", False), Int32Field("N", "Kódované číslo (Bity, 0–127)", "", 0), BooleanField("field_DP", "Tečka", "", False), BooleanField("DP", "Tečka", "", False)]
    displays = [Display.Text("bits", "Bity", "")]

class Connection_Display_Color(Module):
    name = "Připojení: Displej – barva"
    symbol = "CLR"
    width = 1
    description = "Řídí barvu LED připojeného displeje z pole <b>color</b> (když je přepínač <b>field_color</b> zapnutý) nebo ze vstupu <b>color</b>. Nastavuje rozsvícený i ztlumený barevný kanál entity displeje."
    categories = [DefaultCategories.Devices, DefaultCategories.DevicesDisplay]
    inputs = [Input("color", "Aktivovat displej")]
    outputs = []
    fields = [BooleanField("field_color", "Přepsat barvu", "", False)]
    displays = [Display.LED("color", "Barva")]

class Connection_Export_Get(Module):
    name = "Připojení: Export (zjistit)"
    symbol = "EXG"
    width = 1
    description = "Čte logistický režim exportu připojené <b>logistic</b> budovy a vrací <b>mode</b> (0 = auto, 1 = zapnuto, 2 = vypnuto). U budov s jednoduchou logistikou vrací 1 (povoleno) nebo 2 (zakázáno). Chyba, pokud není připojena kompatibilní budova."
    categories = [DefaultCategories.ConnectionRead]
    inputs = []
    outputs = [Output("mode", "Režim exportu:   0 (auto),   1 (zap),   2 (vyp)")]

class Connection_Export_Set(Module):
    name = "Připojení: Export (nastavit)"
    symbol = "EXS"
    width = 1
    description = "Nastaví logistický režim exportu připojené <b>logistic</b> budovy z <b>mode</b> vstupu (0 = auto, 1 = zapnuto, 2 = vypnuto). U budov s jednoduchou logistikou má smysl jen on/off (mode 2 vypíná výstup). Chyba, pokud není připojena kompatibilní budova."
    categories = [DefaultCategories.ConnectionRead]
    inputs = [Input("mode", "Režim exportu:   0 (auto),   1 (zap),   2 (vyp)")]
    outputs = []

class Connection_Farm(Module):
    name = "Připojení: Farma"
    symbol = "FARM"
    width = 4
    description = "Čte a řídí připojenou <b>farm</b>: vypisuje slim-id aktuální plodiny <b>crop</b>, <b>water</b> (importovanou + půdní), <b>fertility</b> (%) a hladinu hnojiva <b>fertilizer</b> (%). Zapisuje cíl <b>fertility</b> a do dalšího slotu zařadí <b>crop</b> ze vstupu (slim-id), GreenManure pokud <b>fertilize</b> > 0, nebo NoCrop. Chyba, pokud farma není připojena nebo plodina je neplatná."
    categories = [DefaultCategories.ConnectionRead]
    inputs = [Input("crop", "Další rostoucí plodina"), Input("fertility", "Cílová úrodnost (výchozí: 100)"), Input("fertilize", "Přiřadit přírodní hnojení (0/1)")]
    outputs = [Output("crop", "Aktuálně rostoucí plodina"), Output("water", "Aktuální hladina vody (včetně nádrže)"), Output("fertility", "Aktuální úrodnost"), Output("fertilizer", "Aktuální hladina hnojiva")]
    displays = [Display.Icon("crop_3", "Plodina 4", ""), Display.Icon("crop_2", "Plodina 3", ""), Display.Icon("crop_1", "Plodina 2", ""), Display.Icon("crop_0", "Plodina 1", "")]

class Connection_Filter_Get(Module):
    name = "Připojení: Filtr (zjistit)"
    symbol = "F-G"
    width = 2
    description = "Čte přiřazené slim-id produktu z připojené <b>entity</b> a vypisuje jej na <b>product</b>. Podporuje sklady, vlakové stanice, jídlo/služby sídliště, nemocnice, virtuální doly a třídičky; vstup/pole <b>index</b> volí přihrádku/slot. Chyba, pokud typ entity není podporován."
    categories = [DefaultCategories.ConnectionRead]
    inputs = [Input("index", "Skladovací přihrádka")]
    outputs = [Output("product", "Typ produktu")]
    fields = [BooleanField("field_index", "Nastavit index podle nastavení", "", False), Int32Field("index", "Skladovací přihrádka", "", 0)]
    displays = [Display.Text("_", "", ""), Display.Icon("product", "Produkt", "")]

class Connection_Filter_Set(Module):
    name = "Připojení: Filtr (nastavit)"
    symbol = "F-S"
    width = 2
    description = "Přiřadí produktový filtr připojené <b>entity</b> ze vstupu <b>product</b> nebo z pole <b>product</b> (přepínač <b>field_product</b>); vstup/pole <b>index</b> volí přihrádku u víceslotových budov. Podporuje sklady, kargo depa, vlakové stanice, jídlo sídliště, nemocnice, věže dolů a třídičky. Chyba, pokud entita není podporována nebo sklad při přepřazení není prázdný."
    categories = [DefaultCategories.ConnectionRead]
    inputs = [Input("index", "Skladovací přihrádka"), Input("product", "Typ produktu")]
    outputs = []
    fields = [BooleanField("field_index", "Nastavit index podle nastavení", "", False), Int32Field("index", "Skladovací přihrádka", "", 0), BooleanField("field_product", "Nastavit produkt podle nastavení", "", False)]
    displays = [Display.Text("index", "Index", ""), Display.Icon("product", "Produkt", "")]

class Connection_Import_Get(Module):
    name = "Připojení: Import (zjistit)"
    symbol = "IMG"
    width = 1
    description = "Čte logistický režim importu připojené <b>logistic</b> budovy a vrací <b>mode</b> (0 = auto, 1 = zapnuto, 2 = vypnuto). U budov s jednoduchou logistikou vrací 1 (povoleno) nebo 2 (zakázáno). Chyba, pokud není připojena kompatibilní budova."
    categories = [DefaultCategories.ConnectionRead]
    inputs = []
    outputs = [Output("mode", "Režim importu:   0 (auto),   1 (zap),   2 (vyp)")]

class Connection_Import_Set(Module):
    name = "Připojení: Import (nastavit)"
    symbol = "IMS"
    width = 1
    description = "Nastaví logistický režim importu připojené <b>logistic</b> budovy z <b>mode</b> vstupu (0 = auto, 1 = zapnuto, 2 = vypnuto). U budov s jednoduchou logistikou má smysl jen on/off (mode 2 vypíná vstup). Chyba, pokud není připojena kompatibilní budova."
    categories = [DefaultCategories.ConnectionRead]
    inputs = [Input("mode", "Režim importu:   0 (auto),   1 (zap),   2 (vyp)")]
    outputs = []

class Connection_IsActive(Module):
    name = "Připojení: Stav"
    symbol = "STAT"
    width = 4
    description = "Čte provozní stav připojené <b>entity</b>. Vypisuje <b>power</b> (1, pokud má dostatek elektřiny nebo elektřinu nepotřebuje), <b>workers</b> (1, pokud je obsazeno nebo nevyžaduje pracovníky), <b>constructed</b> (1, pokud je stavba dokončena) a <b>pause</b> (1, pokud je entita pozastavena). Chyba, pokud není připojena žádná entita."
    categories = [DefaultCategories.ConnectionRead]
    inputs = []
    outputs = [Output("power", "Má dostatek elektřiny"), Output("workers", "Má dostatek pracovníků"), Output("constructed", "Je postaveno"), Output("pause", "Je pozastaveno")]
    displays = [Display.Icon("power", "Elektřina", ""), Display.Icon("workers", "Pracovníci", ""), Display.LED("constructed", "Postaveno"), Display.Icon("pause", "Pozastaveno", "")]

class Connection_NuclearReactor(Module):
    name = "Připojení: Jaderný reaktor"
    symbol = "NR"
    width = 4
    description = "Čte a řídí připojený NuclearReactor: vypisuje <b>heat</b>, příznak <b>meltdown</b> a aktuální <b>power</b>; nastavuje cílovou hladinu výkonu z <b>target</b> vstupu (omezeno na maximum reaktoru). Pokud je vstup <b>breed_control</b> zapnutý, aplikuje <b>breed_step</b> na obohacovací cyklus. Chyba, pokud reaktor není připojen."
    categories = [DefaultCategories.ConnectionRead]
    inputs = [Input("breed_control", "Řídit obohacování"), Input("breed_step", "Krok obohacování"), Input("target", "Cílová úroveň výkonu")]
    outputs = [Output("heat", "Uložené teplo"), Output("meltdown", "Je v havárii"), Output("power", "Aktuální výkon")]
    fields = [BooleanField("field_breeding", "Řídit obohacování", "", False)]
    displays = [Display.Text("power", "Výkon", ""), Display.LED("meltdown", "Havárie"), Display.Icon("breading", "Obohacování", "")]

class Connection_Office_Edict(Module):
    name = "Připojení: Kancelář – Edikt"
    symbol = "EDICT"
    width = 2
    description = "Udržuje úroveň zvoleného <b>ediktu</b> na připojené Kapitánské kanceláři podle vstupu/pole <b>level</b>. Úroveň 0 edikt vypne; vyšší úrovně postupně aktivují další stupně v řetězci ediktu. Vypisuje aktuální <b>level</b> a <b>active</b> (1 pokud je nejvyšší povolený stupeň skutečně v účinnosti, 0 pokud je blokován předpoklady jako Unity, výzkum nebo požadavek pokročilé kanceláře). Ikona ediktu má zelený okraj, pokud je aktivní, červený pokud je blokována. Povolením rozšíření výstupu <b>max</b> také zpřístupníte délku řetězce a přepnete zobrazení na formát <b>x|n</b>."
    categories = [DefaultCategories.ConnectionRead]
    inputs = [Input("level", "Cílová úroveň")]
    outputs = [Output("active", "Aktivní"), Output("level", "Aktuální úroveň")]
    fields = [BooleanField("field_level", "Přepsat vstup 'level'", "", False), Int32Field("level", "Cílová úroveň", "", 0)]
    displays = [Display.Icon("icon", "Edikt", ""), Display.Text("level", "Úroveň", "")]

class Connection_Priority_Get(Module):
    name = "Připojení: Priorita (zjistit)"
    symbol = "P-G"
    width = 1
    description = "Čte obecnou prioritu (1–15) připojené <b>building</b> a vypisuje ji na <b>priority</b>. Chyba, pokud není připojena budova s prioritou."
    categories = [DefaultCategories.ConnectionRead]
    inputs = []
    outputs = [Output("priority", "Priorita: 1 – 15")]

class Connection_Priority_Set(Module):
    name = "Připojení: Priorita (nastavit)"
    symbol = "P-S"
    width = 1
    description = "Nastaví obecnou prioritu (1–15) připojené <b>logistic</b> budovy ze vstupu <b>priority</b> (výchozí 8, pokud není připojen). Chyba, pokud není připojena budova s prioritou."
    categories = [DefaultCategories.ConnectionRead]
    inputs = [Input("priority", "Priorita: 1 – 15")]
    outputs = []

class Connection_Recipe_Set(Module):
    name = "Připojení: Recept (nastavit)"
    symbol = "REC-S"
    width = 2
    description = "Přiřadí připojené <b>entity</b> Machine recept zvolený v poli <b>recipe</b>, pokud je <b>on</b> true (vstup nebo pole <b>on</b>, přepínač <b>field_on</b>). Smaže existující přiřazení a znovu jej nastaví; pokud je <b>on</b> false, neudělá nic. Chyba, pokud stroj není připojen, recept není zvolen nebo jej nelze přiřadit."
    categories = [DefaultCategories.ConnectionRead]
    inputs = [Input("on", "Aktivní recept")]
    outputs = []
    fields = [BooleanField("field_on", "Aktivní recept", "", False), BooleanField("on", "Aktivní recept", "", False)]

class Connection_Settlement(Module):
    name = "Připojení: Sídliště (populace)"
    symbol = "SETTLE"
    width = 2
    description = "Čte připojený SettlementHousingModule <b>entity</b>. Vypisuje <b>pop_this</b> (populace v tomto bytovém modulu) a <b>pop_nearby</b> (populace nadřazeného sídliště, případně tohoto modulu). Vypisuje 0, pokud bydlení není připojeno."
    categories = [DefaultCategories.ConnectionRead, DefaultCategories.Stats]
    inputs = [Input("product", "První produkt v #")]
    outputs = [Output("pop_this", "Populace (modul sídliště)"), Output("pop_nearby", "Populace (celé sídliště)")]

class Connection_Speaker(Module):
    name = "Připojení: Reproduktor – přehrát"
    symbol = "SPK"
    width = 1
    description = "Řídí stav přehrávání entity Speaker pomocí vstupu <b>play</b> nebo pole <b>play</b> (boolean, ovládáno přepínačem <b>field_play</b>). Chyba, pokud v poli <b>speaker</b> není připojen reproduktor."
    categories = [DefaultCategories.Devices, DefaultCategories.DevicesSound]
    inputs = [Input("play", "Aktivovat zvuk")]
    outputs = []
    fields = [BooleanField("field_play", "Aktivovat zvuk", "", False), BooleanField("play", "Aktivovat zvuk", "", False)]

class Connection_Station_TrainInfo(Module):
    name = "Připojení: Stanice"
    symbol = "ST-TR"
    width = 4
    description = "Čte a přepíná připojenou <b>station</b> (TrainStationBase). Vypisuje <b>instation</b> (1, pokud je přítomen vlak ze skupiny stanice) a u stanic s moduly <b>cargo</b> (1 = nakládání, 2 = vykládání). Vstup <b>direction</b> přepíná modul mezi nakládáním (1) a vykládáním (2). Chyba, pokud stanice není připojena."
    categories = [DefaultCategories.ConnectionRead]
    inputs = [Input("direction", "Přepnout směr: 1 - Nakládá 2 - Vykládá")]
    outputs = [Output("instation", "Ve stanici"), Output("cargo", "Pracuje: 1 - Nakládá 2 - Vykládá")]
    displays = [Display.Text("_", "", ""), Display.LED("instation", "Ve stanici"), Display.Icon("cargo", "Nakládá / Vykládá", "")]

class Connection_Storage(Module):
    name = "Připojení: Sklad"
    symbol = "STOCK"
    width = 4
    description = "Čte připojenou skladovou <b>entity</b> (sklady, vstupní/výstupní zásobníky, virtuální doly, FlyWheels, ThermalStorage, sídla, Kapitánskou kancelář, libovolný počítačový generátor — Mainframe / DataCenter — který poskytuje síťové součty výpočetního výkonu, nebo výzkumnou laboratoř, která poskytuje globálně aktuálně zkoumaný výzkum z ResearchManager). Vypisuje <b>quantity</b>, <b>capacity</b>, <b>fullness</b> (%) a slim-id uloženého <b>product</b> (id výzkumného uzlu při připojení k laboratoři). S nastaveným <b>field_product</b> filtruje zásobníky podle zvoleného <b>product</b>."
    categories = [DefaultCategories.ConnectionRead]
    inputs = [Input("product", "Produkt")]
    outputs = [Output("quantity", "Množství"), Output("capacity", "Kapacita"), Output("fullness", "Plnost v %"), Output("product", "Produkt v #")]
    fields = [BooleanField("field_product", "Produkt", "", False)]
    displays = [Display.Text("quantity", "Množství", ""), Display.Text("fullness", "Plnost", ""), Display.Icon("product", "Produkt", "")]

class Connection_Storage_Flow_In_Get(Module):
    name = "Připojení: Tok (vstup, zjistit)"
    symbol = "FG"
    width = 1
    description = ""
    categories = [DefaultCategories.ConnectionRead, DefaultCategories.Control]
    inputs = []
    outputs = [Output("p", "Procento")]
    displays = [Display.Text("p", "Procento", "")]

class Connection_Storage_Flow_In_Set(Module):
    name = "Připojení: Tok (vstup, nastavit)"
    symbol = "FS"
    width = 2
    description = ""
    categories = [DefaultCategories.ConnectionRead, DefaultCategories.Control]
    inputs = [Input("p", "Procento")]
    outputs = []
    displays = [Display.Text("_", "", ""), Display.Icon("t", "Typ", "")]

class Connection_Storage_Flow_Out_Get(Module):
    name = "Připojení: Tok (výstup, zjistit)"
    symbol = "FG"
    width = 1
    description = ""
    categories = [DefaultCategories.ConnectionRead, DefaultCategories.Control]
    inputs = []
    outputs = [Output("p", "Procento")]
    displays = [Display.Text("p", "Procento", "")]

class Connection_Storage_Flow_Out_Set(Module):
    name = "Připojení: Tok (výstup, nastavit)"
    symbol = "FS"
    width = 2
    description = ""
    categories = [DefaultCategories.ConnectionRead, DefaultCategories.Control]
    inputs = [Input("p", "Procento")]
    outputs = []
    displays = [Display.Text("_", "", ""), Display.Icon("t", "Typ", "")]

class Connection_Storage_Logistics_In_Get(Module):
    name = "Připojení: Logistika (vstup, zjistit)"
    symbol = "LG"
    width = 1
    description = ""
    categories = [DefaultCategories.ConnectionRead, DefaultCategories.Control]
    inputs = []
    outputs = [Output("p", "Procento")]
    displays = [Display.Text("p", "Procento", "")]

class Connection_Storage_Logistics_In_Set(Module):
    name = "Připojení: Logistika (vstup, nastavit)"
    symbol = "LS"
    width = 2
    description = ""
    categories = [DefaultCategories.ConnectionRead, DefaultCategories.Control]
    inputs = [Input("p", "Procento")]
    outputs = []
    displays = [Display.Text("_", "", ""), Display.Icon("t", "Typ", "")]

class Connection_Storage_Logistics_Out_Get(Module):
    name = "Připojení: Logistika (výstup, zjistit)"
    symbol = "LG"
    width = 1
    description = ""
    categories = [DefaultCategories.ConnectionRead, DefaultCategories.Control]
    inputs = []
    outputs = [Output("p", "Procento")]
    displays = [Display.Text("p", "Procento", "")]

class Connection_Storage_Logistics_Out_Set(Module):
    name = "Připojení: Logistika (výstup, nastavit)"
    symbol = "LS"
    width = 2
    description = ""
    categories = [DefaultCategories.ConnectionRead, DefaultCategories.Control]
    inputs = [Input("p", "Procento")]
    outputs = []
    displays = [Display.Text("_", "", ""), Display.Icon("t", "Typ", "")]

class Connection_SwitchOff(Module):
    name = "Připojení: Vypnutí"
    symbol = "S"
    width = 1
    description = "Pozastaví nebo obnoví připojenou <b>entity</b> podle vstupu <b>pause</b> (>0 pozastaví, jinak obnoví). Podporuje libovolnou pozastavitelnou budovu a CargoDepots (předá zakotvené CargoShip). Chyba, pokud <b>entity</b> není nastavena nebo není podporována."
    categories = [DefaultCategories.ConnectionRead]
    inputs = [Input("pause", "Pauza")]
    outputs = []

class Connection_Transport(Module):
    name = "Připojení: Doprava"
    symbol = "TRANS"
    width = 4
    description = "Doprava nebo přístav připojitelný kabelem ve vzdálenosti 40 m od řadiče. Při připojení k přístavu čte náklad přiřazené lodi — množství/kapacita jsou nulové, dokud je loď pryč, a výstup 'Pohybuje se' je 1, kdykoli loď NENÍ zakotvena."
    categories = [DefaultCategories.ConnectionRead]
    inputs = [Input("direction", "Přepnout směr: 1 - z bližšího portu do vzdáleného 2 - ze vzdáleného portu do bližšího"), Input("product", "Filtr produktů")]
    outputs = [Output("quantity", "Množství"), Output("capacity", "Kapacita"), Output("fullness", "Plnost v %"), Output("moving", "Pohybuje se")]
    fields = [BooleanField("fullstack", "Omezit plnost na 100 %", "", False), BooleanField("field_product", "Produkt", "", False)]
    displays = [Display.Text("quantity", "Množství", ""), Display.Text("fullness", "Plnost", ""), Display.LED("moving", "Pohybuje se")]

class Connection_Vehicle_Get(Module):
    name = "Připojení: Počet vozidel (zjistit)"
    symbol = "V-G"
    width = 4
    description = "Čte počet vozidel přiřazených připojené <b>building</b>. Pokud je zvolen typ vozidla přes vstup <b>vehicle</b> nebo pole <b>vehicle</b> (přepínač <b>field_vehicle</b>), vrací počet daného typu na <b>count</b>; jinak vrací celkový počet všech přiřazených vozidel. Chyba, pokud budova není připojena nebo typ není platný."
    categories = [DefaultCategories.ConnectionRead]
    inputs = [Input("vehicle", "Typ vozidla")]
    outputs = [Output("count", "Počet vozidel")]
    fields = [BooleanField("field_vehicle", "Vybrat podle nastavení", "", False)]

class Connection_Vehicle_Set(Module):
    name = "Připojení: Počet vozidel (nastavit)"
    symbol = "V-S"
    width = 4
    description = "Nastaví počet vozidel přiřazených budově; ve výchozím stavu bere vozidla ze všech zón."
    categories = [DefaultCategories.ConnectionRead]
    inputs = [Input("count", "Počet vozidel"), Input("vehicle", "Typ vozidla")]
    outputs = []
    fields = [BooleanField("field_vehicle", "Vybrat typ podle nastavení", "", False), BooleanField("field_count", "Nastavit počet podle nastavení", "", False), Int32Field("count", "Počet vozidel", "", 0)]

class Constant(Module):
    name = "Konstanta (celé číslo)"
    symbol = "#I"
    width = 1
    description = "Vypisuje celé číslo uložené v poli <b>number</b> na výstup <b>value</b>. Slouží jako zdroj literálu v aritmetických řetězcích."
    categories = [DefaultCategories.Arithmetic, DefaultCategories.Constants]
    inputs = []
    outputs = [Output("value", "Hodnota")]
    fields = [Int32Field("number", "Číslo", "", 0)]
    displays = [Display.Text("number", "Hodnota", "")]

class Constant_Boolean(Module):
    name = "Konstanta (boolean)"
    symbol = "#B"
    width = 1
    description = "Vypisuje 1, pokud je pole <b>boolean</b> zaškrtnuto, jinak 0. Hodnota výstupu je Fix32 s hodnotou 0 nebo 1."
    categories = [DefaultCategories.Arithmetic, DefaultCategories.Constants]
    inputs = []
    outputs = [Output("value", "Hodnota")]
    fields = [BooleanField("boolean", "Boolean", "", False)]
    displays = [Display.LED("boolean", "Zap")]

class Constant_Crop(Module):
    name = "Konstanta (plodina)"
    symbol = "#C"
    width = 1
    description = "Vypisuje slim-id plodiny zvolené v poli <b>crop</b> na výstup <b>value</b>. Pole je pomocí FarmProductFilter omezené pouze na plodiny."
    categories = [DefaultCategories.Arithmetic, DefaultCategories.Constants]
    inputs = []
    outputs = [Output("value", "Hodnota")]
    displays = [Display.Icon("crop", "Plodina", "")]

class Constant_Float(Module):
    name = "Konstanta (desetinné číslo)"
    symbol = "#F"
    width = 1
    description = "Vypisuje desetinné číslo uložené v poli <b>float</b> na výstup <b>value</b>. Použijte při potřebě zlomkových konstant (např. poměrů, násobitelů)."
    categories = [DefaultCategories.Arithmetic, DefaultCategories.Constants]
    inputs = []
    outputs = [Output("value", "Hodnota")]
    fields = [Fix32Field("float", "Float", "", 0)]
    displays = [Display.Text("number", "Hodnota", "")]

class Constant_Hex(Module):
    name = "Konstanta (hex)"
    symbol = "#H"
    width = 1
    description = "Vypisuje šestnáctkové celé číslo uložené v poli <b>number</b> na výstup <b>value</b>. Užitečné jako zdroj bitové masky pro logické/bitové operace."
    categories = [DefaultCategories.Arithmetic, DefaultCategories.Constants]
    inputs = []
    outputs = [Output("value", "Hodnota")]
    fields = [Int32Field("number", "Číslo", "", 0)]
    displays = [Display.Text("number", "Hodnota", "")]

class Constant_Machine(Module):
    name = "Konstanta (stroj)"
    symbol = "#M"
    width = 1
    description = "Vypisuje id MachineProto zvolené v poli <b>machine</b> na výstup <b>value</b>. Slouží k identifikaci typu stroje pro navazující propojovací moduly."
    categories = [DefaultCategories.Arithmetic, DefaultCategories.Constants]
    inputs = []
    outputs = [Output("value", "Hodnota")]
    displays = [Display.Icon("machine", "Stroj", "")]

class Constant_Product(Module):
    name = "Konstanta (produkt)"
    symbol = "#P"
    width = 1
    description = "Vypisuje slim-id produktu zvoleného v poli <b>product</b> na výstup <b>value</b>. Kombinujte s filtračními/třídicími moduly k identifikaci typu produktu."
    categories = [DefaultCategories.Arithmetic, DefaultCategories.Constants]
    inputs = []
    outputs = [Output("value", "Hodnota")]
    displays = [Display.Icon("product", "Produkt", "")]

class Constant_Vehicle(Module):
    name = "Konstanta (vozidlo)"
    symbol = "#V"
    width = 1
    description = "Vypisuje id DrivingEntityProto (vozidla) zvolené v poli <b>vehicle</b> na výstup <b>value</b>. Slouží k identifikaci typu vozidla pro navazující propojovací moduly."
    categories = [DefaultCategories.Arithmetic, DefaultCategories.Constants]
    inputs = []
    outputs = [Output("value", "Hodnota")]
    displays = [Display.Icon("vehicle", "vozidlo", "")]

class Control_Relay(Module):
    name = "Relé"
    symbol = "RELAY"
    width = 2
    description = "Hradlovaný průchod: když je <b>enable</b> nenulový (nebo nepřipojený — vstup je výchozí povolen), každý vstup je zkopírován na výstup stejné pozice; když je <b>enable</b> 0, všechny výstupy jsou drženy na 0. Základní pár je <b>A</b>; rozšíření vstupů a výstupů rostou současně, takže N-tý vstup se vždy páruje s N-tým výstupem bez ohledu na to, kolik jich přidáte. První sloupec výstupů je úmyslně prázdný — sedí pod vstupem <b>enable</b>, který nemá odpovídající výstup."
    categories = [DefaultCategories.Decision, DefaultCategories.Control]
    inputs = [Input("enable", "Povolit"), Input("a", "A")]
    outputs = [Output("a", "A")]
    displays = [Display.LED("active", "Aktivní"), Display.Text("a", "A", "")]

class Decision_Select(Module):
    name = "Výběr (rozšiřitelný)"
    symbol = "SEL"
    width = 4
    description = "Směruje první vstupní pin <b>A</b>..<b>F</b>, jehož prahové pole je >= <b>index</b>, na <b>selected</b>; na výstup <b>matched</b> přichází celé číslo 0..5 odpovídajícího pinu. Pokud žádný práh nesouhlasí, <b>selected</b> přebírá vstup <b>else</b> a <b>matched</b> vrací -1. Rozšíření pravým okrajem zvyšuje počet volitelných pinů z 2 až na 6; zobrazení indexu se roztáhne až na 16 buněk pro velké hodnoty."
    categories = [DefaultCategories.Decision, DefaultCategories.Control]
    inputs = [Input("index", "Index"), Input("a", "A"), Input("b", "B")]
    outputs = [Output("matched", "Pin"), Output("selected", "Vybráno")]
    fields = [Int32Field("a", "A", "", 0), Int32Field("b", "B", "", 1), Int32Field("c", "C", "", 2), Int32Field("d", "D", "", 3), Int32Field("e", "E", "", 4), Int32Field("f", "F", "", 5)]
    displays = [Display.Text("index", "Index", "")]

class Display_Bool(Module):
    name = "Displej: LED"
    symbol = "F-B"
    width = 1
    description = "Rozsvítí LED na displeji <b>a</b>, když je vstup <b>a</b> větší než 0; jinak je LED vypnutá. Jakákoli kladná číselná hodnota je považována za pravdivou."
    categories = [DefaultCategories.Display]
    inputs = [Input("a", "Produkt")]
    outputs = []
    displays = [Display.LED("a", "Produkt")]

class Display_Entity(Module):
    name = "Displej: entita"
    symbol = "F-E"
    width = 1
    description = "Vykreslí ikonu prototypu entity, na který odkazuje vstup <b>a</b> (stroj, vozidlo apod.), na displej <b>a</b>. Užitečné pro vizuální identifikaci typů entit."
    categories = [DefaultCategories.Display]
    inputs = [Input("a", "Entita")]
    outputs = []
    displays = [Display.Icon("a", "Entita", "")]

class Display_Int(Module):
    name = "Display: number"
    symbol = "F#"
    width = 2
    description = "Formats input <b>a</b> as a decimal number display.  Use the <b>+</b> / <b>-</b> buttons in the display row to grow the digit count (4 digits at minimum, up to 32 by adding cells); the <b>float</b> field picks how many of those digits are fractional."
    categories = [DefaultCategories.Display]
    inputs = [Input("a", "A")]
    outputs = []
    fields = [Int32Field("float", "Floating numbers", "", 0)]
    displays = [Display.Text("a", "A", "")]

class Display_Product(Module):
    name = "Displej: produkt"
    symbol = "F-P"
    width = 1
    description = "Vykreslí ikonu produktu, jehož slim-id přijde na vstup <b>a</b>, na displej <b>a</b>. Slouží k vizuální identifikaci aktuálního produktu v řetězci."
    categories = [DefaultCategories.Display]
    inputs = [Input("a", "Produkt")]
    outputs = []
    displays = [Display.Icon("a", "Produkt", "")]

class Divide(Module):
    name = "C = A děleno B"
    symbol = "A/B"
    width = 2
    description = "Vypočítá <b>a</b> / <b>b</b> na <b>c</b>. Pokud je <b>b</b> nula, nastaví výstup <b>error</b> na 1 a <b>c</b> na Fix32.MaxValue; jinak je <b>error</b> 0. Přepínač <b>field_b</b> přepne <b>b</b> na konstantní pole."
    categories = [DefaultCategories.Arithmetic]
    inputs = [Input("a", "A"), Input("b", "B")]
    outputs = [Output("c", "C"), Output("error", "Chyba")]
    fields = [BooleanField("field_b", "Použít přímou konstantu", "", False), Fix32Field("b", "B", "", 0)]

class Fork_2(Module):
    name = "Rozdvojka: 1 pin na 2"
    symbol = "F-2"
    width = 2
    description = "Slouží k organizaci propojení pinů. Použití není povinné, výstup lze připojit na více vstupů"
    inputs = [Input("a", "A")]
    outputs = [Output("a", "A"), Output("b", "B")]

class Fork_4(Module):
    name = "Rozdvojka: 1 pin na 4"
    symbol = "F-4"
    width = 4
    description = "Slouží k organizaci propojení pinů. Použití není povinné, výstup lze připojit na více vstupů"
    inputs = [Input("a", "A")]
    outputs = [Output("a", "A"), Output("b", "B"), Output("c", "C"), Output("d", "D")]

class Game_Pause(Module):
    name = "Pozastavit hru (DEBUG)"
    symbol = "GP"
    width = 1
    description = "Modul pouze pro ladění: pokud vstup <b>pause</b> > 0, požádá GameSpeedController o globální pozastavení hry a rozsvítí informační indikátor."
    categories = [DefaultCategories.Control]
    inputs = [Input("pause", "Pauza")]
    outputs = []

class Invert(Module):
    name = "B = -A"
    symbol = "-A"
    width = 1
    description = "Vypisuje aritmetickou negaci <b>a</b> (tj. <b>0 - a</b>) na <b>b</b>. Slouží k převrácení znaménka číselného signálu."
    categories = [DefaultCategories.Arithmetic]
    inputs = [Input("a", "A")]
    outputs = [Output("b", "B")]

class Modulo(Module):
    name = "C = A modulo B"
    symbol = "A%B"
    width = 2
    description = "Vypočítá <b>a</b> % <b>b</b> na <b>c</b>. Pokud je <b>b</b> nula, nastaví výstup <b>error</b> na 1 a <b>c</b> na 0; jinak je <b>error</b> 0. Přepínač <b>field_b</b> přepne <b>b</b> na konstantní pole."
    categories = [DefaultCategories.Arithmetic]
    inputs = [Input("a", "A"), Input("b", "B")]
    outputs = [Output("c", "C"), Output("error", "Chyba")]
    fields = [BooleanField("field_b", "Použít přímou konstantu", "", False), Fix32Field("b", "B", "", 0)]

class Multiply(Module):
    name = "C = A násobeno B"
    symbol = "A*B"
    width = 2
    description = "Vypočítá <b>a</b> * <b>b</b> na <b>c</b>. Pokud je přepínač <b>field_b</b> zapnutý, jako násobitel se místo vstupního pinu použije konstanta z pole <b>b</b>."
    categories = [DefaultCategories.Arithmetic]
    inputs = [Input("a", "A"), Input("b", "B")]
    outputs = [Output("c", "C")]
    fields = [BooleanField("field_b", "Použít přímou konstantu", "", False), Fix32Field("b", "B", "", 0)]

class Notification_Error(Module):
    name = "Notifikace: Chyba"
    symbol = "NOTIF ERR"
    width = 2
    description = "Vrací stav Chyba, dokud je vstup <b>in</b> zapnutý, takže řadič vyvolá chybovou notifikaci; jinak vrací Běží."
    categories = [DefaultCategories.Display]
    inputs = [Input("in", "Stav")]
    outputs = []

class Notification_Info(Module):
    name = "Notifikace: Info"
    symbol = "NOTIF INF"
    width = 2
    description = "Nastavuje příznak <b>Info</b> řadiče podle vstupu <b>in</b>; řadič zobrazí informační notifikaci, dokud je vstup zapnutý."
    categories = [DefaultCategories.Display]
    inputs = [Input("in", "Stav")]
    outputs = []

class Notification_Warning(Module):
    name = "Notifikace: Varování"
    symbol = "NOTIF WRN"
    width = 2
    description = "Nastavuje příznak <b>Warning</b> řadiče podle vstupu <b>in</b>; řadič zobrazí varovnou notifikaci, dokud je vstup zapnutý."
    categories = [DefaultCategories.Display]
    inputs = [Input("in", "Stav")]
    outputs = []

class PLC_PY(Module):
    name = "Vlastní: PLC (Python)"
    symbol = "PLC-PY"
    width = 4
    description = "Programovatelný logický řadič řízený hráčem — varianta Python. Napište Python skript do pole <b>code</b>, který čte <b>self.Input</b>, zapisuje do <b>self.Output</b> a přistupuje k <b>self.Field</b>/<b>self.Display</b>/<b>self.Array</b> jako kterýkoli jiný modul. Skript může používat sekce <b>init:</b> (spustí se jednou / při obnově) a <b>main:</b> (spustí se každý tik); definice <b>def</b> mimo sekce na nejvyšší úrovni jsou sdílené mezi nimi. Výpočetní náročnost roste s velikostí skriptu (0,5 + 0,01 za token lexeru); vyžaduje údržbu T3."
    categories = [DefaultCategories.Control]
    inputs = [Input("A", "A"), Input("B", "B"), Input("C", "C"), Input("D", "D")]
    outputs = [Output("A", "A"), Output("B", "B"), Output("C", "C"), Output("D", "D")]
    fields = [StringField("name", "Název", "", "PLC-PY"), StringField("code", "Kód", "", "")]
    displays = [Display.LED("status", "Stav (LED)"), Display.Text("label", "Název modulu", "")]

class Radio_In_AM(Module):
    name = "AM přijímač"
    symbol = "AM-R"
    width = 2
    description = "Čte AM kanál zvolený v poli <b>am</b> přes připojenou <b>antena</b> a vypisuje přijatou hodnotu na <b>am</b>. Chyba a vrací 0, pokud anténa není připojena."
    categories = [DefaultCategories.Antene, DefaultCategories.AnteneAM]
    inputs = []
    outputs = [Output("am", "AM signál")]
    displays = [Display.Text("am", "Frekvence", "")]

class Radio_In_FM_16(Module):
    name = "FM přijímač (16 signálů)"
    symbol = "FM-R"
    width = 16
    description = "Naslouchá na FM kanálu z pole <b>fm</b> a vysílá až 16 signálů na výstupy <b>a</b>..<b>p</b>, plus sílu příjmu na <b>signal</b> a název kanálu ID3 na displej <b>id3</b>. Mimo dosah vrací nulu."
    categories = [DefaultCategories.Antene, DefaultCategories.AnteneFM]
    inputs = []
    outputs = [Output("a", "A"), Output("b", "B"), Output("c", "C"), Output("d", "D"), Output("e", "E"), Output("f", "F"), Output("g", "G"), Output("h", "H"), Output("i", "I"), Output("j", "J"), Output("k", "K"), Output("m", "M"), Output("n", "N"), Output("o", "O"), Output("p", "P"), Output("q", "Q")]
    fields = [BooleanField("logging", "Povolit ladicí výpis antény", "", False)]
    displays = [Display.Text("signal", "Signál", ""), Display.Text("fm", "Frekvence", "")]

class Radio_In_FM_2(Module):
    name = "FM přijímač (2 signály)"
    symbol = "FM-R"
    width = 2
    description = "Naslouchá na FM kanálu z pole <b>fm</b> a vysílá až 2 signály na výstupy <b>a</b>..<b>b</b>, plus sílu příjmu na <b>signal</b> a název kanálu ID3 na displej <b>id3</b>. Mimo dosah vrací nulu."
    categories = [DefaultCategories.Antene, DefaultCategories.AnteneFM]
    inputs = []
    outputs = [Output("a", "A"), Output("b", "B")]
    fields = [BooleanField("logging", "Povolit ladicí výpis antény", "", False)]
    displays = [Display.Text("signal", "Signál", ""), Display.Text("fm", "Frekvence", "")]

class Radio_In_FM_4(Module):
    name = "FM přijímač (4 signály)"
    symbol = "FM-R"
    width = 4
    description = "Naslouchá na FM kanálu z pole <b>fm</b> a vysílá až 4 signály na výstupy <b>a</b>..<b>d</b>, plus sílu příjmu na <b>signal</b> a název kanálu ID3 na displej <b>id3</b>. Mimo dosah vrací nulu."
    categories = [DefaultCategories.Antene, DefaultCategories.AnteneFM]
    inputs = []
    outputs = [Output("a", "A"), Output("b", "B"), Output("c", "C"), Output("d", "D")]
    fields = [BooleanField("logging", "Povolit ladicí výpis antény", "", False)]
    displays = [Display.Text("signal", "Signál", ""), Display.Text("fm", "Frekvence", "")]

class Radio_In_FM_8(Module):
    name = "FM přijímač (8 signálů)"
    symbol = "FM-R"
    width = 8
    description = "Naslouchá na FM kanálu z pole <b>fm</b> a vysílá až 8 signálů na výstupy <b>a</b>..<b>h</b>, plus sílu příjmu na <b>signal</b> a název kanálu ID3 na displej <b>id3</b>. Mimo dosah vrací nulu."
    categories = [DefaultCategories.Antene, DefaultCategories.AnteneFM]
    inputs = []
    outputs = [Output("a", "A"), Output("b", "B"), Output("c", "C"), Output("d", "D"), Output("e", "E"), Output("f", "F"), Output("g", "G"), Output("h", "H")]
    fields = [BooleanField("logging", "Povolit ladicí výpis antény", "", False)]
    displays = [Display.Text("signal", "Signál", ""), Display.Text("fm", "Frekvence", "")]

class Radio_Out_AM(Module):
    name = "AM vysílač"
    symbol = "AM-B"
    width = 2
    description = "Vysílá vstup <b>am</b> na AM kanálu zvoleném v poli <b>am</b> přes připojenou <b>antena</b>. Přeskakuje, pokud je anténa vypnutá nebo pozastavená; chyba, pokud není připojena."
    categories = [DefaultCategories.Antene, DefaultCategories.AnteneAM]
    inputs = [Input("am", "AM signál")]
    outputs = []
    displays = [Display.Text("am", "Frekvence", "")]

class Radio_Out_FM_16(Module):
    name = "FM vysílač (16 signálů)"
    symbol = "FM-B"
    width = 16
    description = "Vysílá až 16 vstupních signálů (<b>a</b>..<b>p</b>) na FM kanálu z pole <b>fm</b> přes připojenou <b>antena</b> a označuje proud polem <b>id3</b>. Chyba, pokud anténa není připojena."
    categories = [DefaultCategories.Antene, DefaultCategories.AnteneFM]
    inputs = [Input("a", "A"), Input("b", "B"), Input("c", "C"), Input("d", "D"), Input("e", "E"), Input("f", "F"), Input("g", "G"), Input("h", "H"), Input("i", "I"), Input("j", "J"), Input("k", "K"), Input("m", "M"), Input("n", "N"), Input("o", "O"), Input("p", "P"), Input("q", "Q")]
    outputs = []
    fields = [StringField("id3", "ID3 (název)", "", ""), BooleanField("logging", "Povolit ladicí výpis antény", "", False)]
    displays = [Display.Text("fm", "Frekvence", "")]

class Radio_Out_FM_2(Module):
    name = "FM vysílač (2 signály)"
    symbol = "FM-B"
    width = 2
    description = "Vysílá až 2 vstupní signály (<b>a</b>..<b>b</b>) na FM kanálu z pole <b>fm</b> přes připojenou <b>antena</b> a označuje proud polem <b>id3</b>. Chyba, pokud anténa není připojena."
    categories = [DefaultCategories.Antene, DefaultCategories.AnteneFM]
    inputs = [Input("a", "A"), Input("b", "B")]
    outputs = []
    fields = [StringField("id3", "ID3 (název)", "", ""), BooleanField("logging", "Povolit ladicí výpis antény", "", False)]
    displays = [Display.Text("fm", "Frekvence", "")]

class Radio_Out_FM_4(Module):
    name = "FM vysílač (4 signály)"
    symbol = "FM-B"
    width = 4
    description = "Vysílá až 4 vstupní signály (<b>a</b>..<b>d</b>) na FM kanálu z pole <b>fm</b> přes připojenou <b>antena</b> a označuje proud polem <b>id3</b>. Chyba, pokud anténa není připojena."
    categories = [DefaultCategories.Antene, DefaultCategories.AnteneFM]
    inputs = [Input("a", "A"), Input("b", "B"), Input("c", "C"), Input("d", "D")]
    outputs = []
    fields = [StringField("id3", "ID3 (název)", "", ""), BooleanField("logging", "Povolit ladicí výpis antény", "", False)]
    displays = [Display.Text("fm", "Frekvence", "")]

class Radio_Out_FM_8(Module):
    name = "FM vysílač (8 signálů)"
    symbol = "FM-B"
    width = 8
    description = "Vysílá až 8 vstupních signálů (<b>a</b>..<b>h</b>) na FM kanálu z pole <b>fm</b> přes připojenou <b>antena</b> a označuje proud polem <b>id3</b>. Chyba, pokud anténa není připojena."
    categories = [DefaultCategories.Antene, DefaultCategories.AnteneFM]
    inputs = [Input("a", "A"), Input("b", "B"), Input("c", "C"), Input("d", "D"), Input("e", "E"), Input("f", "F"), Input("g", "G"), Input("h", "H")]
    outputs = []
    fields = [StringField("id3", "ID3 (název)", "", ""), BooleanField("logging", "Povolit ladicí výpis antény", "", False)]
    displays = [Display.Text("fm", "Frekvence", "")]

class Randomizer(Module):
    name = "Generátor náhodných čísel"
    symbol = "RAN"
    width = 1
    description = "Pseudonáhodný generátor: vysílá deterministickou sekvenci na <b>value</b> seedovanou polem <b>seed</b>; každý tik se posune o vstup <b>addition</b> (výchozí 256). Změna seedu sekvenci restartuje."
    categories = [DefaultCategories.Arithmetic]
    inputs = [Input("addition", "Hodnota zrnitosti")]
    outputs = [Output("value", "Náhodná hodnota")]
    fields = [Int32Field("seed", "Číselný seed", "", 0)]

class Runtime_Clock_1(Module):
    name = "Řízení: Hodiny (1 výstup)"
    symbol = "CLK"
    width = 1
    description = "Vypisuje celočíselný čítač na <b>clock</b>, který se zvyšuje každých <b>clock_period</b> tiků a po dosažení <b>max_count</b> se vrací k nule. Pokud je pole <b>mode</b> zapnuto, místo toho výstup pulzuje pravdou jen na tiku, kdy by se čítač změnil. Volitelný vstup <b>reset</b> drží hodiny na nule a potlačuje výstup, dokud je nenulový; po návratu resetu na nulu se počítání obnoví."
    categories = [DefaultCategories.Control]
    inputs = [Input("reset", "Reset (hold non-zero to freeze at 0)")]
    outputs = [Output("clock", "Hodiny")]
    fields = [BooleanField("mode", "Pulzní režim", "", False), Int32Field("clock_period", "Perioda hodin", "", 1), Int32Field("max_count", "Maximální výstup", "", 2)]

class Runtime_Clock_2(Module):
    name = "Řízení: Hodiny (2 výstupy)"
    symbol = "CLK"
    width = 2
    description = "Vypisuje celočíselný čítač na <b>clock</b>, který se zvyšuje každých <b>clock_period</b> tiků a po dosažení <b>max_count</b> se vrací k nule, plus boolean <b>update</b>, který pulzuje pravdou na každém tiku, kdy se čítač mění. Volitelný vstup <b>reset</b> drží hodiny na nule a potlačuje výstup, dokud je nenulový; po návratu resetu na nulu se počítání obnoví."
    categories = [DefaultCategories.Control]
    inputs = [Input("reset", "Reset (drží na 0, pokud je nenulový)")]
    outputs = [Output("update", "Aktualizováno tento tik"), Output("clock", "Hodiny")]
    fields = [Int32Field("clock_period", "Perioda hodin", "", 1), Int32Field("max_count", "Resetovací hodnota", "", 2)]

class Runtime_Delay_1(Module):
    name = "Řízení: Zpoždění (libovolný počet tiků)"
    symbol = "DLY"
    width = 1
    description = "Zpozdí vstup <b>input</b> o počet tiků nastavený v poli <b>delay</b> a poté vyšle stejný signál na <b>output</b>. Zpoždění 1 (nebo méně) propustí hodnotu beze změny."
    categories = [DefaultCategories.Control]
    inputs = [Input("input", "Vstup signálu")]
    outputs = [Output("output", "Výstup signálu")]
    fields = [Int32Field("delay", "Zpoždění", "", 1)]

class Runtime_Delay_Tap(Module):
    name = "Control: Delay (taps)"
    symbol = "DLY"
    width = 2
    description = "Multi-stage shift register: each output tap holds the input from N ticks ago, where N matches the tap label.  Add more taps from the right edge of the module."
    categories = [DefaultCategories.Control]
    inputs = [Input("0", "Signal input")]
    outputs = [Output("1", "Delay by 1 tick")]

class Runtime_Equal_Selector(Module):
    name = "Control: Equal Selector"
    symbol = "MS"
    width = 2
    description = "Compares <b>main</b> against the connected data inputs (<b>in_0</b>, plus any added extensions); outputs the index of the lowest match on <b>matching_index</b> and sets <b>output</b> to 1.  If nothing matches, <b>matching_index</b> is 99 and <b>output</b> is 0.  Add more input pins from the right edge of the module."
    categories = [DefaultCategories.Control]
    inputs = [Input("main", "Main Input"), Input("in_0", "Input 0")]
    outputs = [Output("matching_index", "Index of equal input"), Output("output", "Match with any input")]

class Runtime_FlipFlop(Module):
    name = "Control: Flip-Flop"
    symbol = "FF"
    width = 2
    description = "When <b>enable</b> is on, copies each connected channel input to the matching output and remembers it; while <b>enable</b> is off, outputs keep their last stored values. Add more channel pin pairs from the right edge of the module."
    categories = [DefaultCategories.Control]
    inputs = [Input("enable", "Enable"), Input("in_1", "A")]
    outputs = [Output("out_1", "A")]
    displays = [Display.Icon("write", "Write Enable", ""), Display.LED("led_1", "Stored A")]

class Runtime_hysteresis(Module):
    name = "Control: Hysteresis"
    symbol = "HYS"
    width = 1
    description = "Uses <b>hysteresis</b> have different threshold for turning a signal on or off."
    categories = [DefaultCategories.Control]
    inputs = [Input("Input", "Input")]
    outputs = [Output("Output", "Output")]
    fields = [Int32Field("High", "High", "", 99), Int32Field("Low", "Low", "", 1), BooleanField("DefaultOutput", "Value while active", "", True)]
    displays = [Display.LED("active", "Active")]

class Runtime_Max(Module):
    name = "Maximum"
    symbol = "MAX"
    width = 2
    description = "Vypisuje nejmenší ze všech připojených vstupů (<b>A</b>, <b>B</b> a libovolných přidaných rozšíření) na <b>min</b> a největší na <b>max</b>. Další vstupní piny (až 8) lze přidat na pravém okraji modulu. Volitelná výstupní rozšíření zveřejňují 0-založený index vstupu s minimem (<b>indexmin</b>) a maximem (<b>indexmax</b>). LED pod každým vstupem svítí zeleně pro vstup s maximem, červeně pro minimum a zůstává šedá, když vstup není ani jedno. Nepřipojené vstupy se počítají jako nula."
    categories = [DefaultCategories.Arithmetic]
    inputs = [Input("A", "A"), Input("B", "B")]
    outputs = [Output("min", "Minimum"), Output("max", "Maximum")]
    displays = [Display.Icon("A", "A", ""), Display.Icon("B", "B", "")]

class Runtime_Memory_Selector_1(Module):
    name = "Řízení: Paměťový selektor (1 vstup)"
    symbol = "MS"
    width = 1
    description = "Pokud je <b>in_1</b> kladný, vypíše hodnotu pole <b>field_1</b>; jinak vypíše pole <b>default</b>. Jednovstupová vyhledávací tabulka."
    categories = [DefaultCategories.Control]
    inputs = [Input("in_1", "Vstup signálu")]
    outputs = [Output("output", "Výstup signálu")]
    fields = [Int32Field("default", "Výchozí", "", 0), Int32Field("field_1", "Hodnota 1", "", 1)]

class Runtime_Memory_Selector_2(Module):
    name = "Řízení: Paměťový selektor (2 vstupy)"
    symbol = "MS"
    width = 2
    description = "Prioritní vyhledávání: vypíše hodnotu <b>field_2</b>, pokud je <b>in_2</b> kladný, jinak <b>field_1</b>, pokud je <b>in_1</b> kladný, jinak pole <b>default</b>. Při shodě vyhrávají vyšší vstupy."
    categories = [DefaultCategories.Control]
    inputs = [Input("in_1", "Vstup 1"), Input("in_2", "Vstup 2")]
    outputs = [Output("output", "Výstup signálu")]
    fields = [Int32Field("default", "Výchozí", "", 0), Int32Field("field_1", "Hodnota 1", "", 1), Int32Field("field_2", "Hodnota 2", "", 2)]

class Runtime_Memory_Selector_4(Module):
    name = "Řízení: Paměťový selektor (4 vstupy)"
    symbol = "MEM SELECT"
    width = 4
    description = "Prioritní vyhledávání: prochází vstupy <b>in_4</b> dolů k <b>in_1</b> a vypíše hodnotu odpovídajícího <b>field_n</b> pro první kladný vstup; jinak použije pole <b>default</b>. Při shodě vyhrávají vyšší vstupy."
    categories = [DefaultCategories.Control]
    inputs = [Input("in_1", "Vstup 1"), Input("in_2", "Vstup 2"), Input("in_3", "Vstup 3"), Input("in_4", "Vstup 4")]
    outputs = [Output("output", "Výstup signálu")]
    fields = [Int32Field("default", "Výchozí", "", 0), Int32Field("field_1", "Hodnota 1", "", 1), Int32Field("field_2", "Hodnota 2", "", 2), Int32Field("field_3", "Hodnota 3", "", 3), Int32Field("field_4", "Hodnota 4", "", 4)]

class Runtime_Memory_Selector_6(Module):
    name = "Řízení: Paměťový selektor (6 vstupů)"
    symbol = "Memory Selector"
    width = 6
    description = "Prioritní vyhledávání: prochází vstupy <b>in_6</b> dolů k <b>in_1</b> a vypíše hodnotu odpovídajícího <b>field_n</b> pro první kladný vstup; jinak použije pole <b>default</b>. Při shodě vyhrávají vyšší vstupy."
    categories = [DefaultCategories.Control]
    inputs = [Input("in_1", "Vstup 1"), Input("in_2", "Vstup 2"), Input("in_3", "Vstup 3"), Input("in_4", "Vstup 4"), Input("in_5", "Vstup 5"), Input("in_6", "Vstup 6")]
    outputs = [Output("output", "Výstup signálu")]
    fields = [Int32Field("default", "Výchozí", "", 0), Int32Field("field_1", "Hodnota 1", "", 1), Int32Field("field_2", "Hodnota 2", "", 2), Int32Field("field_3", "Hodnota 3", "", 3), Int32Field("field_4", "Hodnota 4", "", 4), Int32Field("field_5", "Hodnota 5", "", 5), Int32Field("field_6", "Hodnota 6", "", 6)]

class Runtime_Memory_Selector_8(Module):
    name = "Řízení: Paměťový selektor (8 vstupů)"
    symbol = "Memory Selector"
    width = 8
    description = "Prioritní vyhledávání: prochází vstupy <b>in_8</b> dolů k <b>in_1</b> a vypíše hodnotu odpovídajícího <b>field_n</b> pro první kladný vstup; jinak použije pole <b>default</b>. Při shodě vyhrávají vyšší vstupy."
    categories = [DefaultCategories.Control]
    inputs = [Input("in_1", "Vstup 1"), Input("in_2", "Vstup 2"), Input("in_3", "Vstup 3"), Input("in_4", "Vstup 4"), Input("in_5", "Vstup 5"), Input("in_6", "Vstup 6"), Input("in_7", "Vstup 7"), Input("in_8", "Vstup 8")]
    outputs = [Output("output", "Výstup signálu")]
    fields = [Int32Field("default", "Výchozí", "", 0), Int32Field("field_1", "Hodnota 1", "", 1), Int32Field("field_2", "Hodnota 2", "", 2), Int32Field("field_3", "Hodnota 3", "", 3), Int32Field("field_4", "Hodnota 4", "", 4), Int32Field("field_5", "Hodnota 5", "", 5), Int32Field("field_6", "Hodnota 6", "", 6), Int32Field("field_7", "Hodnota 7", "", 7), Int32Field("field_8", "Hodnota 8", "", 8)]

class Runtime_Shift(Module):
    name = "Control: Shift"
    symbol = "SHIFT"
    width = 3
    description = "Cyclic shifter: <b>index</b> picks how far to rotate the channel inputs (<b>0</b>, <b>1</b>, plus any added extensions) onto the matching outputs.  Output <b>index</b> echoes the wrapped index.  Add more channel pin pairs from the right edge of the module."
    categories = [DefaultCategories.Control]
    inputs = [Input("index", "Index"), Input("0", "Input 0"), Input("1", "Input 1")]
    outputs = [Output("index", "Index"), Output("0", "Output 0"), Output("1", "Output 1")]

class Runtime_Timer(Module):
    name = "Řízení: Časovač"
    symbol = "TMR"
    width = 2
    description = "Počítá nahoru o 1 každý tik na výstupu <b>timer</b>, dokud nedosáhne periody (vstup <b>timer_period</b> nebo pole, ~10 tiků/s); poté se zapne <b>done</b> a čítač se zastaví. Spuštění <b>reset</b> vyčistí <b>timer</b> i <b>done</b>."
    categories = [DefaultCategories.Control]
    inputs = [Input("reset", "Resetovat časovač"), Input("timer_period", "Perioda časovače")]
    outputs = [Output("timer", "Časovač"), Output("done", "Je hotovo")]
    fields = [Int32Field("timer_period", "Perioda časovače (tiky)", "", 1)]

class Stats_Efficiency(Module):
    name = "Statistika: Efektivita"
    symbol = "EFF"
    width = 2
    description = "Čte statistiky produktivity přes IEntityWithProductivityCounter. Hlavní výstup <b>%</b> je procento produktivity (0–100) za posledních 12 měsíců. Počty tiků pro jednotlivé kategorie jsou dostupné jako rozšiřující výstupy <b>A–D</b>; jejich význam závisí na entitě (např. pro stroj: A=Pracuje, B=ChybíVstup, C=PlnýVýstup, D=NemůžePracovat)."
    categories = [DefaultCategories.ConnectionRead, DefaultCategories.Stats]
    inputs = []
    outputs = [Output("percent", "%")]
    displays = [Display.Text("percent", "%", "")]

class Stats_Electricity(Module):
    name = "Statistika: Elektřina"
    symbol = "PWR"
    width = 4
    description = "Čte globální metriky ElectricityManager pro aktuální tik. Vypisuje <b>consumption</b> (DemandedThisTick), <b>production</b> (GeneratedThisTick), <b>capacity</b> (GenerationCapacityThisTick) v kW a <b>usage</b> jako procento 0–100 z consumption / capacity."
    categories = [DefaultCategories.Stats]
    inputs = []
    outputs = [Output("consumption", "Spotřeba"), Output("production", "Produkce"), Output("capacity", "Kapacita výkonu"), Output("demand", "Power demand")]
    displays = [Display.Text("consumption", "Spotřeba", ""), Display.Text("production", "Produkce", ""), Display.Icon("power", "Výkon", "")]

class Stats_Health(Module):
    name = "Statistika: Zdraví"
    symbol = "HLT"
    width = 1
    description = "Čte celokoloniální zdravotní statistiky z PopsHealthManager.HealthStats. Hlavní výstup <b>v</b> je aktuální měsíční procento zdraví (0–100). Rozšiřující výstupy zveřejňují <b>diff</b> (tento měsíc minus minulý měsíc, kladné při zlepšení), <b>disease</b> (zbývající měsíce aktivní nemoci, 0 pokud žádná) a <b>disease_strength</b> (úmrtnost aktivní nemoci v procentech, 0 pokud žádná). Displej zobrazuje ikonu zdraví, šipku trendu, když je zapnuto rozšíření diff, a barevně rozlišené aktuální procento. Chybuje, pokud není připojena nemocnice ani Kapitánská kancelář."
    categories = [DefaultCategories.ConnectionRead, DefaultCategories.Stats]
    inputs = []
    outputs = [Output("v", "Zdraví %")]
    displays = [Display.Icon("health", "Zdraví", "")]

class Stats_Maintenance(Module):
    name = "Připojení: Údržba"
    symbol = "MAINT"
    width = 4
    description = "Čte zásobu údržby v připojeném MaintenanceDepot pro zvolený stupeň (pole <b>m</b>). Vypisuje aktuální <b>a</b> množství, <b>c</b> kapacitu, <b>p</b> procento 0–100 a měsíční <b>u</b> spotřebu (kladný přebytek / záporný deficit)."
    categories = [DefaultCategories.ConnectionRead, DefaultCategories.Stats]
    inputs = []
    outputs = [Output("a", "Množství"), Output("c", "Kapacita"), Output("p", "Procento (0–100)"), Output("u", "Spotřeba (měsíčně +přebytek / -deficit)")]
    displays = [Display.Icon("product", "Produkt", ""), Display.Icon("direction", "Přebytek/Deficit", ""), Display.Text("value", "Hodnota", "")]

class Stats_Unity(Module):
    name = "Připojení: Kancelář – Unity"
    symbol = "UNI"
    width = 1
    description = "Čte aktuální celkové Unity kapitána přes UpointsManager a vypisuje je na <b>v</b>; po rozšíření může číst i maximum <b>max</b>, % <b>percent</b> nebo rozdíl za poslední měsíc <b>diff</b>. Řádek displeje zobrazuje ikonu Unity, šipku trendu (když je aktivní rozšíření diff) a aktuální hodnotu s volitelným procentem (když je aktivní rozšíření percent). Chyba, pokud v poli <b>office</b> není připojena CaptainOffice."
    categories = [DefaultCategories.ConnectionRead, DefaultCategories.Stats]
    inputs = []
    outputs = [Output("v", "Hodnota Unity")]
    displays = [Display.Icon("unity", "Unity", "")]

class Stats_Vehicle(Module):
    name = "Připojení: Kancelář – Vozidla"
    symbol = "VEH"
    width = 2
    description = "Čte statistiky vozidel přes IVehiclesManager. S typem vozidla zvoleným přes vstup nebo pole <b>vehicle</b>: vypisuje <b>count</b> (vlastněná) a <b>assignable</b>. Bez výběru: vypisuje celkový počet flotily na <b>count</b> a 0 na <b>assignable</b>. Chyba, pokud není připojena CaptainOffice."
    categories = [DefaultCategories.ConnectionRead, DefaultCategories.Stats]
    inputs = [Input("vehicle", "Počet vlastněných vozidel/lodí (vše, pokud není vybráno)"), Input("vehicle", "Počet vlastněných vozidel/lodí (vše, pokud není vybráno)")]
    outputs = [Output("count", "Počet vlastněných vozidel/lodí (vše, pokud není vybráno)"), Output("assignable", "Počet přiřaditelných vozidel/lodí (vše, pokud není vybráno)")]
    fields = [BooleanField("field_vehicle", "Vybrat podle nastavení", "", False)]

class Stats_Workers(Module):
    name = "Připojení: Kancelář – Pracovníci"
    symbol = "WRK"
    width = 4
    description = "Čte statistiky pracovníků z WorkersManager. Vypisuje použité <b>u</b>, dostupné <b>a</b>, chybějící <b>m</b> (deficit, kladný při nedostatku) a celkem <b>t = u + a</b>. Chyba, pokud není připojena CaptainOffice."
    categories = [DefaultCategories.ConnectionRead, DefaultCategories.Stats]
    inputs = []
    outputs = [Output("u", "Využití pracovníci"), Output("a", "Dostupní pracovníci"), Output("m", "Chybějící pracovníci"), Output("t", "Celkem pracovníků")]

class Sub(Module):
    name = "C = A - B"
    symbol = "A-B"
    width = 2
    description = "Vypočítá <b>a</b> - <b>b</b> na <b>c</b>. Pokud je přepínač <b>field_b</b> zapnutý, odečítá se konstanta z pole <b>b</b> místo vstupního pinu."
    categories = [DefaultCategories.Arithmetic]
    inputs = [Input("a", "A"), Input("b", "B")]
    outputs = [Output("c", "C")]
    fields = [BooleanField("field_b", "Použít přímou konstantu", "", False), Fix32Field("b", "B", "", 0)]

class Sum(Module):
    name = "C = A + B"
    symbol = "A+B"
    width = 2
    description = "Vypočítá <b>a</b> + <b>b</b> na <b>c</b>. Pokud je přepínač <b>field_b</b> zapnutý, místo vstupního pinu se použije konstanta z pole <b>b</b> (viz FieldOrInput)."
    categories = [DefaultCategories.Arithmetic]
    inputs = [Input("a", "A"), Input("b", "B")]
    outputs = [Output("c", "Součet")]
    fields = [BooleanField("field_b", "Použít přímou konstantu", "", False), Fix32Field("b", "B", "", 0)]

class Variable_Read(Module):
    name = "Proměnná (čtení)"
    symbol = "*C"
    width = 1
    description = "Čte lokální proměnnou řadiče: prohledá stejný řadič na modul <b>Variable_Write</b> se shodným polem <b>name</b> a vypíše jeho <b>value</b> na <b>value</b>. Pokud žádný neexistuje, vrátí 0; chyba, pokud je <b>name</b> prázdné."
    categories = [DefaultCategories.Control, DefaultCategories.Arithmetic]
    inputs = []
    outputs = [Output("value", "Hodnota")]
    fields = [StringField("name", "Název proměnné", "", "")]
    displays = [Display.Text("name", "Název proměnné (měl by být delší)", "")]

class Variable_Write(Module):
    name = "Proměnná (zápis)"
    symbol = "*C"
    width = 1
    description = "Drží lokální proměnnou řadiče pojmenovanou polem <b>name</b>. Ukládá vstup <b>value</b> (nebo konstantu <b>value</b>, je-li <b>field_value</b> zapnuto), aby ji mohl párový <b>Variable_Read</b> na stejném řadiči přečíst. Chyba, pokud je <b>name</b> prázdné."
    categories = [DefaultCategories.Control, DefaultCategories.Arithmetic]
    inputs = [Input("value", "Hodnota")]
    outputs = []
    fields = [StringField("name", "Název proměnné", "", ""), BooleanField("field_value", "Použít přímou konstantu", "", False), Fix32Field("value", "Hodnota", "", 0)]
    displays = [Display.Text("name", "Název proměnné (měl by být delší)", "")]

class VariableNetwork_Read(Module):
    name = "Síťová proměnná (čtení)"
    symbol = "*N"
    width = 1
    description = "Čte globální síťovou proměnnou identifikovanou polem <b>name</b> přes VariableManager a vypisuje její aktuální hodnotu na <b>value</b>. Chyba, pokud je <b>name</b> prázdné."
    categories = [DefaultCategories.Control, DefaultCategories.Arithmetic]
    inputs = []
    outputs = [Output("value", "Hodnota")]
    fields = [StringField("name", "Název proměnné", "", "")]
    displays = [Display.Text("name", "Název proměnné (měl by být delší)", "")]

class VariableNetwork_Write(Module):
    name = "Síťová proměnná (zápis)"
    symbol = "*N"
    width = 1
    description = "Zapíše vstup <b>value</b> (nebo konstantu <b>value</b>, je-li <b>field_value</b> zapnuto) do globální síťové proměnné identifikované polem <b>name</b> přes VariableManager. Chyba, pokud je <b>name</b> prázdné."
    categories = [DefaultCategories.Control, DefaultCategories.Arithmetic]
    inputs = [Input("value", "Hodnota")]
    outputs = []
    fields = [StringField("name", "Název proměnné", "", ""), BooleanField("field_value", "Použít přímou konstantu", "", False), Fix32Field("value", "Hodnota", "", 0)]
    displays = [Display.Text("name", "Název proměnné (měl by být delší)", "")]

