# Referenční příručka k unitě OrgInterface

Tato referenční příručka popisuje obsah unity `OrgInterface`, zejména metod rozhraní `IVLFOrganism`. Není určena ke čtení od začátku ke konci, ani k výuce, jak psát organismy, ale k rychlému zjištění přesného významu jednotlivých objektů deklarovaných v unitě `OrgInterface`. Z toho také plyne její strohost a technický jazyk.

## Obsah

- Konstanty
  - `MaxURCount`
- Typy
  - `TMoveDirection`
  - `TOptions`
- Metody rozhraní `IVLFOrganism`
  - `Age`
  - `AllocedURCount`
  - `AllocUR`
  - `Attack`
  - `Build`
  - `Color`
  - `Die`
  - `Digest`
  - `DivCell`
  - `Eat`
  - `Energy`
  - `Exclude`
  - `FoodAt`
  - `FoodIn`
  - `ForeignAllocedURCount`
  - `ForeignUR`
  - `GenCount`
  - `GetOptions`
  - `ChemAt`
  - `Mass`
  - `MaxAge`
  - `MaxMoveDist`
  - `MaxX`
  - `MaxY`
  - `MinX`
  - `MinY`
  - `Move`
  - `OrgAt`
  - `Secrete`
  - `SetColor`
  - `SetForeignUR`
  - `SetUR`
  - `Species`
  - `Spread`
  - `UR`
  - `X`
  - `Y`
- Dodatky
  - Algoritmus distribuce potravy

## Konstanty

### MaxURCount

#### Deklarace

>     const MaxURCount = 256;

#### Popis

> Maximální počet uživatelských registrů, který můžete naalokovat funkcí `AllocUR`.

#### Viz také

> `AllocedURCount`, `AllocUR`, `ForeignAllocedURCount`, `ForeignUR`, `SetForeignUR`, `SetUR`, `UR`

## Typy

### TMoveDirection

#### Deklarace

>     type TMoveDirection = (N, W, S, E);

#### Popis

> Datový typ udávající směr pohybu (`N` = nahoru, `W` = vlevo, `S` = dolů, `E` = vpravo).

#### Viz také

> `Move`

### TOptions

#### Deklarace

>     type
>       TOptions = record
>         FuzzyAttack: Boolean;
>         EnergyPerStep: Integer;
>         DistributeEnergy: Boolean;
>         ChemGoAway: Boolean;
>       end;

#### Popis

> Datový typ používaný funkcí `GetOptions` k získání informací o nastavení simulace. Význam jednotlivých položek je následující:

> `FuzzyAttack`
>   Pokud je `True`, pak vítězem souboje dvou organismů (vyvolaném pomocí `Attack`) je ten z nich, jehož součet hmotnosti a energie je vyšší. Pokud je `False`, o vítězi se rozhoduje pomocí složitějšího algoritmu, který je popsán u funkce `Attack`.
> `EnergyPerStep`
>   Množství energie, které organismus ztratí při každém kroku simulace ("daň za život").
> `DistributeEnergy`
>   Energie vymrhaná na pohyb, útoky apod. se vrací ve formě potravy zpět do prostředí, tj. platí zákon zachování energie.
> `ChemGoAway`
>   Pokud je `True`, chemikálie vyloučené organismy (pomocí `Exclude`) postupně "vyprchávají", tj. hodnoty na políčcích jsou postupně nastavovány na 0. Přesný popis algoritmu vyprchávání není definován. Pokud je `False`, pak jakákoliv chemikálie vyloučená organismem zůstane na příslušném políčku neomezeně dlouho (pokud nebude přepsána jinou chemikálií).

#### Viz také

> `Attack`, `ChemAt`, `Die`, `Energy`, `Exclude`, `GetOptinos`, `Move`

## Metody rozhraní IVLFOrganism

### Age

#### Deklarace

>     function Age: Integer; stdcall;

#### Popis

> Věk organismu, neboli počet kroků simulace od vzniku organismu.

#### Viz také

> `GenCount`, `MaxAge`

### AllocedURCount

#### Deklarace

>     function AllocedURCount: Integer; stdcall;

#### Popis

> Počet právě alokovaných uživatelských registrů.

#### Viz také

> `AllocUR`, `ForeignAllocedURCount`, `ForeignUR`, `MaxURCount`, `SetForeignUR`, `SetUR`, `UR`

### AllocUR

#### Deklarace

>     function AllocUR(Count: Integer): Integer; stdcall;

#### Popis

> Alokuje `Count` uživatelských registrů. Jejich indexy jsou v pak rozsahu `0`..`Count - 1`. Pokud je `Count` < 0 nebo `Count` > `MaxURCount`, pak funkce nic nealokuje a ukončí se.

> Při alokování platí tato pravidla:

> - Pokud bylo před voláním funkce alokováno méně registrů než `Count`, jejich obsah bude zachován a nově přidané registry budou mít hodnotu 0.
> - Pokud bylo před voláním funkce alokováno více registrů než `Count`, bude zachován obsah prvních `Count` registrů.
> - Pokud bylo před voláním funkce alokováno stejně registrů jako `Count`, nic se voláním funkce nezmění.

> Pokud byl organismus vytvořen manuálním přidáním do prostředí, nemá zpočátku alokované žádné uživatelské registry. Pokud byl vytvořen buněčným dělením (funkcí `DivCell`), má zpočátku alokován stejný počet registrů jako rodič a jejich hodnoty jsou nastaveny na 0.

> Funkce vrátí počet alokovaných registrů.

#### Viz také

> `AllocedURCount`, `DivCell`, `ForeignAllocedURCount`, `ForeignUR`, `MaxURCount`, `SetForeignUR`, `SetUR`, `UR`

### Attack

#### Deklarace

>     function Attack: Boolean; stdcall;

#### Popis

> Pokud se na políčku, kde se nachází organismus, nachází i jiný organismus, pak na něj organismus zaútočí. O vítězi útoku se rozhoduje v závislosti na nastavení takto:

> - Pokud je zvolena volba Při útoku silnější organismu vždy zvítězí, pak je vítězem ten organismu, jehož součet hmotnosti a energie je vyšší. Pokud je tento součet stejný, zvítězí libovolný organismus z nich ("libovolností" se myslí, že postup určení vítěze není zveřejněn v API a organismus na něj nesmí spoléhat).
> - Pokud je zvolena volba Při útoku silnější organismus má větší pravděpodobnost vítězství, pak je postup následující:
>   1. Sečte se hmotnost a energie prvního organismu (= S1).
>   2. Sečte se hmotnost a energie druhého organismu (= S2).
>   3. Sečtou se čísla S1 a S2 (= S).
>   4. Vypočte se pravděpodobnost vítězství prvního organismu P1 = S1 / S.
>   5. Vypočte se pravděpodobnost vítězství druhého organismu P2 = S2 / S.
>   6. Vítězem se stane náhodně jeden z organismů s ohledem na příslušné pravděpodobnosti vítězství.

> Od hmotnosti vítězného organismu se po souboji odečte hmotnost poraženého organismu a od energie vítězného organismu se odečte energie poraženého organismu. Pokud je v nastavení zvolena volba Spotřebovanou energii opět distribuovat do prostředí, pak se odečtené množství hmotnosti a energie vrátí do prostředí ve formě potravy (viz Algoritmus vracení potravy do prostředí). Ohlídá se, aby hodnoty nešly do záporných čísel. Poražený organismus umírá (stane se totéž jako po zavolání jeho metody `Die`).

> Pokud se mezi voláními organismus nepohne nebo nerozmnoží, je zaručeno, že funkce `Attack`, `ForeignAllocedURCount`, `ForeignUR`, `OrgAt` a `SetForeignUR` se budou týkat téhož organismu..

> Pokud se útok povedl (organismus vyhrál), funkce vrátí `True`. Pokud se útok nepovedl (organismus zahynul), funkce nevrátí kontrolu zpět do kontrolní procedury (příkazy následující po `Attack` se tedy neprovedou). Pokud se pod organismem žádný jiný organismus nenacházel, funkce vrátí `False`.

#### Viz také

> `Attack`, `ForeignAllocedURCount`, `ForeignUR`, `OrgAt`, `SetForeignUR`, `GetOptions`

### Build

#### Deklarace

>     function Build(Value: Byte): Byte; stdcall;

#### Popis

> Stráví `Value` potravy ze své trávicí vakuoly a přemění ji na hmotu, čímž o `Value` zvýší svoji hmotnost. Množství strávené potravy se sníží v případě, že jí není ve vakuole dostatek nebo když by hmotnost organismu přesáhla maximální mez (255 jednotek).

> Funkce vrátí skutečné množství strávené potravy.

#### Viz také

> `FoodAt`, `Mass`, `Spread`

### Color

#### Deklarace

>     function Color: TColor; stdcall;

#### Popis

> Barva organismu kódovaná v RGB schématu.

#### Viz také

> `SetColor`

### Die

#### Deklarace

>     procedure Die; stdcall;

#### Popis

> Organismus zemře. Pokud je v nastavení zvolena volba Spotřebovanou energii opět distribuovat do prostředí, pak se do prostředí vrátí množství potravy odpovídající součtu hmotnosti, energie a obsahu trávicí vakuoly umírajícího organismu (viz Algoritmus vracení potravy do prostředí).

> Po spuštění příkazu `Die` se už proceduře nevrátí kontrola nad během programu. Příkazy, co následují za ním, se tedy neprovedou.

> Organismus též zemře, pokud po skončení běhu kontrolní procedury je splněna alespoň jedna z následujících podmínek:

> 1. Věk organismu je větší nebo roven maximálnímu věku organismu (`Age` >= `MaxAge`).
> 2. Organismus nemá energii (`Energy` = 0).
> 3. Organismus má nulovou tělesnou hmotnost (`Mass` = 0).

#### Viz také

> `Age`, `Energy`, `GetOptions`, `FoodIn`, `Mass`, `MaxAge`

### Digest

#### Deklarace

>     function Digest(Value: Byte): Byte; stdcall;

#### Popis

> Stráví `Value` potravy ze své trávicí vakuoly a přemění ji na energii. Množství strávené potravy se sníží v případě, že jí není ve vakuole dostatek nebo když by energie organismu přesáhla maximální mez (255 jednotek).

> Funkce vrátí skutečné množství strávené potravy.

#### Viz také

> `Energy`, `FoodAt`

### DivCell

#### Deklarace

>     procedure DivCell; stdcall;

#### Popis

> Rozdělí buňku na dvě. Buněčné dělení je jediná možná forma rozmnožování organismů v The life!. Potomek se objeví na stejném políčku jako rodič a bude mít stejnou barvu. Oba organismy mají poloviční hmotnost původního organismu (`Mass`), poloviční množství potravy v trávicí vakuole (`FoodIn`) a poloviční energii (`Energy`). Generace potomka (`GenCount`) bude o jednotku vyšší než generace rodiče. Potomek bude mít alokován stejný počet uživatelských registrů jako rodič a všechny tyto uživatelské registry budou mít hodnotu 0.

> Program po rozmnožení zaručuje toto:

> - `OrgAt(0, 0)` = `Species`
> - `SetForeignUR` volaná z kontrolní procedury rodiče bude nastavovat uživatelské registry právě zplozenému potomkovi

> Tyto záruky končí ve chvíli zplození nového potomka (v tom případě se přesouvají na něj) nebo ukončením aktuálního kroku simulace. Záruky také nejsou symetrické, tj. neplatí pro volání funkcí z potomka. Není též zaručeno, zda bude kontrolní procedura potomka volána ještě v témže kroku simulace nebo až v kroku následujícím.

#### Viz také

> `AllocedURCount`, `AllocUR`, `Energy`, `FoodIn`, `GenCount`, `Mass`, `OrgAt`, `SetForeignUR`, `UR`

### Eat

#### Deklarace

>     function Eat(Value: Byte): Byte; stdcall;

#### Popis

> Sní `Value` potravy z políčka, na kterém se organismus právě nachází. Množství snědené potravy sníží, je-li jí v políčku pod organismem nedostatek nebo pro ni naopak organismus nemá prostor ve své trávicí vakuole (která pobere maximálně 255 jednotek potravy).

> Funkce vrátí skutečné množství snědené potravy.

#### Viz také

> `FoodAt`, `FoodIn`, `Secrete`

### Energy

#### Deklarace

>     function Energy: Byte; stdcall;

#### Popis

> Množství energie organismu. Energii je možno využít k pohybu nebo k vylučování chemikálií. Pokud organismus po ukončení běhu kontrolní procedury bude mít `Energy` = 0, zahyne.

#### Viz také

> `Digest`, `Exclude`, `GetOptions`, `Move`

### Exclude

#### Deklarace

>     function Exclude(Radius: Integer; Value: Byte): Integer; stdcall;

#### Popis

> Vyloučí v kruhu s poloměrem `Radius` chemikálii `Value`. Na vyloučení se spotřebuje tolik energie, kolik políček je obsah kruhu. Pokud má organismus málo energie, poloměr se sníží na tak malou hodnotu, aby již energie organismu na vyloučení chemikálie stačila.

> Pokud je v nastavení zvolena volba Spotřebovanou energii opět distribuovat do prostředí, pak se energie spotřebovaná na vyloučení chemikálií vrátí do prostředí ve formě potravy (viz Algoritmus vracení potravy do prostředí).

> Funkce vrátí skutečný poloměr kruhu, kde byla chemikálie vyloučena.

#### Viz také

> `GetOptions`, `ChemAt`

### FoodAt

#### Deklarace

>     function FoodAt(AX, AY: Integer): Byte; stdcall;

#### Popis

> Vrací množství potravy na políčku se souřadnicemi `AX`, `AY`. Tyto souřadnice jsou chápány relativně vůči organismu. Pokud je např. organismus na souřadnicích [150, 80] a organismus zavolá funkci `FoodAt` s parametry `AX` = -1 a `AY` = 1, je vrácena hodnota potravy na políčku se souřadnicemi [149,81]. Obě souřadnice musí mít hodnotu -1, 0 nebo 1. Pokud mají jinou hodnotu, funkce vrací 0. Pokud leží zjišťované políčko mimo okraje prostředí, funkce vrací 0. Organismus může díky této funkci získat přehled o potravě na políčku pod sebou a osmi políčcích kolem sebe.

> V dalších verzích se může dosah funkce `FoodAt` zvětšit nebo může být volitelný uživatelem.

#### Viz také

> `Eat`, `OrgAt`, `Secrete`

### FoodIn

#### Deklarace

>     function FoodIn: Byte; stdcall;

#### Popis

> Množství potravy v trávicí vakuole organismu. Tato potrava se dá dále vyžít k proměně na energii nebo tělesnou hmotnost.

#### Viz také

> `Build`, `Digest`, `Eat`, `Energy`, `Mass`, `Secrete`

### ForeignAllocedURCount

#### Deklarace

>     function ForeignAllocedURCount: Integer; stdcall;

#### Popis

> Vrátí počet právě alokovaných uživatelských registrů jiného organismu, který se nachází pod organismem (tzn. má stejné souřadnice). Pokud pod organismem žádný jiný organismus neleží, nedělá nic. Pokud se jich tam naopak nachází víc, vrátí počet registrů toho nejstaršího z nich (tzn. s největším `Age`).

> Pokud se mezi voláními organismus nepohne nebo nerozmnoží, je zaručeno, že funkce `Attack`, `ForeignAllocedURCount`, `ForeignUR`, `OrgAt` a `SetForeignUR` se budou týkat téhož organismu.

> Po rozmnožení organismu je zaručeno, že se bude načítat počet registrů potomka.

> Pokud byl počet uživatelských registrů v pořádku přečten, funkce ho vrátí. Pokud se pod organismem žádný jiný organismus nenacházel, funkce vrátí hodnotu -1.

#### Viz také

> `AllocedURCount`, `AllocUR`, `ForeignUR`, `MaxURCount`, `SetForeignUR`, `SetUR`, `UR`

### ForeignUR

#### Deklarace

>     function ForeignUR(Index: Byte): Integer; stdcall;

#### Popis

> Umožňuje přístup k poli `UR` ("uživatelské registry") jiného organismu, který se nachází pod organismem (tzn. má stejné souřadnice). Simulační program samotný toto pole nechává nedotčené. Pokud pod organismem žádný jiný organismus neleží, nedělá nic. Pokud se jich tam naopak nachází víc, přistupuje k `UR` toho nejstaršího z nich (tzn. s největším `Age`).

> Pokud se mezi voláními organismus nepohne nebo nerozmnoží, je zaručeno, že funkce `Attack`, `ForeignAllocedURCount`, `ForeignUR`, `OrgAt` a `SetForeignUR` se budou týkat téhož organismu.

> Po rozmnožení organismu je zaručeno, že se budou načítat registry potomka.

> Pokud byl uživatelský registr v pořádku přečten, funkce vrátí jeho hodnotu. Pokud se pod organismem žádný jiný organismus nenacházel nebo `Index` neoznačoval alokovaný uživatelský registr, funkce vrátí hodnotu `InvalidUR`.

#### Viz také

> `AllocedURCount`, `AllocUR`, `ForeignAllocedURCount`, `MaxURCount`, `SetForeignUR`, `SetUR`, `UR`

### GenCount

#### Deklarace

>     function GenCount: Integer; stdcall;

#### Popis

> Generace organismu. Organismus přidaný do prostředí bude mít `GenCount` = 0, jeho potomci `GenCount` = 1, jejich potomci `GenCount` = 2 atd.

#### Viz také

> `Age`

### GetOptions

#### Deklarace

>     procedura GetOptions(var Options: TOptions); stdcall;

#### Popis

> Procedura načte do struktury `Options` nastavení simulace The Life!. Přesný význam jednotlivých položek struktury najdete u jejího popisu.

#### Viz také

> `TOptions`

### ChemAt

#### Deklarace

>     function ChemAt(AX, AY: Integer): Byte; stdcall;

#### Popis

> Vrací druh chemikálie na políčku se souřadnicemi `AX`, `AY`. Tyto souřadnice jsou chápány relativně vůči organismu. Pokud je např. organismus na souřadnicích [150, 80] a organismus zavolá funkci `ChemAt` s parametry `AX` = -1 a `AY` = 1, je vrácen druh chemikálie na políčku se souřadnicemi [149,81]. Obě souřadnice musí mít hodnotu -1, 0 nebo 1. Pokud mají jinou hodnotu, funkce vrací 0. Pokud leží zjišťované políčko mimo okraje prostředí, funkce vrací 0. Organismus může díky této funkci získat přehled o chemikáliích na políčku pod sebou a osmi políčcích kolem sebe.

#### Viz také

> `Exclude`, `GetOptions`

### Mass

#### Deklarace

>     function Mass: Byte; stdcall;

#### Popis

> Hmotnost organismu. Pokud organismus po ukončení běhu kontrolní procedury bude mít `Mass` = 0, zahyne.

#### Viz také

> `Build`, `Spread`

### MaxAge

#### Deklarace

>     function MaxAge: Integer; stdcall;

#### Popis

> Maximální věk organismu, kterého může nabýt. Po jeho nabytí zahyne. V aktuální verzi je definován `MaxAge` = `MaxInt`, takže smrt organismu kvůli věku je velmi nepravděpodobná. V příštích verzích může ale být hodnota změněna nebo nastavována volitelně uživatelem.

#### Viz také

> `Age`

### MaxMoveDist

#### Deklarace

>     function MaxMoveDist: Integer; stdcall;

#### Popis

> Maximální délka, o jakou se může organismus pohnout během jednoho kroku simulace.

#### Viz také

> `Move`

### MaxX

#### Deklarace

>     function MaxX: Integer; stdcall;

#### Popis

> Maximální X-ová souřadnice, na kterou se organismus může dostat, neboli šířka prostředí, ve kterém se pohybuje - 1.

#### Viz také

> `MaxY`, `MinX`, `MinY`, `Move`, `X`, `Y`

### MaxY

#### Deklarace

>     function MaxY: Integer; stdcall;

#### Popis

> Maximální Y-ová souřadnice, na kterou se organismus může dostat, neboli výška prostředí, ve kterém se pohybuje - 1.

#### Viz také

> `MaxX`, `MinX`, `MinY`, `Move`, `X`, `Y`

### MinX

#### Deklarace

>     function MinX: Integer; stdcall;

#### Popis

> Minimální X-ová souřadnice, na kterou se organismus může dostat. V současné verzi The Life! bude vrácená hodnota vždy 0.

#### Viz také

> `MaxX`, `MaxY`, `MinY`, `Move`, `X`, `Y`

### MinY

#### Deklarace

>     function MinY: Integer; stdcall;

#### Popis

> Minimální Y-ová souřadnice, na kterou se organismus může dostat. V současné verzi The Life! bude vrácená hodnota vždy 0.

#### Viz také

> `MaxX`, `MaxY`, `MinX`, `Move`, `X`, `Y`

### Move

#### Deklarace

>     function Move(Direction: TMoveDirection; Distance: Integer): Integer; stdcall;

#### Popis

> Pohne se ve směru `Direction` o `Distance` políček. Při pohybu se spotřebuje `Distance * (Mass div 16 + 1)` energie. Vzdálenost se zkrátí v případě, že

> 1. je nedostatek energie,
> 2. pohyb během jednoho kroku simulace by byl delší než stanovený limit (jeho hodnotu lze zjistit pomocí `MaxMoveDist`),
> 3. organismus by se dostal za okraj prostředí.

> Pokud je v nastavení zvolena volba Spotřebovanou energii opět distribuovat do prostředí, pak se energie spotřebovaná na pohyb vrátí do prostředí ve formě potravy (viz Alogritmus vracení potravy do prostředí).

> Funkce vrátí skutečnou vzdálenost, o kterou se organismus pohnul.

#### Viz také

> `GetOptions`, `MaxMoveDist`, `MaxX`, `MaxY`, `MinX`, `MinY`, `Move`, `TMoveDirection`, `X`, `Y`

### OrgAt

#### Deklarace

>     function OrgAt(AX, AY: Integer): PChar; stdcall;

#### Popis

> Vrací druh organismu na políčku se souřadnicemi `AX`, `AY`. Tyto souřadnice jsou chápány relativně vůči organismu. Pokud je např. organismus na souřadnicích [150, 80] a organismus zavolá funkci `OrgAt` s parametry `AX` = -1 a `AY` = 1, je vrácen druh organismu na políčku se souřadnicemi [149,81]. Obě souřadnice musí mít hodnotu -1, 0 nebo 1. Pokud mají jinou hodnotu, funkce vrací prázdný řetězec. Pokud leží zjišťované políčko mimo okraje prostředí, funkce vrací prázdný řetězec. Pokud se na daných souřadnicích nenachází žádný organismus, funkce vrací prázdný řetězec. Pokud se naopak na daných souřadnicích nachází více organismů, je vrácen druh toho nejstaršího z nich (tzn. s největším `Age`). Organismus může díky této funkci získat přehled o organismech na políčku pod sebou osmi políčcích kolem sebe.

> Vrácený řetězec není třeba odalokovávat a je garantováno, že bude platný až do konce běhu kontrolní procedury.

> Pokud se mezi voláními organismus nepohne nebo nerozmnoží, je zaručeno, že funkce `Attack`, `ForeignAllocedURCount`, `ForeignUR`, `OrgAt` a `SetForeignUR` se budou týkat téhož organismu.

> Po rozmnožení organismu je zaručeno, že `OrgAt(0, 0)` = `Species`.

> V dalších verzích se může dosah funkce `OrgAt` zvětšit nebo může být volitelný uživatelem.

#### Viz také

> `Attack`, `FoodAt`, `ForeignAllocedURCount`, `ForeignUR`, `SetForeignUR`, `Species`

### Secrete

#### Deklarace

>     function Secrete(Value: Byte): Byte; stdcall;

#### Popis

> Vyloučí `Value` potravy ze své trávicí vakuoly ven z organismu. Množství přeměněné potravy se sníží v případě, že jí má organismus ve vakuole málo nebo by celkové množství potravy na políčku, kde se organismus nachází, přesáhlo maximální mez (255 jednotek).

> Funkce vrátí skutečné množství vyloučené potravy.

#### Viz také

> `Eat`, `FoodAt`, `FoodIn`

### SetColor

#### Deklarace

>     procedure SetColor(R, G, B: Byte); stdcall;

#### Popis

> Nastaví barvu organismu. Výsledná barva vznikne smísením červené (`R`), zelené (`G`) a modré (`B`).

#### Viz také

> `Color`

### SetForeignUR

#### Deklarace

>     function SetForeignUR(index: Byte; Value: Integer): Boolean; stdcall;

#### Popis

> Nastaví uživatelský registr s indexem `Index` jiného organismu, který se nachází pod organismem (tzn. má stejné souřadnice), na hodnotu `Value`. Pokud pod organismem žádný jiný organismus neleží, nenastavuje nic. Pokud se jich tam naopak nachází víc, nastaví `UR` tomu nejstaršímu z nich (tzn. s největším `Age`).

> Pokus se mezi voláními organismus nepohne nebo nerozmnoží, je zaručeno, že funkce `OrgAt`, `SetForeignUR` a `Attack` se budou týkat téhož organismu.

> Po rozmnožení organismu je zaručeno, že se budou nastavovat registry potomka.

> Pokud byl uživatelský registr v pořádku nastaven, funkce vrátí `True`. Pokud se pod organismem žádný jiný organismus nenacházel nebo `Index` neoznačoval alokovaný uživatelský registr, funkce vrátí `False`.

#### Viz také

> `AllocedURCount`, `AllocUR`, `Attack`, `ForeignAllocedURCount`, `ForeignUR`, `MaxURCount`, `OrgAt`, `SetUR`, `UR`

### SetUR

#### Deklarace

>     procedure SetUR(Index: Byte; Value: Integer); stdcall;

#### Popis

> Nastaví uživatelský registr s indexem `Index` na hodnotu `Value`.

> Pokud byl uživatelský registr v pořádku nastaven, funkce vrátí `True`. Pokud `Index` neoznačoval alokovaný uživatelský registr, funkce vrátí `False`.

#### Viz také

> `AllocedURCount`, `AllocUR`, `ForeignAllocedURCount`, `ForeignUR`, `MaxURCount`, `SetForeignUR`, `UR`

### Species

#### Deklarace

>     function Species: PChar; stdcall;

#### Popis

> Druh organismu, tedy i název jeho knihovny DLL (bez přípony). Nerozlišují se malá a velká písmena.

> Vrácený řetězec není třeba odalokovávat a je garantováno, že bude platný až do konce běhu kontrolní procedury.

#### Viz také

> `OrgAt`

### Spread

#### Deklarace

>     function Spread(Value: Byte): Byte; stdcall;

#### Popis

> Přemění `Value` své tělesné hmoty na potravu v trávicí vakuole. Množství přeměněné hmotnosti se sníží v případě, že organismus má příliš malou hmotnost nebo by potrava ve vakuole přesáhla maximální mez (255 jednotek).

> Funkce vrátí skutečné množství přeměněné tělesné hmoty.

#### Viz také

> `Build`, `FoodIn`, `Mass`

### UR

#### Deklarace

>     function UR(Index: Byte): Integer; stdcall;

#### Popis

> Umožňuje přístup k poli `UR` ("uživatelské registry"), které může každý organismus využít podle své potřeby k uchovávání údajů mezi jednotlivými kroky simulace. Simulační program samotný toto pole nechává nedotčené.

> Před použitím je nutno potřebné registry alokovat funci `AllocUR`.

> Pokud byl organismus vytvořen manuálním přidáním do prostředí, nemá zpočátku alokované žádné uživatelské registry. Pokud byl vytvořen buněčným dělením (funkcí `DivCell`), má zpočátku alokován stejný počet registrů jako rodič a jejich hodnoty jsou nastaveny na 0.

> Pokud `Index` neoznačoval alokovaný uživatelský registr, funkce vrátí hodnotu `InvalidURIndex`, jinak vrátí hodnotu uloženou v příslušném registru.

#### Viz také

> `AllocedURCount`, `AllocUR`, `DivCell`, `ForeignAllocedURCount`, `ForeignUR`, `MaxURCount`, `SetForeignUR`, `SetUR`

### X

#### Deklarace

>     function X: Integer; stdcall;

#### Popis

> X-ová souřadnice organismu. Nabývá hodnot `0`..`MaxX`.

#### Viz také

> `MaxX`, `MaxY`, `MinX`, `MinY`, `Move`, `Y`

### Y

#### Deklarace

>     function Y: Integer; stdcall;

#### Popis

> Y-ová souřadnice organismu. Nabývá hodnot `0`..`MaxY`.

#### Viz také

> `MaxX`, `MaxY`, `MinX`, `MinY`, `Move`, `X`

## Dodatky

### Algoritmus distribuce potravy

Tento algoritmus je uplatňován, pokud je v nastavení zvolena volba Spotřebovanou energii opět distribuovat do prostředí, a organismus provede činnost vedoucí ke ztrátě energie, hmotnosti či obsahu trávicí vakuoly (pohyb, útok, vyloučení chemikálií či smrt).

Pokud se distribuuje energie organismu, děje se tak pomocí tohoto algoritmu:

1. Vybere se náhodné políčko v prostředí.
2. Pokud je na vybraném políčku 255 jednotek potravy, vybere se jiné. Pokud ne na 1000 pokusů nepodaří vybrat políčko s méně než 255 jednotkami potravy, přejde se ke kroku 4.
3. Hodnota potravy na vybraném políčku se o jedničku zvýší.
4. Energie organismu se o jedničku sníží.
5. Pokud má organismus ještě nějakou energii, přejde se na krok 1.

Pokud se distribuuje obsah trávicí vakuoly nebo hmotnost organismu, děje se tak pomocí tohoto algoritmu:

1. Vezme se množství potravy na políčku pod organismem a odečte se od 255. Pokud je výsledek větší, než hmotnost (resp. obsah trávicí vakuoly) organismu, zmenší se tak, aby se jí rovnal.
2. Hodnota potravy na políčku pod organismem se zvýší o hodnotu vypočtenou v kroku 1.
3. Hmotnost (resp. obsah trávicí vakuoly) organismu se sníží o hodnotu vypočtenou v kroku 1.
4. Pokud organismu má nyní nenulovou hmotnost (resp. obsah trávicí vakuoly), je tento zbytek distribuován stejným algoritmem, jako energie.