# generated automatically from known prototypes

from Core.template import Template

class Arithmetic_Display_16SEG_B:
    name = "Aritmetika: 16segmentový"
    symbol = "16S-NB"
    width = 2
    description = "Rozsvítí 16segmentový displej a aktivuje čáry podle bitů jediného čísla"
    fields = []
    inputs = [("V", "Číslo")]
    outputs = [("bits", "Bity"),("rest", "Zbytek")]

class Arithmetic_Display_7SEG_B:
    name = "Aritmetika: 7segmentový"
    symbol = "7S-NB"
    width = 2
    description = "Rozsvítí 7segmentový displej a aktivuje čáry podle bitů jediného čísla"
    fields = []
    inputs = [("V", "Číslo")]
    outputs = [("bits", "Bity"),("rest", "Zbytek")]

class Average:
    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."
    fields = [("count", "Počet", "NumberField`1")]
    inputs = [("input", "Vstup")]
    outputs = [("count", "Průměr"),("average", "Průměr")]

class Boolean_And_2:
    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í."
    fields = []
    inputs = [("a", "A"),("b", "B")]
    outputs = [("b", "not C"),("a", "C")]

class Boolean_Latch:
    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>."
    fields = []
    inputs = [("set", "Nastavit"),("reset", "Reset")]
    outputs = [("on", "Uložený signál")]

class Boolean_Not:
    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."
    fields = []
    inputs = [("a", "A")]
    outputs = [("a", "not A")]

class Boolean_Or_2:
    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í."
    fields = []
    inputs = [("a", "A"),("b", "B")]
    outputs = [("b", "not C"),("a", "C")]

class Boolean_Xor:
    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í."
    fields = []
    inputs = [("a", "A"),("b", "B")]
    outputs = [("b", "not C"),("a", "C")]

class Button_1:
    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á."
    fields = []
    inputs = []
    outputs = [("value", "Zap – 1, Vyp – 0")]

class Button_Pass:
    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."
    fields = []
    inputs = [("value", "Hodnota")]
    outputs = [("value", "Hodnota")]

class Compare_Int_Equal:
    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í."
    fields = [("field_b", "Použít přímou konstantu", "BooleanField"),("b", "B", "NumberField`1")]
    inputs = [("a", "A"),("b", "B")]
    outputs = [("not_c", "not C"),("c", "C")]

class Compare_Int_Greater:
    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í."
    fields = [("field_b", "Použít přímou konstantu", "BooleanField"),("b", "B", "NumberField`1")]
    inputs = [("a", "A"),("b", "B")]
    outputs = [("not_c", "not C"),("c", "C")]

class Compare_Int_GreaterOrEqual:
    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í."
    fields = [("field_b", "Použít přímou konstantu", "BooleanField"),("b", "B", "NumberField`1")]
    inputs = [("a", "A"),("b", "B")]
    outputs = [("not_c", "not C"),("c", "C")]

class Compare_Int_LessGreater:
    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."
    fields = [("field_b", "Override input 'b'", "BooleanField"),("b", "B", "NumberField`1"),("mode", "Mode", "NumberField`1")]
    inputs = [("a", "A"),("b", "B")]
    outputs = [("l", "L (Lesser)"),("g", "G (Greater)")]

class Compare_Int_Lower:
    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í."
    fields = [("field_b", "Použít přímou konstantu", "BooleanField"),("b", "B", "NumberField`1")]
    inputs = [("a", "A"),("b", "B")]
    outputs = [("not_c", "not C"),("c", "C")]

class Compare_Int_LowerOrEqual:
    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í."
    fields = [("field_b", "Použít přímou konstantu", "BooleanField"),("b", "B", "NumberField`1")]
    inputs = [("a", "A"),("b", "B")]
    outputs = [("not_c", "not C"),("c", "C")]

class Connection_AnimalFarm:
    name = "Connection: Animal Farm"
    symbol = "A-FARM"
    width = 2
    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."
    fields = [("field_slaughter", "Override input 'slaughter'", "BooleanField"),("slaughter", "Slaughter step (0-10, <0 = off)", "NumberField`1"),("field_growth", "Override input 'growth'", "BooleanField"),("growth", "Breeding (0 allow, >0 pause)", "NumberField`1"),("farm", "Managed animal farm", "EntityField")]
    inputs = [("slaughter", "Slaughter step (0-10, <0 = off)"),("growth", "Breeding (0 allow, >0 pause)")]
    outputs = [("state", "State (0-6)"),("slaughter", "Slaughter step"),("starving", "Animals starving (0/1)"),("nowater", "Missing water (0/1)")]

class Connection_Boost_Set:
    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."
    fields = [("entity", "Připojené zařízení", "EntityField"),("field_boost", "Nastavit boost podle nastavení", "BooleanField"),("boost", "Nastavit boost podle nastavení", "BooleanField")]
    inputs = [("boost", "Unity boost aktivní")]
    outputs = [("boost", "Unity boost aktivní")]

class Connection_Controller_Input:
    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."
    fields = [("controller", "Připojené zařízení", "EntityField"),("name", "Název výstupu", "StringField")]
    inputs = []
    outputs = [("a", "A"),("b", "B"),("c", "C"),("d", "D")]

class Connection_Controller_Output:
    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."
    fields = [("name", "Název", "StringField")]
    inputs = [("a", "A"),("b", "B"),("c", "C"),("d", "D")]
    outputs = []

class Connection_Datacenter_Racks:
    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."
    fields = [("entity", "Datové centrum", "EntityField"),("field_target", "Přepsat vstup 'target'", "BooleanField"),("target", "Cílový počet racků", "NumberField`1"),("field_rack", "Přepsat vstup 'rack'", "BooleanField"),("rack", "Typ racku", "EntityTypeField`1")]
    inputs = [("target", "Cílový počet racků"),("rack", "Typ racku")]
    outputs = [("count", "Aktuální počet racků"),("capacity", "Kapacita")]

class Connection_Display:
    name = "Připojení: Displej – aktivní"
    symbol = "DIA"
    width = 1
    description = "Spojuje světla a displej pro aktivaci"
    fields = [("display", "Displej", "EntityField"),("field_active", "Aktivovat displej", "BooleanField"),("active", "Aktivovat displej", "BooleanField")]
    inputs = [("active", "Aktivovat displej")]
    outputs = []

class Connection_Display_16SEG_B:
    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"
    fields = [("display", "Displej", "EntityField"),("field_N", "Kódované číslo (Bity, 0–65 535)", "BooleanField"),("N", "Kódované číslo (Bity, 0–65 535)", "NumberField`1"),("field_DP", "Tečka", "BooleanField"),("DP", "Tečka", "BooleanField")]
    inputs = [("N", "Bity"),("DP", "Tečka")]
    outputs = []

class Connection_Display_7SEG_8:
    name = "Připojení: Displej – 7segmentový (8 vstupů)"
    symbol = "7-SEGMENT"
    width = 8
    description = "Rozsvítí 7segmentový displej a aktivuje čáry podle signálu"
    fields = [("display", "Displej", "EntityField"),("field_A", "Signál: A", "BooleanField"),("A", "Signál: A", "BooleanField"),("field_B", "Signál: B", "BooleanField"),("B", "Signál: B", "BooleanField"),("field_C", "Signál: C", "BooleanField"),("C", "Signál: C", "BooleanField"),("field_D", "Signál: D", "BooleanField"),("D", "Signál: D", "BooleanField"),("field_E", "Signál: E", "BooleanField"),("E", "Signál: E", "BooleanField"),("field_F", "Signál: F", "BooleanField"),("F", "Signál: F", "BooleanField"),("field_G", "Signál: G", "BooleanField"),("G", "Signál: G", "BooleanField"),("field_DP", "Tečka", "BooleanField"),("DP", "Tečka", "BooleanField")]
    inputs = [("A", "A"),("B", "B"),("C", "C"),("D", "D"),("E", "E"),("F", "F"),("G", "G"),("DP", "Tečka")]
    outputs = []

class Connection_Display_7SEG_B:
    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"
    fields = [("display", "Displej", "EntityField"),("field_N", "Kódované číslo (Bity, 0–127)", "BooleanField"),("N", "Kódované číslo (Bity, 0–127)", "NumberField`1"),("field_DP", "Tečka", "BooleanField"),("DP", "Tečka", "BooleanField")]
    inputs = [("N", "Bity"),("DP", "Tečka")]
    outputs = []

class Connection_Display_Color:
    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."
    fields = [("display", "Displej", "EntityField"),("field_color", "Přepsat barvu", "BooleanField"),("color", "Barva", "ColorField")]
    inputs = [("color", "Aktivovat displej")]
    outputs = []

class Connection_Export_Get:
    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."
    fields = [("logistic", "Logistická budova", "EntityField")]
    inputs = []
    outputs = [("mode", """Režim exportu:
  0 (auto),
  1 (zap),
  2 (vyp)""")]

class Connection_Export_Set:
    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."
    fields = [("logistic", "Logistická budova", "EntityField")]
    inputs = [("mode", """Režim exportu:
  0 (auto),
  1 (zap),
  2 (vyp)""")]
    outputs = []

class Connection_Farm:
    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á."
    fields = [("farm", "Spravovaná farma", "EntityField")]
    inputs = [("crop", "Další rostoucí plodina"),("fertility", "Cílová úrodnost (výchozí: 100)"),("fertilize", "Přiřadit přírodní hnojení (0/1)")]
    outputs = [("crop", "Aktuálně rostoucí plodina"),("water", "Aktuální hladina vody (včetně nádrže)"),("fertility", "Aktuální úrodnost"),("fertilizer", "Aktuální hladina hnojiva")]

class Connection_Filter_Get:
    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."
    fields = [("entity", "Připojené zařízení", "EntityField"),("field_index", "Nastavit index podle nastavení", "BooleanField"),("index", "Skladovací přihrádka", "NumberField`1")]
    inputs = [("index", "Skladovací přihrádka")]
    outputs = [("product", "Typ produktu")]

class Connection_Filter_Set:
    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ý."
    fields = [("entity", "Budova s filtrem", "EntityField"),("field_index", "Nastavit index podle nastavení", "BooleanField"),("index", "Skladovací přihrádka", "NumberField`1"),("field_product", "Nastavit produkt podle nastavení", "BooleanField"),("product", "Filtrovaný produkt", "ProductField")]
    inputs = [("index", "Skladovací přihrádka"),("product", "Typ produktu")]
    outputs = []

class Connection_Import_Get:
    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."
    fields = [("logistic", "Logistická budova", "EntityField")]
    inputs = []
    outputs = [("mode", """Režim importu:
  0 (auto),
  1 (zap),
  2 (vyp)""")]

class Connection_Import_Set:
    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."
    fields = [("logistic", "Logistická budova", "EntityField")]
    inputs = [("mode", """Režim importu:
  0 (auto),
  1 (zap),
  2 (vyp)""")]
    outputs = []

class Connection_IsActive:
    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."
    fields = [("entity", "Připojené zařízení", "EntityField")]
    inputs = []
    outputs = [("power", "Má dostatek elektřiny"),("workers", "Má dostatek pracovníků"),("constructed", "Je postaveno"),("pause", "Je pozastaveno")]

class Connection_NuclearReactor:
    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."
    fields = [("reactor", "Připojený reaktor", "EntityField"),("field_breeding", "Řídit obohacování", "BooleanField")]
    inputs = [("breed_control", "Řídit obohacování"),("breed_step", "Krok obohacování"),("target", "Cílová úroveň výkonu")]
    outputs = [("heat", "Uložené teplo"),("meltdown", "Je v havárii"),("power", "Aktuální výkon")]

class Connection_Office_Edict:
    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>."
    fields = [("office", "Kapitánská kancelář", "EntityField"),("field_level", "Přepsat vstup 'level'", "BooleanField"),("level", "Cílová úroveň", "NumberField`1"),("edict", "Edikt (základní stupeň)", "EntityTypeField`1")]
    inputs = [("level", "Cílová úroveň")]
    outputs = [("active", "Aktivní"),("level", "Aktuální úroveň")]

class Connection_Priority_Get:
    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."
    fields = [("building", "Budova", "EntityField")]
    inputs = []
    outputs = [("priority", "Priorita: 1 – 15")]

class Connection_Priority_Set:
    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."
    fields = [("logistic", "Logistická budova", "EntityField")]
    inputs = [("priority", "Priorita: 1 – 15")]
    outputs = []

class Connection_Recipe_Set:
    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."
    fields = [("entity", "Budova s filtrem", "EntityField"),("field_on", "Aktivní recept", "BooleanField"),("on", "Aktivní recept", "BooleanField"),("recipe", "Recept", "CustomField")]
    inputs = [("on", "Aktivní recept")]
    outputs = []

class Connection_Settlement:
    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."
    fields = [("entity", "Připojené zařízení", "EntityField")]
    inputs = [("product", "První produkt v #")]
    outputs = [("pop_this", "Populace (modul sídliště)"),("pop_nearby", "Populace (celé sídliště)")]

class Connection_Speaker:
    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."
    fields = [("speaker", "Reproduktor", "EntityField"),("field_play", "Aktivovat zvuk", "BooleanField"),("play", "Aktivovat zvuk", "BooleanField")]
    inputs = [("play", "Aktivovat zvuk")]
    outputs = []

class Connection_Station_TrainInfo:
    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."
    fields = [("station", "Vlaková stanice", "EntityField")]
    inputs = [("direction", """Přepnout směr:
1 - Nakládá
2 - Vykládá""")]
    outputs = [("instation", "Ve stanici"),("cargo", """Pracuje:
1 - Nakládá
2 - Vykládá""")]

class Connection_Storage:
    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>."
    fields = [("entity", "Připojený sklad", "EntityField"),("field_product", "Produkt", "BooleanField"),("product", "Produkt", "ProductField")]
    inputs = [("product", "Produkt")]
    outputs = [("quantity", "Množství"),("capacity", "Kapacita"),("fullness", "Plnost v %"),("product", "Produkt v #")]

class Connection_Storage_Flow_In_Get:
    name = "Připojení: Tok (vstup, zjistit)"
    symbol = "FG"
    width = 1
    description = ""
    fields = [("s", "Sklad", "EntityField")]
    inputs = []
    outputs = [("p", "Procento")]

class Connection_Storage_Flow_In_Set:
    name = "Připojení: Tok (vstup, nastavit)"
    symbol = "FS"
    width = 2
    description = ""
    fields = [("s", "Sklad", "EntityField")]
    inputs = [("p", "Procento")]
    outputs = []

class Connection_Storage_Flow_Out_Get:
    name = "Připojení: Tok (výstup, zjistit)"
    symbol = "FG"
    width = 1
    description = ""
    fields = [("s", "Sklad", "EntityField")]
    inputs = []
    outputs = [("p", "Procento")]

class Connection_Storage_Flow_Out_Set:
    name = "Připojení: Tok (výstup, nastavit)"
    symbol = "FS"
    width = 2
    description = ""
    fields = [("s", "Sklad", "EntityField")]
    inputs = [("p", "Procento")]
    outputs = []

class Connection_Storage_Logistics_In_Get:
    name = "Připojení: Logistika (vstup, zjistit)"
    symbol = "LG"
    width = 1
    description = ""
    fields = [("s", "Sklad", "EntityField")]
    inputs = []
    outputs = [("p", "Procento")]

class Connection_Storage_Logistics_In_Set:
    name = "Připojení: Logistika (vstup, nastavit)"
    symbol = "LS"
    width = 2
    description = ""
    fields = [("s", "Sklad / Stanice", "EntityField")]
    inputs = [("p", "Procento")]
    outputs = []

class Connection_Storage_Logistics_Out_Get:
    name = "Připojení: Logistika (výstup, zjistit)"
    symbol = "LG"
    width = 1
    description = ""
    fields = [("s", "Sklad", "EntityField")]
    inputs = []
    outputs = [("p", "Procento")]

class Connection_Storage_Logistics_Out_Set:
    name = "Připojení: Logistika (výstup, nastavit)"
    symbol = "LS"
    width = 2
    description = ""
    fields = [("s", "Sklad / Stanice", "EntityField")]
    inputs = [("p", "Procento")]
    outputs = []

class Connection_SwitchOff:
    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."
    fields = [("entity", "Připojené zařízení", "EntityField")]
    inputs = [("pause", "Pauza")]
    outputs = []

class Connection_Transport:
    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."
    fields = [("entity", "Připojené zařízení", "EntityField"),("fullstack", "Omezit plnost na 100 %", "BooleanField"),("field_product", "Produkt", "BooleanField"),("product", "Produkt", "ProductField")]
    inputs = [("direction", """Přepnout směr:
1 - z bližšího portu do vzdáleného
2 - ze vzdáleného portu do bližšího"""),("product", "Filtr produktů")]
    outputs = [("quantity", "Množství"),("capacity", "Kapacita"),("fullness", "Plnost v %"),("moving", "Pohybuje se")]

class Connection_Vehicle_Get:
    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ý."
    fields = [("building", "Budova", "EntityField"),("field_vehicle", "Vybrat podle nastavení", "BooleanField"),("vehicle", "vozidlo", "EntityTypeField`1")]
    inputs = [("vehicle", "Typ vozidla")]
    outputs = [("count", "Počet vozidel")]

class Connection_Vehicle_Set:
    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."
    fields = [("building", "Budova", "EntityField"),("field_vehicle", "Vybrat typ podle nastavení", "BooleanField"),("vehicle", "vozidlo", "EntityTypeField`1"),("field_count", "Nastavit počet podle nastavení", "BooleanField"),("count", "Počet vozidel", "NumberField`1"),("zone", "Zóna vozidel", "CustomField")]
    inputs = [("count", "Počet vozidel"),("vehicle", "Typ vozidla")]
    outputs = []

class Constant:
    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."
    fields = [("number", "Číslo", "NumberField`1")]
    inputs = []
    outputs = [("value", "Hodnota")]

class Constant_Boolean:
    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."
    fields = [("boolean", "Boolean", "BooleanField")]
    inputs = []
    outputs = [("value", "Hodnota")]

class Constant_Crop:
    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."
    fields = [("crop", "Plodina", "ProductField")]
    inputs = []
    outputs = [("value", "Hodnota")]

class Constant_Float:
    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ů)."
    fields = [("float", "Float", "NumberField`1")]
    inputs = []
    outputs = [("value", "Hodnota")]

class Constant_Hex:
    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."
    fields = [("number", "Číslo", "NumberField`1")]
    inputs = []
    outputs = [("value", "Hodnota")]

class Constant_Machine:
    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."
    fields = [("machine", "Stroj", "EntityTypeField`1")]
    inputs = []
    outputs = [("value", "Hodnota")]

class Constant_Product:
    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."
    fields = [("product", "Produkt", "ProductField")]
    inputs = []
    outputs = [("value", "Hodnota")]

class Constant_Vehicle:
    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."
    fields = [("vehicle", "vozidlo", "EntityTypeField`1")]
    inputs = []
    outputs = [("value", "Hodnota")]

class Control_Relay:
    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."
    fields = []
    inputs = [("enable", "Povolit"),("a", "A")]
    outputs = [("a", "A")]

class Decision_Select:
    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."
    fields = [("threshold_info", "Každá hodnota níže je nejvyšší <b>index</b>, který směruje odpovídající vstupní pin na <b>selected</b> (a vrací jeho pořadí 0..5 na <b>matched</b>). Piny se testují postupně — vítězí první, jehož práh je ≥ <b>index</b>.", "InfoField"),("a", "A", "NumberField`1"),("b", "B", "NumberField`1"),("c", "C", "NumberField`1"),("d", "D", "NumberField`1"),("e", "E", "NumberField`1"),("f", "F", "NumberField`1")]
    inputs = [("index", "Index"),("a", "A"),("b", "B")]
    outputs = [("matched", "Pin"),("selected", "Vybráno")]

class Display_Bool:
    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."
    fields = []
    inputs = [("a", "Produkt")]
    outputs = []

class Display_Entity:
    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."
    fields = []
    inputs = [("a", "Entita")]
    outputs = []

class Display_Int:
    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."
    fields = [("float", "Floating numbers", "NumberField`1")]
    inputs = [("a", "A")]
    outputs = []

class Display_Product:
    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."
    fields = []
    inputs = [("a", "Produkt")]
    outputs = []

class Divide:
    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."
    fields = [("field_b", "Použít přímou konstantu", "BooleanField"),("b", "B", "NumberField`1")]
    inputs = [("a", "A"),("b", "B")]
    outputs = [("c", "C"),("error", "Chyba")]

class Fork_2:
    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ů"
    fields = []
    inputs = [("a", "A")]
    outputs = [("a", "A"),("b", "B")]

class Fork_4:
    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ů"
    fields = []
    inputs = [("a", "A")]
    outputs = [("a", "A"),("b", "B"),("c", "C"),("d", "D")]

class Game_Pause:
    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."
    fields = []
    inputs = [("pause", "Pauza")]
    outputs = []

class Invert:
    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."
    fields = []
    inputs = [("a", "A")]
    outputs = [("b", "B")]

class Modulo:
    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."
    fields = [("field_b", "Použít přímou konstantu", "BooleanField"),("b", "B", "NumberField`1")]
    inputs = [("a", "A"),("b", "B")]
    outputs = [("c", "C"),("error", "Chyba")]

class Multiply:
    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>."
    fields = [("field_b", "Použít přímou konstantu", "BooleanField"),("b", "B", "NumberField`1")]
    inputs = [("a", "A"),("b", "B")]
    outputs = [("c", "C")]

class Notification_Error:
    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ěží."
    fields = []
    inputs = [("in", "Stav")]
    outputs = []

class Notification_Info:
    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ý."
    fields = []
    inputs = [("in", "Stav")]
    outputs = []

class Notification_Warning:
    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ý."
    fields = []
    inputs = [("in", "Stav")]
    outputs = []

class PLC_PY:
    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."
    fields = [("name", "Název", "StringField"),("code", "Kód", "StringField"),("editor", "Upravit kód", "CustomField")]
    inputs = [("A", "A"),("B", "B"),("C", "C"),("D", "D")]
    outputs = [("A", "A"),("B", "B"),("C", "C"),("D", "D")]

class Radio_In_AM:
    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."
    fields = [("am", "AM", "CustomField"),("antena", "Anténa", "EntityField")]
    inputs = []
    outputs = [("am", "AM signál")]

class Radio_In_FM_16:
    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."
    fields = [("fm", "FM", "CustomField"),("id3", "ID3 (název)", "CustomField"),("logging", "Povolit ladicí výpis antény", "BooleanField")]
    inputs = []
    outputs = [("a", "A"),("b", "B"),("c", "C"),("d", "D"),("e", "E"),("f", "F"),("g", "G"),("h", "H"),("i", "I"),("j", "J"),("k", "K"),("m", "M"),("n", "N"),("o", "O"),("p", "P"),("q", "Q")]

class Radio_In_FM_2:
    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."
    fields = [("fm", "FM", "CustomField"),("id3", "ID3 (název)", "CustomField"),("logging", "Povolit ladicí výpis antény", "BooleanField")]
    inputs = []
    outputs = [("a", "A"),("b", "B")]

class Radio_In_FM_4:
    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."
    fields = [("fm", "FM", "CustomField"),("id3", "ID3 (název)", "CustomField"),("logging", "Povolit ladicí výpis antény", "BooleanField")]
    inputs = []
    outputs = [("a", "A"),("b", "B"),("c", "C"),("d", "D")]

class Radio_In_FM_8:
    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."
    fields = [("fm", "FM", "CustomField"),("id3", "ID3 (název)", "CustomField"),("logging", "Povolit ladicí výpis antény", "BooleanField")]
    inputs = []
    outputs = [("a", "A"),("b", "B"),("c", "C"),("d", "D"),("e", "E"),("f", "F"),("g", "G"),("h", "H")]

class Radio_Out_AM:
    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."
    fields = [("am", "AM", "CustomField"),("antena", "Anténa", "EntityField")]
    inputs = [("am", "AM signál")]
    outputs = []

class Radio_Out_FM_16:
    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."
    fields = [("fm", "FM", "CustomField"),("id3", "ID3 (název)", "StringField"),("antena", "Anténa", "EntityField"),("logging", "Povolit ladicí výpis antény", "BooleanField")]
    inputs = [("a", "A"),("b", "B"),("c", "C"),("d", "D"),("e", "E"),("f", "F"),("g", "G"),("h", "H"),("i", "I"),("j", "J"),("k", "K"),("m", "M"),("n", "N"),("o", "O"),("p", "P"),("q", "Q")]
    outputs = []

class Radio_Out_FM_2:
    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."
    fields = [("fm", "FM", "CustomField"),("id3", "ID3 (název)", "StringField"),("antena", "Anténa", "EntityField"),("logging", "Povolit ladicí výpis antény", "BooleanField")]
    inputs = [("a", "A"),("b", "B")]
    outputs = []

class Radio_Out_FM_4:
    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."
    fields = [("fm", "FM", "CustomField"),("id3", "ID3 (název)", "StringField"),("antena", "Anténa", "EntityField"),("logging", "Povolit ladicí výpis antény", "BooleanField")]
    inputs = [("a", "A"),("b", "B"),("c", "C"),("d", "D")]
    outputs = []

class Radio_Out_FM_8:
    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."
    fields = [("fm", "FM", "CustomField"),("id3", "ID3 (název)", "StringField"),("antena", "Anténa", "EntityField"),("logging", "Povolit ladicí výpis antény", "BooleanField")]
    inputs = [("a", "A"),("b", "B"),("c", "C"),("d", "D"),("e", "E"),("f", "F"),("g", "G"),("h", "H")]
    outputs = []

class Randomizer:
    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."
    fields = [("seed", "Číselný seed", "NumberField`1")]
    inputs = [("addition", "Hodnota zrnitosti")]
    outputs = [("value", "Náhodná hodnota")]

class Runtime_Clock_1:
    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í."
    fields = [("mode", "Pulzní režim", "BooleanField"),("clock_period", "Perioda hodin", "NumberField`1"),("max_count", "Maximální výstup", "NumberField`1")]
    inputs = [("reset", "Reset (hold non-zero to freeze at 0)")]
    outputs = [("clock", "Hodiny")]

class Runtime_Clock_2:
    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í."
    fields = [("clock_period", "Perioda hodin", "NumberField`1"),("max_count", "Resetovací hodnota", "NumberField`1")]
    inputs = [("reset", "Reset (drží na 0, pokud je nenulový)")]
    outputs = [("update", "Aktualizováno tento tik"),("clock", "Hodiny")]

class Runtime_Delay_1:
    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."
    fields = [("delay", "Zpoždění", "NumberField`1")]
    inputs = [("input", "Vstup signálu")]
    outputs = [("output", "Výstup signálu")]

class Runtime_Delay_Tap:
    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."
    fields = []
    inputs = [("0", "Signal input")]
    outputs = [("1", "Delay by 1 tick")]

class Runtime_Equal_Selector:
    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."
    fields = []
    inputs = [("main", "Main Input"),("in_0", "Input 0")]
    outputs = [("matching_index", "Index of equal input"),("output", "Match with any input")]

class Runtime_FlipFlop:
    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."
    fields = []
    inputs = [("enable", "Enable"),("in_1", "A")]
    outputs = [("out_1", "A")]

class Runtime_Max:
    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."
    fields = []
    inputs = [("A", "A"),("B", "B")]
    outputs = [("min", "Minimum"),("max", "Maximum")]

class Runtime_Memory_Selector_1:
    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."
    fields = [("default", "Výchozí", "NumberField`1"),("field_1", "Hodnota 1", "NumberField`1")]
    inputs = [("in_1", "Vstup signálu")]
    outputs = [("output", "Výstup signálu")]

class Runtime_Memory_Selector_2:
    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."
    fields = [("default", "Výchozí", "NumberField`1"),("field_1", "Hodnota 1", "NumberField`1"),("field_2", "Hodnota 2", "NumberField`1")]
    inputs = [("in_1", "Vstup 1"),("in_2", "Vstup 2")]
    outputs = [("output", "Výstup signálu")]

class Runtime_Memory_Selector_4:
    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."
    fields = [("default", "Výchozí", "NumberField`1"),("field_1", "Hodnota 1", "NumberField`1"),("field_2", "Hodnota 2", "NumberField`1"),("field_3", "Hodnota 3", "NumberField`1"),("field_4", "Hodnota 4", "NumberField`1")]
    inputs = [("in_1", "Vstup 1"),("in_2", "Vstup 2"),("in_3", "Vstup 3"),("in_4", "Vstup 4")]
    outputs = [("output", "Výstup signálu")]

class Runtime_Memory_Selector_6:
    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."
    fields = [("default", "Výchozí", "NumberField`1"),("field_1", "Hodnota 1", "NumberField`1"),("field_2", "Hodnota 2", "NumberField`1"),("field_3", "Hodnota 3", "NumberField`1"),("field_4", "Hodnota 4", "NumberField`1"),("field_5", "Hodnota 5", "NumberField`1"),("field_6", "Hodnota 6", "NumberField`1")]
    inputs = [("in_1", "Vstup 1"),("in_2", "Vstup 2"),("in_3", "Vstup 3"),("in_4", "Vstup 4"),("in_5", "Vstup 5"),("in_6", "Vstup 6")]
    outputs = [("output", "Výstup signálu")]

class Runtime_Memory_Selector_8:
    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."
    fields = [("default", "Výchozí", "NumberField`1"),("field_1", "Hodnota 1", "NumberField`1"),("field_2", "Hodnota 2", "NumberField`1"),("field_3", "Hodnota 3", "NumberField`1"),("field_4", "Hodnota 4", "NumberField`1"),("field_5", "Hodnota 5", "NumberField`1"),("field_6", "Hodnota 6", "NumberField`1"),("field_7", "Hodnota 7", "NumberField`1"),("field_8", "Hodnota 8", "NumberField`1")]
    inputs = [("in_1", "Vstup 1"),("in_2", "Vstup 2"),("in_3", "Vstup 3"),("in_4", "Vstup 4"),("in_5", "Vstup 5"),("in_6", "Vstup 6"),("in_7", "Vstup 7"),("in_8", "Vstup 8")]
    outputs = [("output", "Výstup signálu")]

class Runtime_Shift:
    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."
    fields = []
    inputs = [("index", "Index"),("0", "Input 0"),("1", "Input 1")]
    outputs = [("index", "Index"),("0", "Output 0"),("1", "Output 1")]

class Runtime_Timer:
    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>."
    fields = [("timer_period", "Perioda časovače (tiky)", "NumberField`1")]
    inputs = [("reset", "Resetovat časovač"),("timer_period", "Perioda časovače")]
    outputs = [("timer", "Časovač"),("done", "Je hotovo")]

class Runtime_hysteresis:
    name = "Control: Hysteresis"
    symbol = "HYS"
    width = 1
    description = "Uses <b>hysteresis</b> have different threshold for turning a signal on or off."
    fields = [("High", "High", "NumberField`1"),("Low", "Low", "NumberField`1"),("DefaultOutput", "Value while active", "BooleanField")]
    inputs = [("Input", "Input")]
    outputs = [("Output", "Output")]

class Stats_Efficiency:
    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)."
    fields = [("entity", "Entita", "EntityField")]
    inputs = []
    outputs = [("percent", "%")]

class Stats_Electricity:
    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."
    fields = []
    inputs = []
    outputs = [("consumption", "Spotřeba"),("production", "Produkce"),("capacity", "Kapacita výkonu"),("demand", "Power demand")]

class Stats_Health:
    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ář."
    fields = [("entity", "Nemocnice nebo Kapitánská kancelář", "EntityField")]
    inputs = []
    outputs = [("v", "Zdraví %")]

class Stats_Maintenance:
    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)."
    fields = [("depot", "Sklad údržby", "EntityField"),("m", "Stupeň údržby", "ProductField")]
    inputs = []
    outputs = [("a", "Množství"),("c", "Kapacita"),("p", "Procento (0–100)"),("u", "Spotřeba (měsíčně +přebytek / -deficit)")]

class Stats_Unity:
    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."
    fields = [("office", "Kapitánská kancelář", "EntityField")]
    inputs = []
    outputs = [("v", "Hodnota Unity")]

class Stats_Vehicle:
    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."
    fields = [("office", "Kapitánská kancelář", "EntityField"),("field_vehicle", "Vybrat podle nastavení", "BooleanField"),("vehicle", "vozidlo", "EntityTypeField`1")]
    inputs = [("vehicle", "Počet vlastněných vozidel/lodí (vše, pokud není vybráno)"),("vehicle", "Počet vlastněných vozidel/lodí (vše, pokud není vybráno)")]
    outputs = [("count", "Počet vlastněných vozidel/lodí (vše, pokud není vybráno)"),("assignable", "Počet přiřaditelných vozidel/lodí (vše, pokud není vybráno)")]

class Stats_Workers:
    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."
    fields = [("office", "Kapitánská kancelář", "EntityField")]
    inputs = []
    outputs = [("u", "Využití pracovníci"),("a", "Dostupní pracovníci"),("m", "Chybějící pracovníci"),("t", "Celkem pracovníků")]

class Sub:
    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."
    fields = [("field_b", "Použít přímou konstantu", "BooleanField"),("b", "B", "NumberField`1")]
    inputs = [("a", "A"),("b", "B")]
    outputs = [("c", "C")]

class Sum:
    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)."
    fields = [("field_b", "Použít přímou konstantu", "BooleanField"),("b", "B", "NumberField`1")]
    inputs = [("a", "A"),("b", "B")]
    outputs = [("c", "Součet")]

class VariableNetwork_Read:
    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é."
    fields = [("name", "Název proměnné", "StringField"),("variables", "Proměnné", "CustomField")]
    inputs = []
    outputs = [("value", "Hodnota")]

class VariableNetwork_Write:
    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é."
    fields = [("name", "Název proměnné", "StringField"),("field_value", "Použít přímou konstantu", "BooleanField"),("value", "Hodnota", "NumberField`1"),("variables", "Proměnné", "CustomField")]
    inputs = [("value", "Hodnota")]
    outputs = []

class Variable_Read:
    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é."
    fields = [("name", "Název proměnné", "StringField")]
    inputs = []
    outputs = [("value", "Hodnota")]

class Variable_Write:
    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é."
    fields = [("name", "Název proměnné", "StringField"),("field_value", "Použít přímou konstantu", "BooleanField"),("value", "Hodnota", "NumberField`1")]
    inputs = [("value", "Hodnota")]
    outputs = []

