8927 lines
326 KiB
Plaintext
8927 lines
326 KiB
Plaintext
# SOME DESCRIPTIVE TITLE
|
||
# Copyright (C) YEAR Free Software Foundation, Inc.
|
||
# This file is distributed under the same license as the PACKAGE package.
|
||
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
|
||
msgid ""
|
||
msgstr ""
|
||
"Project-Id-Version: \n"
|
||
"Report-Msgid-Bugs-To: \n"
|
||
"POT-Creation-Date: DATE\n"
|
||
"PO-Revision-Date: 2015-09-14 13:51+0200\n"
|
||
"Last-Translator: Adrian \"Schocker\" Korzeniowski <adikorzeniowski@gmail.com>\n"
|
||
"Language-Team: \n"
|
||
"Language: pl\n"
|
||
"MIME-Version: 1.0\n"
|
||
"Content-Type: text/plain; charset=UTF-8\n"
|
||
"Content-Transfer-Encoding: 8bit\n"
|
||
"X-Generator: Poedit 1.8.4\n"
|
||
|
||
#. type: \b; header
|
||
#: ../E/abstime.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>abstime</code>"
|
||
msgstr "Instrukcja <code>abstime</code>"
|
||
|
||
#. type: Plain text, \t; header
|
||
#: ../E/abstime.txt:2 ../E/acos.txt:2 ../E/aim.txt:2 ../E/asin.txt:2 ../E/atan.txt:2 ../E/atan2.txt:2 ../E/build.txt:14 ../E/buildingenabled.txt:13 ../E/busy.txt:2 ../E/canbuild.txt:13 ../E/canresearch.txt:2 ../E/ceil.txt:2 ../E/cos.txt:2 ../E/deletef.txt:6 ../E/delinfo.txt:2 ../E/destroy.txt:2 ../E/detect.txt:5 ../E/dist.txt:18 ../E/dist2d.txt:2 ../E/do.txt:2 ../E/drop.txt:12 ../E/errmode.txt:5 ../E/factory.txt:2 ../E/fire.txt:10 ../E/flatgrnd.txt:2 ../E/flatspace.txt:2 ../E/floor.txt:2 ../E/for.txt:2 ../E/goto.txt:12 ../E/grab.txt:12 ../E/if.txt:23 ../E/jet.txt:2 ../E/message.txt:2 ../E/move.txt:8 ../E/pencolor.txt:2 ../E/pendown.txt:2 ../E/penup.txt:2 ../E/penwidth.txt:2 ../E/pow.txt:2 ../E/produce.txt:2 ../E/radar.txt:14 ../E/radarall.txt:12 ../E/rand.txt:2 ../E/readln.txt:8 ../E/receive.txt:2 ../E/recycle.txt:2 ../E/research.txt:2 ../E/researched.txt:2 ../E/retobj.txt:2 ../E/round.txt:2 ../E/search.txt:2 ../E/send.txt:2 ../E/shield.txt:2 ../E/sin.txt:2 ../E/sniff.txt:2 ../E/space.txt:2 ../E/sqrt.txt:2 ../E/strfind.txt:4 ../E/strleft.txt:4 ../E/strlen.txt:4 ../E/strlower.txt:4 ../E/strmid.txt:4 ../E/strright.txt:4 ../E/strupper.txt:4 ../E/strval.txt:8 ../E/switch.txt:47 ../E/takeoff.txt:2 ../E/tan.txt:2 ../E/testinfo.txt:2 ../E/thump.txt:2 ../E/topo.txt:2 ../E/trunc.txt:2 ../E/turn.txt:19 ../E/wait.txt:10 ../E/writeln.txt:8
|
||
#, no-wrap
|
||
msgid "Syntax:"
|
||
msgstr "Składnia:"
|
||
|
||
#. type: Source code
|
||
#: ../E/abstime.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>abstime ( );<n/>"
|
||
msgstr "<c/>abstime ( );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/abstime.txt:5
|
||
#, no-wrap
|
||
msgid "Return the time in seconds elapsed since the beginning of the mission."
|
||
msgstr "Zwraca czas (w sekundach) jaki upłynął od początku misji."
|
||
|
||
#. type: \t; header
|
||
#: ../E/abstime.txt:7
|
||
#, no-wrap
|
||
msgid "Return: <code><a cbot|float>float</a></code>"
|
||
msgstr "Typ wyniku: <code><a cbot|float>float</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/abstime.txt:8
|
||
#, no-wrap
|
||
msgid "Time in seconds."
|
||
msgstr "Czas w sekundach."
|
||
|
||
#. type: \t; header
|
||
#: ../E/abstime.txt:10 ../E/acos.txt:11 ../E/aim.txt:23 ../E/array.txt:41 ../E/asin.txt:11 ../E/atan.txt:11 ../E/atan2.txt:16 ../E/bloc.txt:48 ../E/bool.txt:4 ../E/break.txt:24 ../E/build.txt:27 ../E/buildingenabled.txt:22 ../E/busy.txt:14 ../E/canbuild.txt:22 ../E/canresearch.txt:14 ../E/category.txt:114 ../E/ceil.txt:12 ../E/class.txt:120 ../E/close.txt:6 ../E/cond.txt:4 ../E/continue.txt:24 ../E/cos.txt:11 ../E/deletef.txt:9 ../E/delinfo.txt:13 ../E/destroy.txt:15 ../E/detect.txt:27 ../E/direct.txt:13 ../E/dist.txt:29 ../E/dist2d.txt:13 ../E/do.txt:27 ../E/drop.txt:28 ../E/eof.txt:13 ../E/errmode.txt:32 ../E/expr.txt:197 ../E/extends.txt:105 ../E/extern.txt:29 ../E/factory.txt:21 ../E/false.txt:4 ../E/file.txt:16 ../E/fire.txt:30 ../E/flatgrnd.txt:16 ../E/flatspace.txt:25 ../E/float.txt:24 ../E/floor.txt:12 ../E/for.txt:51 ../E/function.txt:165 ../E/goto.txt:34 ../E/grab.txt:28 ../E/if.txt:39 ../E/int.txt:18 ../E/jet.txt:14 ../E/message.txt:24 ../E/motor.txt:38 ../E/move.txt:21 ../E/nan.txt:14 ../E/new.txt:20 ../E/null.txt:4 ../E/object.txt:79 ../E/open.txt:19 ../E/openfile.txt:11 ../E/pencolor.txt:14 ../E/pendown.txt:17 ../E/penup.txt:11 ../E/penwidth.txt:14 ../E/point.txt:35 ../E/pointer.txt:51 ../E/pow.txt:14 ../E/private.txt:19 ../E/produce.txt:30 ../E/protected.txt:26 ../E/public.txt:49 ../E/radar.txt:80 ../E/radarall.txt:19 ../E/rand.txt:8 ../E/readln.txt:18 ../E/receive.txt:16 ../E/recycle.txt:12 ../E/research.txt:18 ../E/researched.txt:14 ../E/researches.txt:27 ../E/retobj.txt:13 ../E/return.txt:29 ../E/round.txt:12 ../E/search.txt:25 ../E/send.txt:17 ../E/shield.txt:18 ../E/sin.txt:11 ../E/sizeof.txt:21 ../E/sniff.txt:16 ../E/space.txt:22 ../E/sqrt.txt:11 ../E/static.txt:20 ../E/strfind.txt:18 ../E/string.txt:32 ../E/strleft.txt:14 ../E/strlen.txt:12 ../E/strlower.txt:10 ../E/strmid.txt:18 ../E/strright.txt:14 ../E/strupper.txt:10 ../E/strval.txt:17 ../E/super.txt:45 ../E/switch.txt:70 ../E/synchro.txt:23 ../E/takeoff.txt:15 ../E/tan.txt:11 ../E/term.txt:30 ../E/testinfo.txt:16 ../E/this.txt:52 ../E/thump.txt:12 ../E/topo.txt:13 ../E/true.txt:4 ../E/trunc.txt:12 ../E/turn.txt:32 ../E/type.txt:32 ../E/var.txt:66 ../E/void.txt:10 ../E/wait.txt:21 ../E/while.txt:46 ../E/writeln.txt:19
|
||
#, no-wrap
|
||
msgid "See also"
|
||
msgstr "Zobacz również"
|
||
|
||
#. type: Plain text
|
||
#: ../E/abstime.txt:11 ../E/aim.txt:24 ../E/array.txt:42 ../E/bool.txt:5 ../E/break.txt:25 ../E/busy.txt:15 ../E/cond.txt:5 ../E/continue.txt:25 ../E/deletef.txt:10 ../E/destroy.txt:16 ../E/detect.txt:28 ../E/direct.txt:14 ../E/dist.txt:30 ../E/dist2d.txt:14 ../E/drop.txt:29 ../E/errmode.txt:33 ../E/expr.txt:198 ../E/extern.txt:30 ../E/false.txt:5 ../E/fire.txt:31 ../E/flatgrnd.txt:17 ../E/flatspace.txt:26 ../E/float.txt:25 ../E/for.txt:52 ../E/function.txt:166 ../E/goto.txt:35 ../E/grab.txt:29 ../E/if.txt:40 ../E/int.txt:19 ../E/jet.txt:15 ../E/message.txt:25 ../E/move.txt:22 ../E/nan.txt:15 ../E/object.txt:80 ../E/openfile.txt:12 ../E/pencolor.txt:15 ../E/pendown.txt:18 ../E/penup.txt:12 ../E/penwidth.txt:15 ../E/point.txt:36 ../E/produce.txt:31 ../E/recycle.txt:13 ../E/retobj.txt:14 ../E/return.txt:30 ../E/search.txt:26 ../E/shield.txt:19 ../E/sizeof.txt:22 ../E/sniff.txt:17 ../E/space.txt:23 ../E/string.txt:33 ../E/switch.txt:71 ../E/takeoff.txt:16 ../E/term.txt:31 ../E/thump.txt:13 ../E/topo.txt:14 ../E/true.txt:5 ../E/turn.txt:33 ../E/type.txt:33 ../E/var.txt:67 ../E/void.txt:11 ../E/wait.txt:22
|
||
#, no-wrap
|
||
msgid "<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr "<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/aim.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>aim</code>"
|
||
msgstr "Instrukcja <code>aim</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/break.txt:2 ../E/continue.txt:2 ../E/direct.txt:2 ../E/motor.txt:15 ../E/while.txt:20
|
||
#, no-wrap
|
||
msgid "Syntax :"
|
||
msgstr "Składnia:"
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/aim.txt:6 ../E/fire.txt:14
|
||
#, no-wrap
|
||
msgid "<a object|botfr>Shooter</a>"
|
||
msgstr "<a object|botfr>Działo</a>"
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/aim.txt:7 ../E/fire.txt:15
|
||
#, no-wrap
|
||
msgid "<a object|botor>Orga shooter</a>"
|
||
msgstr "<a object|botor>Działo organiczne</a>"
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/aim.txt:8 ../E/fire.txt:16
|
||
#, no-wrap
|
||
msgid "<a object|botphaz>Phazer shooter</a>"
|
||
msgstr "<a object|botphaz>Działo fazowe</a>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/fire.txt:18
|
||
#, no-wrap
|
||
msgid "When controlling the robot through programming, the only way to turn the gun left or right is to turn the whole robot with the instruction <code><a cbot|turn>turn</a></code>."
|
||
msgstr "Podczas kontrolowania działanie robota przy użyciu programu, jedynym sposobem obrócenia lufy w prawo lub w lewo, jest obrócenie całego robota instrukcją <code><a cbot|turn>turn</a></code>."
|
||
|
||
#. type: \t; header
|
||
#: ../E/cos.txt:5 ../E/sin.txt:5 ../E/tan.txt:5 ../E/turn.txt:24
|
||
#, no-wrap
|
||
msgid "angle: <code><a cbot|float>float</a></code>"
|
||
msgstr "kąt: <code><a cbot|float>float</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/aim.txt:13
|
||
#, no-wrap
|
||
msgid "Angle in degrees of the gun relative to the robot. A positive value orients the gun upward. For shooters and orga shooters, the angle must range from <code>-20</code> to <code>+20</code> degrees. For phazer shooters, the angle must range from <code>-20</code> to <code>45</code> degrees."
|
||
msgstr "Kąt w stopniach w odniesieniu do robota. Wartość dodatnia ustawia lufę w górę. Dla dział i dział organicznych ograniczeniem jest przedział od <code>-20</code> do <code>+20</code> stopni. Dla działa fazowego kąt ten musi należeć do przedziału od <code>-20</code> do <code>45</code> stopni."
|
||
|
||
#. type: \t; header
|
||
#: ../E/aim.txt:18 ../E/build.txt:22 ../E/destroy.txt:10 ../E/drop.txt:23 ../E/factory.txt:16 ../E/fire.txt:25 ../E/goto.txt:29 ../E/grab.txt:23 ../E/move.txt:16 ../E/pencolor.txt:9 ../E/pendown.txt:12 ../E/penup.txt:6 ../E/penwidth.txt:9 ../E/recycle.txt:7 ../E/research.txt:13 ../E/sniff.txt:11 ../E/takeoff.txt:10 ../E/thump.txt:7 ../E/turn.txt:27
|
||
#, no-wrap
|
||
msgid "Return value: <code><a cbot|int>int</a></code>"
|
||
msgstr "Typ wyniku: <code><a cbot|int>int</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/aim.txt:19
|
||
#, no-wrap
|
||
msgid ""
|
||
"Zero if everything is OK, a value different from zero if the rotation could not be performed: \n"
|
||
"<code>== 0 </code>The gun has now got the desired orientation\n"
|
||
"<code>!= 0 </code>rotation impossible"
|
||
msgstr ""
|
||
"Zero jeśli wszystko jest w porządku, wartość różna od zera, jeśli obrót nie może być wykonany: \n"
|
||
"<code>== 0 </code>Lufa została wycelowana w żądanym kierunku\n"
|
||
"<code>!= 0 </code>obrót niemożliwy"
|
||
|
||
#. type: \b; header
|
||
#: ../E/array.txt:1
|
||
#, no-wrap
|
||
msgid "Arrays"
|
||
msgstr "Tablice"
|
||
|
||
#. type: Plain text
|
||
#: ../E/array.txt:2
|
||
#, no-wrap
|
||
msgid "An array is basically a collection of variables of the same type or class. You can use N dimensionnal arrays in the CBOT language. Each dimension is limited to 9999 elements. You must use square brackets <code>[]</code> after the type name or the variable name to declare an array."
|
||
msgstr "Tablica jest zestawem obiektów tego samego typu lub klasy. W języku CBOT można używać N wymiarowych tablic. Każdy wymiar jest ograniczony do 9999 elementów. Aby zadeklarować tablicę, należy użyć nawiasów kwadratowych <code>[]</code> po nazwie zmiennej lub nazwie typu."
|
||
|
||
#. type: Plain text
|
||
#: ../E/array.txt:9
|
||
#, no-wrap
|
||
msgid "Actually when the CBOT interpreter encounters an array declaration, it just creates a <code><a cbot|null>null</a></code> <a cbot|pointer>reference</a>:"
|
||
msgstr "W rzeczywistości, gdy interpreter języka CBOT napotka deklarację tablicy, tworzy jedynie <a cbot|pointer>wskażnik</a> <code><a cbot|null>null</a></code>:"
|
||
|
||
#. type: Source code
|
||
#: ../E/array.txt:11
|
||
#, no-wrap
|
||
msgid "int a[5]; // a is now a null reference"
|
||
msgstr "int a[5]; // jest teraz wskaźnikiem null"
|
||
|
||
#. type: Plain text
|
||
#: ../E/array.txt:13
|
||
#, no-wrap
|
||
msgid "As soon as you put values into the array, the elements are created and the reference is initialized:"
|
||
msgstr "Z chwilą wstawienia wartości do tablicy, tworzone są elementy i inicjalizowany jest wskaźnik:"
|
||
|
||
#. type: Source code
|
||
#: ../E/array.txt:15
|
||
#, no-wrap
|
||
msgid ""
|
||
"a[2] = 213; // a points to\n"
|
||
" // 3 elements [0], [1] et [2]"
|
||
msgstr ""
|
||
"a[2] = 213; // tablica a wskazuje na\n"
|
||
" // 3 elementy: [0], [1] i [2]"
|
||
|
||
#. type: Plain text
|
||
#: ../E/array.txt:18
|
||
#, no-wrap
|
||
msgid "After this operation, <code>a</code> contains a reference to the elements of the array. Elements <code>[0]</code> and <code>[1]</code> are created but not initialized because an array cannot contain empty elements. The <code><a cbot|sizeof>sizeof</a></code> instruction allows you to obtain the number of elements contained in an array."
|
||
msgstr "Po tej operacji, zmienna <code>a</code> zawiera wskaźnik do elementów tablicy. Elementy <code>[0]</code> i <code>[1]</code> są tworzone, ale nie inicjalizowane, gdyż tablica nie może zawierać pustych elementów. Instrukcja <code><a cbot|sizeof>sizeof</a></code> umożliwia sprawdzenie liczby elementów tablicy."
|
||
|
||
#. type: Plain text
|
||
#: ../E/array.txt:20
|
||
#, no-wrap
|
||
msgid "When an array is declared with a maximum size, the program will stop as soon as there is an access beyond the maximum array size. No error is signalled during compilation even if the error is obvious:"
|
||
msgstr "Gdy określony jest rozmiar maksymalny deklarowanej tablicy, program zatrzyma się w przypadku próby dostępu poza tablicę. Błąd ten nie jest sygnalizowany podczas kompilacji, nawet jeśli jest oczywisty:"
|
||
|
||
#. type: Source code
|
||
#: ../E/array.txt:22
|
||
#, no-wrap
|
||
msgid ""
|
||
"{\n"
|
||
"\tint a[5];\n"
|
||
"\ta[7] = 123; // no error at compile time\n"
|
||
"\t // but error at run time\n"
|
||
"}"
|
||
msgstr ""
|
||
"{\n"
|
||
"\tint a[5];\n"
|
||
"\ta[7] = 123; // nie ma błędu podczas kompilacji\n"
|
||
"\t // ale pojawia się podczas działania programu\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/array.txt:28
|
||
#, no-wrap
|
||
msgid "If you pass an array as parameter to a <a cbot|function>function</a>, the function only receives a <a cbot|pointer>reference</a> to the array. That means if you modify an array element in the function, the element of the array that has been passed the function will be actuallay modified."
|
||
msgstr "Jeśli tablica przekazywana jest jako parametr <a cbot|function>funkcji</a>, funkcja otrzymuje jedynie <a cbot|pointer>wskaźnik</a> do tablicy. Oznacza to, że w przypadku modyfikacji elementu tablicy wewnątrz funkcji, zostanie w rzeczywistości zmodyfikowany element tablicy przekazanej funkcji jako parametr."
|
||
|
||
#. type: \b; header
|
||
#: ../E/bloc.txt:1
|
||
#, no-wrap
|
||
msgid "Blocks"
|
||
msgstr "Bloki"
|
||
|
||
#. type: Plain text
|
||
#: ../E/bloc.txt:2
|
||
#, no-wrap
|
||
msgid "You can use braces <code>{ }</code> to group a number of instructions together in order to make one single block out of them, for example: "
|
||
msgstr "Do zgrupowania razem kilku instrukcji można użyć nawiasów klamrowych <code>{ }</code> i utworzyć z nich jeden blok, na przykład: "
|
||
|
||
#. type: Source code
|
||
#: ../E/bloc.txt:4
|
||
#, no-wrap
|
||
msgid ""
|
||
"\t{\n"
|
||
"\t\tfloat t;\n"
|
||
"\t\tt = a;\n"
|
||
"\t\ta = b;\n"
|
||
"\t\tb = t; // switches round a and b\n"
|
||
"\t}"
|
||
msgstr ""
|
||
"\t{\n"
|
||
"\t\tfloat t;\n"
|
||
"\t\tt = a;\n"
|
||
"\t\ta = b;\n"
|
||
"\t\tb = t; // zamienia zawartości a i b\n"
|
||
"\t}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/bloc.txt:11
|
||
#, no-wrap
|
||
msgid ""
|
||
"Every instruction in the block is followed by a <a cbot|term>semicolon</a>, but the block itself is not. \n"
|
||
"Let us take the following example with the instruction <code><a cbot|if>if</a></code> to illustrate the use of blocks in a program:"
|
||
msgstr ""
|
||
"Każda instrukcja w bloku zakończona jest <a cbot|term>średnikiem</a> ale sam blok już nie. \n"
|
||
"W celu zilustrowania użycia bloków w programie rozważmy następujący przykład z instrukcją <code><a cbot|if>if</a></code>:"
|
||
|
||
#. type: Source code
|
||
#: ../E/bloc.txt:14
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tif ( a < b )\n"
|
||
"\t\t<n/>instruction 1<c/>;\n"
|
||
"\t\t<n/>instruction 2<c/>;\n"
|
||
"\t<n/>instruction 3<c/>;"
|
||
msgstr ""
|
||
"\tif ( a < b )\n"
|
||
"\t\t<n/>instrukcja 1<c/>;\n"
|
||
"\t\t<n/>instrukcja 2<c/>;\n"
|
||
"\t<n/>instrukcja 3<c/>;"
|
||
|
||
#. type: Plain text
|
||
#: ../E/bloc.txt:19
|
||
#, no-wrap
|
||
msgid ""
|
||
"If the <a cbot|cond>condition</a> is true, instructions 1, 2 and 3 are performed. If the condition is false, only instruction 1 is ignored, instructions 2 and 3 are performed. The fact that instruction 2 is lined up with instruction 1 does not matter. \n"
|
||
"If you want to perform instructions 1 and 2 only if the condition is true, you have to bracket them together in a block: "
|
||
msgstr ""
|
||
"Jeśli <a cbot|cond>warunek</a> jest prawdziwy, wykonywane są instrukcje 1, 2 i 3. Jeśli nie, tylko instrukcja 1 jest pomijana, instrukcje 2 i 3 są wykonywane. Fakt, że instrukcja 2 jest na tym samym poziomie co instrukcja 1 nie ma znaczenia. \n"
|
||
"Jeśli instrukcje 1 i 2 mają być wykonywane tylko gdy warunek jest prawdziwy, należy użyć nawiasów klamrowych do złączenie ich w jeden blok: "
|
||
|
||
#. type: Source code
|
||
#: ../E/bloc.txt:22
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tif ( a < b )\n"
|
||
"\t{\n"
|
||
"\t\t<n/>instruction 1<c/>;\n"
|
||
"\t\t<n/>instruction 2<c/>;\n"
|
||
"\t}\n"
|
||
"\t<n/>instruction 3<c/>;"
|
||
msgstr ""
|
||
"\tif ( a < b )\n"
|
||
"\t{\n"
|
||
"\t\t<n/>instrukcja 1<c/>;\n"
|
||
"\t\t<n/>instrukcja 2<c/>;\n"
|
||
"\t}\n"
|
||
"\t<n/>instrukcja 3<c/>;"
|
||
|
||
#. type: Plain text
|
||
#: ../E/bloc.txt:29
|
||
#, no-wrap
|
||
msgid ""
|
||
"Blocks may be needed with instructions <code><a cbot|if>if</a></code>, <code><a cbot|while>while</a></code> and <code><a cbot|for>for</a></code>, in order to group several instructions that should be performed only if a condition is true, or repeated several times. \n"
|
||
"You can fit blocks into other blocks, on as many levels as you need. Here is an example of imbrication on two levels :"
|
||
msgstr ""
|
||
"Bloki mogą być niezbędne w przypadku instrukcji <code><a cbot|if>if</a></code>, <code><a cbot|while>while</a></code> oraz <code><a cbot|for>for</a></code>, w celu zgrupowania instrukcji, które mają być wykonywane tylko w przypadku prawdziwości warunku bądź powtarzane wielokrotnie. \n"
|
||
"Bloki można umieszczać wewnątrz innych bloków dowolną liczbę razy. Oto przykład dwupoziomowego zagnieżdżenia:"
|
||
|
||
#. type: Source code
|
||
#: ../E/bloc.txt:32
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tif ( a > b )\n"
|
||
"\t{\n"
|
||
"\t\tint i = 0;\n"
|
||
"\t\twhile ( i < 18 )\n"
|
||
"\t\t{\n"
|
||
"\t\t\tmove(10);\n"
|
||
"\t\t\tturn(5);\n"
|
||
"\t\t\ti = i+1;\n"
|
||
"\t\t}\n"
|
||
"\t}"
|
||
msgstr ""
|
||
"\tif ( a > b )\n"
|
||
"\t{\n"
|
||
"\t\tint i = 0;\n"
|
||
"\t\twhile ( i < 18 )\n"
|
||
"\t\t{\n"
|
||
"\t\t\tmove(10);\n"
|
||
"\t\t\tturn(5);\n"
|
||
"\t\t\ti = i+1;\n"
|
||
"\t\t}\n"
|
||
"\t}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/bloc.txt:43
|
||
#, no-wrap
|
||
msgid "You had better line up the open brace <code>{</code> with the closing brace <code>}</code> in order to improve readability, but it is not compulsory. The following example takes less space, is equivalent to the previous example, but it is not advisable to write your programs in the following style : "
|
||
msgstr "Aby poprawić czytelność programu, najlepiej jest wyrównać klamrę otwierającą<code>{</code> z zamykającą <code>}</code>, chociaż nie jest to obowiązkowe. Następujący przykład zajmuje mniej miejsca i jest równoważny poprzedniemu, nie jest jednak polecane używanie takiego stylu: "
|
||
|
||
#. type: Source code
|
||
#: ../E/bloc.txt:45
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tif(a>b) { int i=0; while(i<18) {\n"
|
||
"\tmove(10);turn(5);i=i+1; }}"
|
||
msgstr ""
|
||
"\tif(a>b) { int i=0; while(i<18) {\n"
|
||
"\tmove(10);turn(5);i=i+1; }}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/bloc.txt:49 ../E/do.txt:28 ../E/motor.txt:39 ../E/while.txt:47
|
||
#, no-wrap
|
||
msgid "<a cbot>Instructions</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr "<a cbot>Instrukcje</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/bool.txt:1
|
||
#, no-wrap
|
||
msgid "Type <code>bool</code>"
|
||
msgstr "Typ <code>bool</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/bool.txt:2
|
||
#, no-wrap
|
||
msgid "In a variable of this type you can put a boolean value, that is a value that can take only two states: true or false. "
|
||
msgstr "Zmiennej tego typu można przypisać wartość logiczną, czyli wartość która ma dwa stany: true (prawda) lub false (fałsz). "
|
||
|
||
#. type: \b; header
|
||
#: ../E/break.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>break</code>"
|
||
msgstr "Instrukcja <code>break</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/break.txt:3
|
||
#, no-wrap
|
||
msgid ""
|
||
"<c/>while ( condition )\n"
|
||
"{\n"
|
||
"\tbreak;\n"
|
||
"}"
|
||
msgstr ""
|
||
"<c/>while ( warunek )\n"
|
||
"{\n"
|
||
"\tbreak;\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/break.txt:8
|
||
#, no-wrap
|
||
msgid "With this instruction, you can get out immediately of a <code><a cbot|while>while</a></code> or <code><a cbot|for>for</a></code> loop."
|
||
msgstr "Instrukcja break kończy wykonywanie pętli <code><a cbot|while>while</a></code> lub <code><a cbot|for>for</a></code>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/break.txt:10 ../E/continue.txt:10
|
||
#, no-wrap
|
||
msgid "Here is an example:"
|
||
msgstr "Oto przykład:"
|
||
|
||
#. type: Source code
|
||
#: ../E/break.txt:11
|
||
#, no-wrap
|
||
msgid ""
|
||
"<c/>int i = 0;\n"
|
||
"while ( true )\n"
|
||
"{\n"
|
||
"\t<n/>Instructions ...<c/>\n"
|
||
"\ti = i+1;\n"
|
||
"\tif ( i >= 10 )\n"
|
||
"\t{\n"
|
||
"\t\tbreak;\n"
|
||
"\t}\n"
|
||
"\t<n/>more instructions ...<c/>\n"
|
||
"}"
|
||
msgstr ""
|
||
"<c/>int i = 0;\n"
|
||
"while ( true )\n"
|
||
"{\n"
|
||
"\t<n/>Instrukcje ...<c/>\n"
|
||
"\ti = i+1;\n"
|
||
"\tif ( i >= 10 )\n"
|
||
"\t{\n"
|
||
"\t\tbreak;\n"
|
||
"\t}\n"
|
||
"\t<n/>więcej instrukcji ...<c/>\n"
|
||
"}"
|
||
|
||
#. type: \b; header
|
||
#: ../E/category.txt:1
|
||
#, no-wrap
|
||
msgid "Value <code>Categories</code>"
|
||
msgstr "<code>Kategorie</code> wartości"
|
||
|
||
#. type: Plain text
|
||
#: ../E/category.txt:2
|
||
#, no-wrap
|
||
msgid "Categories represent the names of objects in the CBOT language. Everything in COLOBOT is an object: robots, buildings, raw materials, etc., even yourself."
|
||
msgstr "Kategorie to nazwy obiektów języka CBOT. W grze COLOBOT wszystko to obiekty: roboty, budynki, surowce, itd., nawet Ty."
|
||
|
||
#. type: Plain text
|
||
#: ../E/category.txt:34
|
||
#, no-wrap
|
||
msgid ""
|
||
" <code><a object|titanore>TitaniumOre</a> </code>Titanium Ore\n"
|
||
" <code><a object|uranore>UraniumOre</a> </code>Uranium Ore\n"
|
||
" <code><a object|titan>Titanium</a> </code>Cube of converted Titanium\n"
|
||
" <code><a object|power>PowerCell</a> </code>Regular Power Cell\n"
|
||
" <code><a object|atomic>NuclearCell</a> </code>Nuclear Power Cell\n"
|
||
" <code><a object|bullet>OrgaMatter</a> </code>Organic Matter\n"
|
||
" <code><a object|bbox>BlackBox</a> </code>Black Box\n"
|
||
" <code><a object|tnt>TNT</a> </code>Explosive device\n"
|
||
" <code><a object|key>KeyA..D</a> </code>Keys A, B, C and D"
|
||
msgstr ""
|
||
" <code><a object|titanore>TitaniumOre</a> </code>Ruda tytanu\n"
|
||
" <code><a object|uranore>UraniumOre</a> </code>Ruda uranu\n"
|
||
" <code><a object|titan>Titanium</a> </code>Kostka przetopionego tytanu\n"
|
||
" <code><a object|power>PowerCell</a> </code>Zwykłe ogniwo elektryczne\n"
|
||
" <code><a object|atomic>NuclearCell</a> </code>Atomowe ogniwo elektryczne\n"
|
||
" <code><a object|bullet>OrgaMatter</a> </code>Materia organiczna\n"
|
||
" <code><a object|bbox>BlackBox</a> </code>Czarna skrzynka\n"
|
||
" <code><a object|tnt>TNT</a> </code>Materiały wybuchowe\n"
|
||
" <code><a object|key>KeyA..D</a> </code>Klucze A, B, C i D"
|
||
|
||
#. type: Plain text
|
||
#: ../E/category.txt:47
|
||
#, no-wrap
|
||
msgid ""
|
||
"<button 158/> <code><a object|bottr>PracticeBot</a> </code>Practice Bot\n"
|
||
"<button 173/> <code><a object|bottarg>TargetBot</a> </code>Target Bot"
|
||
msgstr ""
|
||
"<button 158/> <code><a object|bottr>PracticeBot</a> </code>Robot treningowy\n"
|
||
"<button 173/> <code><a object|bottarg>TargetBot</a> </code>Robot cel"
|
||
|
||
#. type: Plain text
|
||
#: ../E/category.txt:50
|
||
#, no-wrap
|
||
msgid ""
|
||
"<button 137/> <code><a object|botgr>WheeledGrabber</a> </code>Wheeled Grabber\n"
|
||
"<button 138/> <code><a object|botgc>TrackedGrabber</a> </code>Tracked Grabber\n"
|
||
"<button 139/> <code><a object|botgj>WingedGrabber</a> </code>Winged Grabber\n"
|
||
"<button 150/> <code><a object|botgs>LeggedGrabber</a> </code>Legged Grabber"
|
||
msgstr ""
|
||
"<button 137/> <code><a object|botgr>WheeledGrabber</a> </code>Transporter na kołach\n"
|
||
"<button 138/> <code><a object|botgc>TrackedGrabber</a> </code>Transporter na gąsienicach\n"
|
||
"<button 139/> <code><a object|botgj>WingedGrabber</a> </code>Transporter latający\n"
|
||
"<button 150/> <code><a object|botgs>LeggedGrabber</a> </code>Transporter na nogach"
|
||
|
||
#. type: Plain text
|
||
#: ../E/category.txt:55
|
||
#, no-wrap
|
||
msgid ""
|
||
"<button 140/> <code><a object|botsr>WheeledSniffer</a> </code>Wheeled Sniffer\n"
|
||
"<button 141/> <code><a object|botsc>TrackedSniffer</a> </code>Tracked Sniffer\n"
|
||
"<button 142/> <code><a object|botsj>WingedSniffer</a> </code>Winged Sniffer\n"
|
||
"<button 152/> <code><a object|botss>LeggedSniffer</a> </code>Legged Sniffer"
|
||
msgstr ""
|
||
"<button 140/> <code><a object|botsr>WheeledSniffer</a> </code>Szperacz na kołach\n"
|
||
"<button 141/> <code><a object|botsc>TrackedSniffer</a> </code>Szperacz na gąsienicach\n"
|
||
"<button 142/> <code><a object|botsj>WingedSniffer</a> </code>Szperacz latający\n"
|
||
"<button 152/> <code><a object|botss>LeggedSniffer</a> </code>Szperacz na nogach"
|
||
|
||
#. type: Plain text
|
||
#: ../E/category.txt:60
|
||
#, no-wrap
|
||
msgid ""
|
||
"<button 143/> <code><a object|botfr>WheeledShooter</a> </code>Wheeled Shooter\n"
|
||
"<button 144/> <code><a object|botfc>TrackedShooter</a> </code>Tracked Shooter\n"
|
||
"<button 145/> <code><a object|botfj>WingedShooter</a> </code>Winged Shooter\n"
|
||
"<button 151/> <code><a object|botfs>LeggedShooter</a> </code>Legged Shooter"
|
||
msgstr ""
|
||
"<button 143/> <code><a object|botfr>WheeledShooter</a> </code>Działo na kołach\n"
|
||
"<button 144/> <code><a object|botfc>TrackedShooter</a> </code>Działo na gąsienicach\n"
|
||
"<button 145/> <code><a object|botfj>WingedShooter</a> </code>Działo latające\n"
|
||
"<button 151/> <code><a object|botfs>LeggedShooter</a> </code>Działo na nogach"
|
||
|
||
#. type: Plain text
|
||
#: ../E/category.txt:65
|
||
#, no-wrap
|
||
msgid ""
|
||
"<button 153/> <code><a object|botor>WheeledOrgaShooter</a> </code>Wheeled Orga Shooter\n"
|
||
"<button 154/> <code><a object|botoc>TrackedOrgaShooter</a> </code>Tracked Orga Shooter\n"
|
||
"<button 155/> <code><a object|botoj>WingedOrgaShooter</a> </code>Winged Orga Shooter\n"
|
||
"<button 156/> <code><a object|botos>LeggedOrgaShooter</a> </code>Legged Orga Shooter"
|
||
msgstr ""
|
||
"<button 153/> <code><a object|botor>WheeledOrgaShooter</a> </code>Działo organiczne na kołach\n"
|
||
"<button 154/> <code><a object|botoc>TrackedOrgaShooter</a> </code>Działo organiczne na gąsienicach\n"
|
||
"<button 155/> <code><a object|botoj>WingedOrgaShooter</a> </code>Latające działo organiczne\n"
|
||
"<button 156/> <code><a object|botos>LeggedOrgaShooter</a> </code>Działo organiczne na nogach"
|
||
|
||
#. type: Plain text
|
||
#: ../E/category.txt:75
|
||
#, no-wrap
|
||
msgid ""
|
||
"<button 149/> <code><a object|botsub>Subber</a> </code>Subber\n"
|
||
"<button 148/> <code><a object|botrecy>Recycler</a> </code>Recycler\n"
|
||
"<button 157/> <code><a object|botshld>Shielder</a> </code>Shielder\n"
|
||
"<button 146/> <code><a object|bottump>Thumper</a> </code>Thumper\n"
|
||
"<button 147/> <code><a object|botphaz>PhazerShooter</a> </code>Phazer Shooter"
|
||
msgstr ""
|
||
"<button 149/> <code><a object|botsub>Subber</a> </code>Robot nurek\n"
|
||
"<button 148/> <code><a object|botrecy>Recycler</a> </code>Robot recykler\n"
|
||
"<button 157/> <code><a object|botshld>Shielder</a> </code>Robot osłaniacz\n"
|
||
"<button 146/> <code><a object|bottump>Thumper</a> </code>Robot uderzacz\n"
|
||
"<button 147/> <code><a object|botphaz>PhazerShooter</a> </code>Działo fazowe"
|
||
|
||
#. type: Plain text
|
||
#: ../E/category.txt:84
|
||
#, no-wrap
|
||
msgid ""
|
||
" <code><a object|mother>AlienQueen</a> </code>Alien Queen\n"
|
||
" <code><a object|egg>AlienEgg</a> </code>Alien Egg\n"
|
||
" <code><a object|ant>AlienAnt</a> </code>Ant\n"
|
||
" <code><a object|spider>AlienSpider</a> </code>Spider\n"
|
||
" <code><a object|wasp>AlienWasp</a> </code>Wasp\n"
|
||
" <code><a object|worm>AlienWorm</a> </code>Worm"
|
||
msgstr ""
|
||
" <code><a object|mother>AlienQueen</a> </code>Królowa Obcych\n"
|
||
" <code><a object|egg>AlienEgg</a> </code>Jajo Obcych\n"
|
||
" <code><a object|ant>AlienAnt</a> </code>Mrówka\n"
|
||
" <code><a object|spider>AlienSpider</a> </code>Pająk\n"
|
||
" <code><a object|wasp>AlienWasp</a> </code>Osa\n"
|
||
" <code><a object|worm>AlienWorm</a> </code>Robal"
|
||
|
||
#. type: Plain text
|
||
#: ../E/category.txt:94
|
||
#, no-wrap
|
||
msgid ""
|
||
"<button 136/> <code><a object|human>Me</a> </code>You!\n"
|
||
" <code><a object|mine>Mine</a> </code>Mine\n"
|
||
" <code><a object|barrier>Barrier</a> </code>Barrier\n"
|
||
" <code><a object|wreck>Wreck</a> </code>Derelict bot\n"
|
||
" <code><a object|ruin>Ruin</a> </code>Derelict building"
|
||
msgstr ""
|
||
"<button 136/> <code><a object|human>Me</a> </code>Ty!\n"
|
||
" <code><a object|mine>Mine</a> </code>Mina\n"
|
||
" <code><a object|barrier>Barrier</a> </code>Bariera\n"
|
||
" <code><a object|wreck>Wreck</a> </code>Szczątki robota\n"
|
||
" <code><a object|ruin>Ruin</a> </code>Szczątki budynku"
|
||
|
||
#. type: Plain text
|
||
#: ../E/category.txt:115
|
||
#, no-wrap
|
||
msgid "<a cbot>CBOT Language</a> and <a cbot|type>Variables</a>."
|
||
msgstr "<a cbot>Język CBOT</a> i <a cbot|type>zmienne</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/class.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>class</code>"
|
||
msgstr "Instrukcja <code>class</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/class.txt:4
|
||
#, no-wrap
|
||
msgid ""
|
||
"public class ClassName\n"
|
||
"{\n"
|
||
"\tdeclarations;\n"
|
||
"}"
|
||
msgstr ""
|
||
"public class NazwaKlasy\n"
|
||
"{\n"
|
||
"\tdeklaracje;\n"
|
||
"}"
|
||
|
||
#. type: \b; header
|
||
#: ../E/close.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>close</code>"
|
||
msgstr "Instrukcja <code>close</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/close.txt:2
|
||
#, no-wrap
|
||
msgid "Close a file opened previously with <code><a cbot|open>open</a></code>. This is a method of the <code><a cbot|file>file</a></code> class; therefore you cannot write <code>close()</code> but only <code>handle.close()</code>:"
|
||
msgstr "Zamyka plik otwarty wcześniej przy użyciu instrukcji <code><a cbot|open>open</a></code>. Jest to metoda klasy <code><a cbot|file>file</a></code>, wobec czego nie można napisać <code>close()</code>, lecz jedynie <code>handle.close()</code>:"
|
||
|
||
#. type: Source code
|
||
#: ../E/close.txt:4
|
||
#, no-wrap
|
||
msgid "\thandle.close();"
|
||
msgstr "\thandle.close();"
|
||
|
||
#. type: Plain text
|
||
#: ../E/close.txt:7
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|file>file</a></code>, <code><a cbot|open>open</a></code>, <code><a cbot|readln>readln</a></code>, <code><a cbot|writeln>writeln</a></code> and <code><a cbot|eof>eof</a></code>.\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<code><a cbot|file>file</a></code>, <code><a cbot|open>open</a></code>, <code><a cbot|readln>readln</a></code>, <code><a cbot|writeln>writeln</a></code> i <code><a cbot|eof>eof</a></code>.\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/cond.txt:1
|
||
#, no-wrap
|
||
msgid "Conditions"
|
||
msgstr "Warunki"
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:116
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code>a == b </code><code>a</code> equals <code>b</code>\n"
|
||
"<code>a != b </code><code>a</code> is different from <code>b</code>\n"
|
||
"<code>a < b </code><code>a</code> smaller than <code>b</code>\n"
|
||
"<code>a <= b </code><code>a</code> smaller than or equal to <code>b</code>\n"
|
||
"<code>a > b </code><code>a</code> greater than <code>b</code>\n"
|
||
"<code>a >= b </code><code>a</code> greater than or equal to <code>b</code>"
|
||
msgstr ""
|
||
"<code>a == b </code><code>a</code> równe <code>b</code>\n"
|
||
"<code>a != b </code><code>a</code> różne od <code>b</code>\n"
|
||
"<code>a < b </code><code>a</code> mniejsze od <code>b</code>\n"
|
||
"<code>a <= b </code><code>a</code> mniejsze od lub równe <code>b</code>\n"
|
||
"<code>a > b </code><code>a</code> większe od <code>b</code>\n"
|
||
"<code>a >= b </code><code>a</code> wi<77><69>ksze od lub równe <code>b</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:124
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code>12 == 12 </code>returns true\n"
|
||
"<code>45 != 47 </code>returns true \n"
|
||
"<code>99 == 98 </code>returns false\n"
|
||
"<code>12 < -1 </code>returns false\n"
|
||
"<code>12 >= 10 </code>returns true \n"
|
||
"<code>12 >= 12 </code>returns true "
|
||
msgstr ""
|
||
"<code>12 == 12 </code>daje w wyniku true\n"
|
||
"<code>45 != 47 </code>daje w wyniku true \n"
|
||
"<code>99 == 98 </code>daje w wyniku false\n"
|
||
"<code>12 < -1 </code>daje w wyniku false\n"
|
||
"<code>12 >= 10 </code>daje w wyniku true \n"
|
||
"<code>12 >= 12 </code>daje w wyniku true "
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:132
|
||
#, no-wrap
|
||
msgid "Be careful not to confuse the equality comparison <code>==</code> with the assignment of a <a cbot|var>variable</a> <code>=</code>."
|
||
msgstr "Nie należy mylić operatora porównania <code>==</code> z operatorem przypisania wartości <a cbot|var>zmiennej</a> <code>=</code>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:134
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code>a == b</code> is an expression that compares <code>a</code> with <code>b</code>.\n"
|
||
"<code>a = b</code> is an expression that copies the value of <code>b</code> into <code>a</code>."
|
||
msgstr ""
|
||
"<code>a == b</code> jest wyrażeniem porównującym <code>a</code> z <code>b</code>.\n"
|
||
"<code>a = b</code> jest wyrażeniem kopiującym wartość <code>b</code> do <code>a</code>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/continue.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>continue</code>"
|
||
msgstr "Instrukcja <code>continue</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/continue.txt:3
|
||
#, no-wrap
|
||
msgid ""
|
||
"<c/>while ( condition )\n"
|
||
"{\n"
|
||
"\tcontinue;\n"
|
||
"}"
|
||
msgstr ""
|
||
"<c/>while ( warunek )\n"
|
||
"{\n"
|
||
"\tcontinue;\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/continue.txt:8
|
||
#, no-wrap
|
||
msgid "With this instruction, you can jump over the rest of instructions in the <code><a cbot|bloc>bloc</a></code> of a <code><a cbot|while>while</a></code> or <code><a cbot|for>for</a></code> loop: The execution will resume at the beginning of the bloc, the next time the loop is repeated."
|
||
msgstr "Przy użyciu tej instrukcji, można przeskoczyć resztę instrukcji w <code><a cbot|bloc>bloku</a></code> pętli <code><a cbot|while>while</a></code> lub <code><a cbot|for>for</a></code>: Działanie zostanie wznowione na początku bloku przy następnym powtórzeniu pętli."
|
||
|
||
#. type: Source code
|
||
#: ../E/continue.txt:11
|
||
#, no-wrap
|
||
msgid ""
|
||
"<c/>int i = 0;\n"
|
||
"while ( i < 5 )\n"
|
||
"{\n"
|
||
"\ti = i+1;\n"
|
||
"\tif ( i == 3 )\n"
|
||
"\t{\n"
|
||
"\t\tcontinue;\n"
|
||
"\t}\n"
|
||
"\t<n/>Instructions ...<c/>\n"
|
||
"}"
|
||
msgstr ""
|
||
"<c/>int i = 0;\n"
|
||
"while ( i < 5 )\n"
|
||
"{\n"
|
||
"\ti = i+1;\n"
|
||
"\tif ( i == 3 )\n"
|
||
"\t{\n"
|
||
"\t\tcontinue;\n"
|
||
"\t}\n"
|
||
"\t<n/>Instrukcje ...<c/>\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/continue.txt:22
|
||
#, no-wrap
|
||
msgid "The instructions will only be executed for the values of <code>i</code> 1, 2, 4 and 5."
|
||
msgstr "Instrukcje będą wykonane tylko dla wartości <code>i</code> 1, 2, 4 i 5."
|
||
|
||
#. type: \b; header
|
||
#: ../E/deletef.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>deletefile</code>"
|
||
msgstr "Instrukcja <code>deletefile</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/deletef.txt:2
|
||
#, no-wrap
|
||
msgid "The deletefile instruction deletes an existing file in the files/ folder. "
|
||
msgstr "Instrukcja deletefile usuwa istniejący plik z folderu files/. "
|
||
|
||
#. type: Plain text
|
||
#: ../E/deletef.txt:4
|
||
#, no-wrap
|
||
msgid "Files can only be deleted in the files/ folder which is located in the folder inside Colobot save directory. You cannot not delete files that are located elsewhere than in the files/ folder."
|
||
msgstr "Pliki mogą być usuwane tylko w folderze files/ znajdującym się w folderze zapisów gry Colobot. Nie jest możliwe usuwanie plików znajdujących się w innych folderach."
|
||
|
||
#. type: Source code
|
||
#: ../E/deletef.txt:7
|
||
#, no-wrap
|
||
msgid "<c/>deletefile ( filename );<n/>"
|
||
msgstr "<c/>deletefile ( nazwa_pliku );<n/>"
|
||
|
||
#. type: \b; header
|
||
#: ../E/delinfo.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>deleteinfo</code>"
|
||
msgstr "Instrukcja <code>deleteinfo</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/delinfo.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>deleteinfo ( name, power );<n/>"
|
||
msgstr "<c/>deleteinfo ( nazwa, moc );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/delinfo.txt:5
|
||
#, no-wrap
|
||
msgid "Delete an existing information in the closest <a object|exchange>information exchange post</a>."
|
||
msgstr "Usuwa istniejącą informację z najbliższej <a object|exchange>stacji przekaźnikowej</a>."
|
||
|
||
#. type: \t; header
|
||
#: ../E/delinfo.txt:7 ../E/receive.txt:7 ../E/send.txt:7 ../E/testinfo.txt:7
|
||
#, no-wrap
|
||
msgid "name: <code>string</code>"
|
||
msgstr "nazwa: <code>string</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/delinfo.txt:8
|
||
#, no-wrap
|
||
msgid "Name of the information to be deleted. This name is a string: it must be written in quotation marks \"\"."
|
||
msgstr "Nazwa informacji do usunięcia. Nazwa jest typu string i musi być napisana w cudzysłowach \"\"."
|
||
|
||
#. type: \t; header
|
||
#: ../E/delinfo.txt:10 ../E/receive.txt:10 ../E/send.txt:14 ../E/testinfo.txt:10
|
||
#, no-wrap
|
||
msgid "power: <code>float</code>"
|
||
msgstr "moc: <code>float</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/delinfo.txt:11
|
||
#, no-wrap
|
||
msgid "Power of the transmitter, which corresponds to the maximal distance between the sender and the exchange post. If the distance is longer, the information won't be deleted. Default value is 10 metres."
|
||
msgstr "Moc transmitera, odpowiadająca maksymalnej odległości pomiędzy nadawcą i stacją przekaźnikową. Jeśli odległość jest większa, informacja nie zostanie usunięta. Domyślana wartość to 10 metrów."
|
||
|
||
#. type: Plain text
|
||
#: ../E/delinfo.txt:14
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|receive>receive</a></code>, <code><a cbot|send>send</a></code> and <code><a cbot|testinfo>testinfo</a></code>.\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<code><a cbot|receive>receive</a></code>, <code><a cbot|send>send</a></code> i <code><a cbot|testinfo>testinfo</a></code>.\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/direct.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>direction</code>"
|
||
msgstr "Instrukcja <code>direction</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/direct.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>direction ( pos );<n/>"
|
||
msgstr "<c/>direction ( pozycja );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/direct.txt:5
|
||
#, no-wrap
|
||
msgid "Calculates the rotation that a robot must perform in order to point towards a given position. "
|
||
msgstr "Oblicza kąt obrotu, niezbędny do skierowania robota w kierunku zadanej pozycji. "
|
||
|
||
#. type: \t; header
|
||
#: ../E/direct.txt:7 ../E/goto.txt:17
|
||
#, no-wrap
|
||
msgid "pos: <code><a cbot|point>point</a></code>"
|
||
msgstr "pozycja: <code><a cbot|point>point</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/direct.txt:8
|
||
#, no-wrap
|
||
msgid "Position towards which the robot must point."
|
||
msgstr "Pozycja, w kierunku której ma być skierowany robot."
|
||
|
||
#. type: \t; header
|
||
#: ../E/acos.txt:8 ../E/asin.txt:8 ../E/atan.txt:8 ../E/atan2.txt:13 ../E/ceil.txt:9 ../E/cos.txt:8 ../E/direct.txt:10 ../E/dist.txt:26 ../E/dist2d.txt:10 ../E/flatgrnd.txt:13 ../E/floor.txt:9 ../E/pow.txt:11 ../E/rand.txt:5 ../E/receive.txt:13 ../E/round.txt:9 ../E/sin.txt:8 ../E/sqrt.txt:8 ../E/tan.txt:8 ../E/topo.txt:10 ../E/trunc.txt:9
|
||
#, no-wrap
|
||
msgid "Return value: <code><a cbot|float>float</a></code>"
|
||
msgstr "Typ wyniku: <code><a cbot|float>float</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/direct.txt:11
|
||
#, no-wrap
|
||
msgid "Angle of the rotation that must be performed. -90 means f. ex. a rotation of 90 degrees to the right. "
|
||
msgstr "Kąt obrotu, który powinien być wykonany. -90 oznacza obrót o 90 stopni w prawo. "
|
||
|
||
#. type: \b; header
|
||
#: ../E/dist.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>distance</code>"
|
||
msgstr "Instrukcja <code>distance</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/dist.txt:2
|
||
#, no-wrap
|
||
msgid "With the instruction <code>distance( , )</code> you can calculate the distance between two positions."
|
||
msgstr "Za pomocą instrukcji <code>distance( , )</code> można obliczyć odległość między dwoma punktami."
|
||
|
||
#. type: \b; header
|
||
#: ../E/build.txt:4 ../E/buildingenabled.txt:4 ../E/canbuild.txt:4 ../E/dist.txt:4 ../E/drop.txt:4 ../E/fire.txt:4 ../E/function.txt:16 ../E/goto.txt:4 ../E/grab.txt:4 ../E/if.txt:4 ../E/motor.txt:4 ../E/move.txt:4 ../E/radar.txt:4 ../E/switch.txt:4 ../E/turn.txt:4 ../E/wait.txt:4 ../E/while.txt:4
|
||
#, no-wrap
|
||
msgid "Basic use"
|
||
msgstr "Podstawowe użycie"
|
||
|
||
#. type: Plain text
|
||
#: ../E/dist.txt:5
|
||
#, no-wrap
|
||
msgid "If you write <code>position</code> alone, this gives you the position of the bot that executes the program. If you write the name of a variable followed by <code>.position</code>, this gives you the position of the object described in the variable."
|
||
msgstr "Napisanie samej instrukcji <code>position</code> daje w wyniku pozycję robota wykonującego program. Napisanie nazwy zmiennej, a następnie bezpośrednio po niej <code>.position</code>, daje w wyniku pozycję obiektu opisywanego przez zmienną."
|
||
|
||
#. type: Plain text
|
||
#: ../E/dist.txt:7
|
||
#, no-wrap
|
||
msgid "Here is a program that moves forward, covering exactly the distance between the bot and the closest ant:"
|
||
msgstr "Oto program polecający robotowi podejść do przodu, o odległość równą odległości pomiędzy robotem i najbliższą mrówką:"
|
||
|
||
#. type: Source code
|
||
#: ../E/dist.txt:9
|
||
#, no-wrap
|
||
msgid ""
|
||
"\titem = <a cbot|radar>radar</a>(AlienAnt);\n"
|
||
"\t<a cbot|move>move</a>(distance(position, item.position));"
|
||
msgstr ""
|
||
"\titem = <a cbot|radar>radar</a>(AlienAnt);\n"
|
||
"\t<a cbot|move>move</a>(distance(position, item.position));"
|
||
|
||
#. type: Plain text
|
||
#: ../E/dist.txt:12
|
||
#, no-wrap
|
||
msgid "This is of course pure suicide. Better to stop 40 meters before, in order to be at shooting range:"
|
||
msgstr "Byłoby to oczywiste samobójstwo. Lepiej zatrzymać robota 40 metrów wcześniej, w odległości odpowiedniej do strzału:"
|
||
|
||
#. type: Source code
|
||
#: ../E/dist.txt:14
|
||
#, no-wrap
|
||
msgid ""
|
||
"\titem = radar(AlienAnt);\n"
|
||
"\tmove(distance(position, item.position) - 40);"
|
||
msgstr ""
|
||
"\titem = radar(AlienAnt);\n"
|
||
"\tmove(distance(position, item.position) - 40);"
|
||
|
||
#. type: \b; header, \t; header
|
||
#: ../E/build.txt:13 ../E/buildingenabled.txt:12 ../E/canbuild.txt:12 ../E/detect.txt:4 ../E/dist.txt:17 ../E/drop.txt:11 ../E/errmode.txt:4 ../E/file.txt:10 ../E/fire.txt:9 ../E/float.txt:19 ../E/goto.txt:11 ../E/grab.txt:11 ../E/if.txt:22 ../E/int.txt:13 ../E/motor.txt:14 ../E/move.txt:7 ../E/radar.txt:13 ../E/radarall.txt:11 ../E/return.txt:9 ../E/switch.txt:46 ../E/turn.txt:18 ../E/wait.txt:9 ../E/while.txt:19
|
||
#, no-wrap
|
||
msgid "For specialists"
|
||
msgstr "Dla specjalistów"
|
||
|
||
#. type: Source code
|
||
#: ../E/dist.txt:19
|
||
#, no-wrap
|
||
msgid "<c/>distance ( pos1, pos2 );<n/>"
|
||
msgstr "<c/>distance ( pozycja1, pozycja2 );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/dist.txt:21
|
||
#, no-wrap
|
||
msgid "Calculates the distance between two positions. "
|
||
msgstr "Oblicza odległość między dwoma punktami. "
|
||
|
||
#. type: \t; header
|
||
#: ../E/dist.txt:23 ../E/dist2d.txt:7
|
||
#, no-wrap
|
||
msgid "pos1, pos2: <code><a cbot|point>point</a></code>"
|
||
msgstr "pozycja1, pozycja2: <code><a cbot|point>point</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/dist.txt:24 ../E/dist2d.txt:8
|
||
#, no-wrap
|
||
msgid "Coordinates of the two positions. "
|
||
msgstr "Współrzędne dwóch punktów. "
|
||
|
||
#. type: Plain text
|
||
#: ../E/dist.txt:27 ../E/dist2d.txt:11
|
||
#, no-wrap
|
||
msgid "Distance between the two positions."
|
||
msgstr "Odległość między dwoma punktami."
|
||
|
||
#. type: \b; header
|
||
#: ../E/dist2d.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>distance2d</code>"
|
||
msgstr "Instrukcja <code>distance2d</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/dist2d.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>distance2d ( pos1, pos2 );<n/>"
|
||
msgstr "<c/>distance2d ( pozycja1, pozycja2 );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/dist2d.txt:5
|
||
#, no-wrap
|
||
msgid "Calculates the distance between two positions (ignores the z coordinate)."
|
||
msgstr "Oblicza odległość pomiędzy dwoma punktami (pomijając współrzędną z)."
|
||
|
||
#. type: \b; header
|
||
#: ../E/do.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>do - while</code>"
|
||
msgstr "Instrukcja <code>do - while</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/do.txt:3
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code>do\n"
|
||
"{\n"
|
||
"\t</code>Instructions ...<c/>\n"
|
||
"}\n"
|
||
"while ( condition );"
|
||
msgstr ""
|
||
"<code>do\n"
|
||
"{\n"
|
||
"\t</code>Instrukcje ...<c/>\n"
|
||
"}\n"
|
||
"while ( warunek );"
|
||
|
||
#. type: Plain text
|
||
#: ../E/do.txt:9
|
||
#, no-wrap
|
||
msgid ""
|
||
"This instruction allows you to perform several times the instructions inside the <a cbot|bloc>block</a>. The instructions are executed at least once, because the condition is tested only afterwards.\n"
|
||
"Be careful not to confuse the instruction <c/>do { } while ( );<n/> with the instruction <code><a cbot|while>while</a> ( ) { }</code>; the latter tests the condition before the instructions in the block are executed. "
|
||
msgstr ""
|
||
"Instrukcja ta umożliwia kilkukrotne wykonanie instrukcji w <a cbot|bloc>bloku</a>. Instrukcje wykonywane są conajmniej jeden raz, gdyż warunek sprawdzany jest dopiero na końcu pętli.\n"
|
||
"Należy uważać, aby nie pomylić instrukcji <c/>do { } while ( );<n/> z instrukcją <code><a cbot|while>while</a> ( ) { }</code>; ta druga sprawdza warunek przed wykonaniem instrukcji w bloku. "
|
||
|
||
#. type: \t; header
|
||
#: ../E/do.txt:12 ../E/for.txt:13 ../E/while.txt:30
|
||
#, no-wrap
|
||
msgid "<code>condition</code>"
|
||
msgstr "<code>warunek</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/do.txt:13 ../E/while.txt:31
|
||
#, no-wrap
|
||
msgid "The instructions in the block are performed over and over again, as long as the <a cbot|cond>condition</a> is true. "
|
||
msgstr "Instrukcje w bloku są wykonywane tak długo, jak długo prawdziwy jest <a cbot|cond>warunek</a>. "
|
||
|
||
#. type: Plain text
|
||
#: ../E/do.txt:15 ../E/while.txt:33
|
||
#, no-wrap
|
||
msgid "Here is an example :"
|
||
msgstr "Oto przykład:"
|
||
|
||
#. type: Source code
|
||
#: ../E/do.txt:16
|
||
#, no-wrap
|
||
msgid ""
|
||
"<c/>do\n"
|
||
"{\n"
|
||
"\tp = radar(TitaniumOre);\n"
|
||
"}\n"
|
||
"while ( p == null );"
|
||
msgstr ""
|
||
"<c/>do\n"
|
||
"{\n"
|
||
"\tp = radar(TitaniumOre);\n"
|
||
"}\n"
|
||
"while ( p == null );"
|
||
|
||
#. type: \t; header
|
||
#: ../E/do.txt:22 ../E/float.txt:11 ../E/for.txt:33 ../E/if.txt:36 ../E/int.txt:10 ../E/switch.txt:67 ../E/while.txt:41
|
||
#, no-wrap
|
||
msgid "Attention"
|
||
msgstr "Uwaga"
|
||
|
||
#. type: Plain text
|
||
#: ../E/do.txt:23
|
||
#, no-wrap
|
||
msgid "Always put a <a cbot|term>semicolon</a> at the end of the line <code>while ( )</code>."
|
||
msgstr "Zawsze należy umieszczać <a cbot|term>średnik</a> na końcu wiersza z instrukcją <code>while ( )</code>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/do.txt:25
|
||
#, no-wrap
|
||
msgid "The instructions <code><a cbot|break>break</a></code> and <code><a cbot|continue>continue</a></code> can be useful inside a block following the instruction <code>do { }</code>."
|
||
msgstr "Instrukcje <code><a cbot|break>break</a></code> i <code><a cbot|continue>continue</a></code> mogą być przydatne wewnątrz bloku instrukcji <code>do { }</code>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/drop.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>drop</code>"
|
||
msgstr "Instrukcja <code>drop</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/drop.txt:2
|
||
#, no-wrap
|
||
msgid "The instruction <c/>drop();<n/> instructs the bot to drop whatever the operating arm is carrying on the ground, on the platform of a building or on the power cell location of a bot."
|
||
msgstr "Instrukcja <c/>drop();<n/> poleca robotowi upuścić niesiony przedmiot na ziemię, platformę budynku lub miejsce na ogniwo elektryczne robota."
|
||
|
||
#. type: Plain text
|
||
#: ../E/drop.txt:5
|
||
#, no-wrap
|
||
msgid "The instruction <c/>drop();<n/> written in this form drops the object in front of the bot. Here is a short program that grabs an object in front of the bot and drops it 5 meters further:"
|
||
msgstr "Instrukcja <c/>drop();<n/> napisana w takiej postaci upuszcza przedmiot przed robotem. Oto krótki program podnoszący przedmiot bezpośrednio przed robotem i upuszczający go 5 metrów dalej:"
|
||
|
||
#. type: Source code
|
||
#: ../E/drop.txt:7
|
||
#, no-wrap
|
||
msgid ""
|
||
"\t<a cbot|grab>grab</a>();\n"
|
||
"\t<a cbot|move>move</a>(5);\n"
|
||
"\tdrop();"
|
||
msgstr ""
|
||
"\t<a cbot|grab>grab</a>();\n"
|
||
"\t<a cbot|move>move</a>(5);\n"
|
||
"\tdrop();"
|
||
|
||
#. type: Source code
|
||
#: ../E/drop.txt:13
|
||
#, no-wrap
|
||
msgid "<c/>drop ( oper );<n/>"
|
||
msgstr "<c/>drop ( oper );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/drop.txt:15
|
||
#, no-wrap
|
||
msgid "This instruction appeals to the operating arm of a <a object|botgr>grabber bot</a>, in order to drop what it is holding."
|
||
msgstr "Instrukcja ta odwołuje się do ramienia <a object|botgr>robota transportera</a>, w celu upuszczenia niesionego przedmiotu."
|
||
|
||
#. type: \t; header
|
||
#: ../E/drop.txt:17 ../E/grab.txt:17
|
||
#, no-wrap
|
||
msgid "oper: <code><a cbot|int>int</a></code> (default value<code>InFront</code>)"
|
||
msgstr "oper: <code><a cbot|int>int</a></code> (domyślna wartość <code>InFront</code>)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/drop.txt:18
|
||
#, no-wrap
|
||
msgid ""
|
||
"Oper indicates where the robot should drop the object. If no indication is given, the object is dropped in front of the bot. \n"
|
||
"<code>InFront </code> Drops in front (default value).\n"
|
||
"<code>Behind </code> Drops behind.\n"
|
||
"<code>EnergyCell</code> Drops on the bot's own power cell location."
|
||
msgstr ""
|
||
"Oper oznacza gdzie robot powinien zostawić przedmiot. Jeśli nie jest to określone, przedmiot zostawiany jest przed robotem. \n"
|
||
"<code>InFront </code> przed (domyślnie).\n"
|
||
"<code>Behind </code> za\n"
|
||
"<code>EnergyCell</code> w miejscu na baterię samego robota."
|
||
|
||
#. type: Plain text
|
||
#: ../E/drop.txt:24
|
||
#, no-wrap
|
||
msgid ""
|
||
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <c/>drop();<n/>.\n"
|
||
"<code>== 0 </code>object was dropped\n"
|
||
"<code>!= 0 </code>error, no object was dropped"
|
||
msgstr ""
|
||
"Zwykle wystąpienie błędu powoduje zatrzymanie programu. Można wyłączyć zatrzymywanie się programu w przypadku wystąpienia błędu, używając instrukcji <code><a cbot|errmode>errmode</a>(0)</code>. Wtedy w przypadku wystąpienia błędu instrukcja <c/>drop();<n/> zwraca w wyniku wartość różną od zera.\n"
|
||
"<code>== 0 </code>przedmiot został upuszczony\n"
|
||
"<code>!= 0 </code>błąd, nie upuszczono żadnego przedmiotu"
|
||
|
||
#. type: \b; header
|
||
#: ../E/eof.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>eof</code>"
|
||
msgstr "Instrukcja <code>eof</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/eof.txt:2
|
||
#, no-wrap
|
||
msgid "Test the end of file condition of an open file. This is a method of the <code><a cbot|file>file</a></code> class; therefore you cannot write <code>eof()</code> but only <code>handle.eof()</code>:"
|
||
msgstr "Sprawdza warunek końca otwartego pliku. Jest to metoda klasy <code><a cbot|file>file</a></code>; wobec czego zamiast <code>eof()</code> należy napisać <code>handle.eof()</code>:"
|
||
|
||
#. type: Source code
|
||
#: ../E/eof.txt:4
|
||
#, no-wrap
|
||
msgid "\tif ( handle.eof() ) "
|
||
msgstr "\tif ( handle.eof() ) "
|
||
|
||
#. type: Plain text
|
||
#: ../E/eof.txt:6 ../E/readln.txt:11
|
||
#, no-wrap
|
||
msgid "Example:"
|
||
msgstr "Przykład:"
|
||
|
||
#. type: Source code
|
||
#: ../E/eof.txt:8
|
||
#, no-wrap
|
||
msgid ""
|
||
"\twhile ( not handle.eof() )\n"
|
||
"\t{\n"
|
||
"\t\ts = handle.readln();\n"
|
||
"\t}"
|
||
msgstr ""
|
||
"\twhile ( not handle.eof() )\n"
|
||
"\t{\n"
|
||
"\t\ts = handle.readln();\n"
|
||
"\t}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/eof.txt:14
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|file>file</a></code>, <code><a cbot|open>open</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|readln>readln</a></code> and <code><a cbot|writeln>writeln</a></code>.\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<code><a cbot|file>file</a></code>, <code><a cbot|open>open</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|readln>readln</a></code> i <code><a cbot|writeln>writeln</a></code>.\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/errmode.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>errmode</code>"
|
||
msgstr "Instrukcja <code>errmode</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/errmode.txt:2
|
||
#, no-wrap
|
||
msgid "The <c/>errmode();<n/> instruction allows you to chose if the program should stop when an error occurs in one of the following instructions: <code><a cbot|goto>goto</a></code>, <code><a cbot|move>move</a></code>, <code><a cbot|grab>grab</a></code>, <code><a cbot|drop>drop</a></code>, etc."
|
||
msgstr "Instrukcja <c/>errmode();<n/> pozwala wybrać, czy program powinien zatrzymywać się w przypadku wystąpienia błędu w wykonywaniu jednej z następujących instrukcji: <code><a cbot|goto>goto</a></code>, <code><a cbot|move>move</a></code>, <code><a cbot|grab>grab</a></code>, <code><a cbot|drop>drop</a></code>, itd."
|
||
|
||
#. type: Source code
|
||
#: ../E/errmode.txt:6
|
||
#, no-wrap
|
||
msgid "<c/>errmode ( mode );<n/>"
|
||
msgstr "<c/>errmode ( tryb );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/errmode.txt:8
|
||
#, no-wrap
|
||
msgid "Normally the program is stopped when an error occurs. If you use the instruction <c/>errmode(0);<n/> at the beginning of the program, the instructions listed above return a value different from zero if the instruction could not be performed."
|
||
msgstr "Zwykle program zatrzymuje się po wystąpieniu błędu. Po użyciu instrukcji <c/>errmode(0);<n/> na początku programu, wymienione powyżej instrukcje dają w wyniku wartość różną od zera jeśli instrukcja nie mogła być wykonana."
|
||
|
||
#. type: \t; header
|
||
#: ../E/errmode.txt:10
|
||
#, no-wrap
|
||
msgid "mode: <code><a cbot|float>float</a></code> (<code>1</code> per default)"
|
||
msgstr "tryb: <code><a cbot|float>float</a></code> (domyślnie <code>1</code>)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/errmode.txt:11
|
||
#, no-wrap
|
||
msgid ""
|
||
"Error treatment mode.\n"
|
||
"<code>0</code> -> continues program execution and returns a non zero value\n"
|
||
"<code>1</code> -> stops the program (default behavior)"
|
||
msgstr ""
|
||
"Sposób traktowania błędu.\n"
|
||
"<code>0</code> -> kontynuuje działanie programu i daje w wyniku wartość różną od zera\n"
|
||
"<code>1</code> -> zatrzymuje program (działanie domyślne)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/errmode.txt:15
|
||
#, no-wrap
|
||
msgid "Example 1:"
|
||
msgstr "Przykład 1:"
|
||
|
||
#. type: Source code
|
||
#: ../E/errmode.txt:16
|
||
#, no-wrap
|
||
msgid ""
|
||
"<c/>errmode(0);\n"
|
||
"while ( goto(pos) != 0 )\n"
|
||
"{\n"
|
||
"\twait(2);\n"
|
||
"}"
|
||
msgstr ""
|
||
"<c/>errmode(0);\n"
|
||
"while ( goto(pos) != 0 )\n"
|
||
"{\n"
|
||
"\twait(2);\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/errmode.txt:22
|
||
#, no-wrap
|
||
msgid "Example 2:"
|
||
msgstr "Przykład 2:"
|
||
|
||
#. type: Source code
|
||
#: ../E/errmode.txt:23
|
||
#, no-wrap
|
||
msgid ""
|
||
"<c/>errmode(0);\n"
|
||
"int err;\n"
|
||
"err = goto(pos);\n"
|
||
"if ( err != 0 )\n"
|
||
"{\n"
|
||
"\t<n/>goto did not perform correctly ...<code>\n"
|
||
"\t</code>take some appropriate action ...<c/>\n"
|
||
"}"
|
||
msgstr ""
|
||
"<c/>errmode(0);\n"
|
||
"int err;\n"
|
||
"err = goto(pozycja);\n"
|
||
"if ( err != 0 )\n"
|
||
"{\n"
|
||
"\t<n/>instrukcji goto nie udało się wykonać...<code>\n"
|
||
"\t</code>podejmij odpowienie działania...<c/>\n"
|
||
"}"
|
||
|
||
#. type: \b; header
|
||
#: ../E/expr.txt:1
|
||
#, no-wrap
|
||
msgid "Expressions"
|
||
msgstr "Wyrażenia"
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:86
|
||
#, no-wrap
|
||
msgid "is equivalent to"
|
||
msgstr "jest równoważne"
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:90
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code>+=</code> addition\n"
|
||
"<code>-=</code> subtraction\n"
|
||
"<code>*=</code> multiplication\n"
|
||
"<code>/=</code> division\n"
|
||
"<code>%=</code> remainder of the division (only for the type <code><a cbot|int>int</a></code>)"
|
||
msgstr ""
|
||
"<code>+=</code> dodawanie\n"
|
||
"<code>-=</code> odejmowanie\n"
|
||
"<code>*=</code> mnożenie\n"
|
||
"<code>/=</code> dzielenie\n"
|
||
"<code>%=</code> reszta z dzielenia (tylko dla typu całkowitego <code><a cbot|int>int</a></code>)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:178
|
||
#, no-wrap
|
||
msgid "The operators <code>++</code> and <code>--</code> allow you to increment (++) or to decrement (--) a variable in very compact and efficient manner."
|
||
msgstr "Operatory <code>++</code> i <code>--</code> umożliwiają wygodny i zwarty zapis zwiększania (++) lub zmiejszania (--) zmiennych."
|
||
|
||
#. type: \b; header
|
||
#: ../E/extern.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>extern</code>"
|
||
msgstr "Instrukcja <code>extern</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/extern.txt:2
|
||
#, no-wrap
|
||
msgid "The <code>extern</code> instruction determines the <a cbot|function>function</a> that acts as main program of a robot. The name of the function declared with <code>extern</code> will apear in the program list in the lower left corner of the screen."
|
||
msgstr "Instrukcja <code>extern</code> wyróżnia <a cbot|function>funkcję</a>, która jest głównym programem robota. Nazwa funkcji zadeklarowanej jako <code>extern</code> pojawi się na liście programów w lewej dolnej części ekranu."
|
||
|
||
#. type: Source code
|
||
#: ../E/extern.txt:4
|
||
#, no-wrap
|
||
msgid ""
|
||
"extern void object::MowDown( )\n"
|
||
"{\n"
|
||
"\twhile ( true )\n"
|
||
"\t{\n"
|
||
"\t\tfire(1);\n"
|
||
"\t\tturn(10);\n"
|
||
"\t}\n"
|
||
"}"
|
||
msgstr ""
|
||
"extern void object::MowDown( )\n"
|
||
"{\n"
|
||
"\twhile ( true )\n"
|
||
"\t{\n"
|
||
"\t\tfire(1);\n"
|
||
"\t\tturn(10);\n"
|
||
"\t}\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/extern.txt:13
|
||
#, no-wrap
|
||
msgid "If the program contains other functions, only the main function must be preceded by <code>extern</code>."
|
||
msgstr "Jeśli program zawiera inne funkcje, tylko główna funkcja powinna być poprzedzona słowem <code>extern</code>."
|
||
|
||
#. type: Source code
|
||
#: ../E/extern.txt:15
|
||
#, no-wrap
|
||
msgid ""
|
||
"extern void object::Square( )\n"
|
||
"{\n"
|
||
"\tfor ( int i=0 ; i<4 ; i++ )\n"
|
||
"\t{\n"
|
||
"\t\tLine(10);\n"
|
||
"\t}\n"
|
||
"}\n"
|
||
"\n"
|
||
"void object::Line(float dist)\n"
|
||
"{\n"
|
||
"\tmove(dist);\n"
|
||
"\tturn(90);\n"
|
||
"}"
|
||
msgstr ""
|
||
"extern void object::Square( )\n"
|
||
"{\n"
|
||
"\tfor ( int i=0 ; i<4 ; i++ )\n"
|
||
"\t{\n"
|
||
"\t\tLine(10);\n"
|
||
"\t}\n"
|
||
"}\n"
|
||
"\n"
|
||
"void object::Line(float dist)\n"
|
||
"{\n"
|
||
"\tmove(dist);\n"
|
||
"\tturn(90);\n"
|
||
"}"
|
||
|
||
#. type: \b; header
|
||
#: ../E/false.txt:1
|
||
#, no-wrap
|
||
msgid "Type <code>false</code>"
|
||
msgstr "Typ <code>false</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/false.txt:2
|
||
#, no-wrap
|
||
msgid "This value means that a condition is not true; it is one of the two values that a <a cbot|bool>boolean</a> <a cbot|var>variable</a> can take."
|
||
msgstr "Wartość ta oznacza, że warunek nie jest prawdziwy; jest to jedna z dwóch wartości <a cbot|var>zmiennej</a> typu <a cbot|bool>boolean</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/file.txt:1
|
||
#, no-wrap
|
||
msgid "Type <code>file</code>"
|
||
msgstr "Typ <code>file</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/file.txt:2
|
||
#, no-wrap
|
||
msgid "This type is used for accessing files in the files/ folder."
|
||
msgstr "Jest to typ wykorzystywany przy dostępie do plików znajdujących się w folderze files/."
|
||
|
||
#. type: Source code
|
||
#: ../E/file.txt:4
|
||
#, no-wrap
|
||
msgid "\tfile handle();"
|
||
msgstr "\tfile handle();"
|
||
|
||
#. type: Plain text
|
||
#: ../E/file.txt:6
|
||
#, no-wrap
|
||
msgid "Use the syntax above for declaring a file handle. You must use () to create an instance of the <code>file</code> class. Without the () the handle would have the value <code><a cbot|null>null</a></code>."
|
||
msgstr "Powyższej składni należ używać do deklarowania zmiennej plikowej. Konieczne jest użycie () do utworzenia instancji klasy <code>file</code>. Bez (), handle będzie wskazywać na <code><a cbot|null>null</a></code>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/file.txt:8
|
||
#, no-wrap
|
||
msgid "Files can only be created and opened in the files/ folder which is located in the folder inside Colobot save directory. You cannot not create or open files elsewhere than in the files/ folder."
|
||
msgstr "Pliki mogą być tworzone i otwierane tylko w folderze files/, który znajduje sie w folderze zapisów gry Colobot. Nie jest możliwe tworzenie ani otwieranie plików poza folderem files/."
|
||
|
||
#. type: Plain text
|
||
#: ../E/file.txt:11
|
||
#, no-wrap
|
||
msgid "<code>file</code> is actually not a simple type but a class. <code>open</code>, <code>close</code>, <code>writeln</code> etc. are methods of the <code>file</code> class. This is the reason why we always write <code>handle.method()</code>:"
|
||
msgstr "<code>file</code> w rzeczywistości nie jest typem prostym ale klasą. <code>open</code>, <code>close</code>, <code>writeln</code> itd. są metodami klasy <code>file</code>. Dlatego zawsze należy pisać <code>handle.method()</code>:"
|
||
|
||
#. type: Source code
|
||
#: ../E/file.txt:13
|
||
#, no-wrap
|
||
msgid ""
|
||
"\thandle.open(\"test.txt\", \"w\");\n"
|
||
"\thandle.close();"
|
||
msgstr ""
|
||
"\thandle.open(\"test.txt\", \"w\");\n"
|
||
"\thandle.close();"
|
||
|
||
#. type: Plain text
|
||
#: ../E/file.txt:17
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|open>open</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|readln>readln</a></code>, <code><a cbot|writeln>writeln</a></code> and <code><a cbot|eof>eof</a></code>.\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<code><a cbot|open>open</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|readln>readln</a></code>, <code><a cbot|writeln>writeln</a></code> i <code><a cbot|eof>eof</a></code>.\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/fire.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>fire</code>"
|
||
msgstr "Instrukcja <code>fire</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/fire.txt:2
|
||
#, no-wrap
|
||
msgid "The instruction <c/>fire();<n/> fires the bot's onboard cannon."
|
||
msgstr "Instrukcja <c/>fire();<n/> powoduje wystrzał z broni pokładowej robota."
|
||
|
||
#. type: Plain text
|
||
#: ../E/fire.txt:5
|
||
#, no-wrap
|
||
msgid "Generally this instruction is used to shoot one-second bursts:"
|
||
msgstr "Przeważnie instrukcja ta używana jest do jednosekundowych serii strzałów:"
|
||
|
||
#. type: Source code
|
||
#: ../E/fire.txt:7
|
||
#, no-wrap
|
||
msgid "\tfire(1);"
|
||
msgstr "\tfire(1);"
|
||
|
||
#. type: Source code
|
||
#: ../E/fire.txt:11
|
||
#, no-wrap
|
||
msgid "<c/>fire ( time );<n/>"
|
||
msgstr "<c/>fire ( czas );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/fire.txt:13
|
||
#, no-wrap
|
||
msgid "Fires the gun, with a burst that lasts a certain time. The longer the burst, the more energy it needs. This instruction can be used with the following bot types: "
|
||
msgstr "Strzela serią trwającą określony czas. Im dłuższa seria, tym więcej energii jest zużywane. Instrukcja ta może być używana przez następujące typy robotów: "
|
||
|
||
#. type: Plain text
|
||
#: ../E/fire.txt:20
|
||
#, no-wrap
|
||
msgid "In order to move the gun upward or downward, use the instruction <code><a cbot|aim>aim</a></code>."
|
||
msgstr "Do celowania w górę lub w dół, należy używać instrukcji <code><a cbot|aim>aim</a></code>."
|
||
|
||
#. type: \t; header
|
||
#: ../E/fire.txt:22 ../E/wait.txt:15
|
||
#, no-wrap
|
||
msgid "time: <code><a cbot|float>float</a></code>"
|
||
msgstr "czas: <code><a cbot|float>float</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/fire.txt:23
|
||
#, no-wrap
|
||
msgid "Duration of the burst. Generally, the value given is 1. Shorter bursts can also be performed in order to spare time and energy."
|
||
msgstr "Czas trwania serii. Zwykle jest to 1 sekunda. Krótsze serie pozwalają zaoszczędzić czas i energię."
|
||
|
||
#. type: Plain text
|
||
#: ../E/fire.txt:26
|
||
#, no-wrap
|
||
msgid ""
|
||
"Zero if OK, or a value different from zero if an error occurred.\n"
|
||
"<code>== 0 </code>the cannon has been fired\n"
|
||
"<code>!= 0 </code>error, the cannon could not be fired"
|
||
msgstr ""
|
||
"Zero w przypadku powodzenia lub inna wartość jeśli wystąpił błąd.\n"
|
||
"<code>== 0 </code>udało się wystrzelić \n"
|
||
"<code>!= 0 </code>błąd, strzał nie mógł byc wykonany"
|
||
|
||
#. type: \b; header
|
||
#: ../E/flatgrnd.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>flatground</code>"
|
||
msgstr "Instrukcja <code>flatground</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/flatgrnd.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>flatground ( center, rmax );<n/>"
|
||
msgstr "<c/>flatground ( center, rmax );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/flatgrnd.txt:5
|
||
#, no-wrap
|
||
msgid "Calculates the maximal radius of a flat zone on which a building ca be built."
|
||
msgstr "Oblicza maksymalny promień płaskiego obszaru, na którym może być zbudowany budynek."
|
||
|
||
#. type: \t; header
|
||
#: ../E/flatgrnd.txt:7 ../E/flatspace.txt:7
|
||
#, no-wrap
|
||
msgid "center: <code><a cbot|point>point</a></code>"
|
||
msgstr "center: <code><a cbot|point>point</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/flatgrnd.txt:8
|
||
#, no-wrap
|
||
msgid "Center of the circlular zone."
|
||
msgstr "Środek kolistej strefy."
|
||
|
||
#. type: \t; header
|
||
#: ../E/flatgrnd.txt:10
|
||
#, no-wrap
|
||
msgid "rmax: <code><a cbot|float>float</a></code>"
|
||
msgstr "rmax: <code><a cbot|float>float</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/flatgrnd.txt:11
|
||
#, no-wrap
|
||
msgid "Maximal radius."
|
||
msgstr "Maksymalny promień."
|
||
|
||
#. type: Plain text
|
||
#: ../E/flatgrnd.txt:14
|
||
#, no-wrap
|
||
msgid "Radius of the flat zone (always between 0 and rmax)."
|
||
msgstr "Promień płaskiego obszaru (zawsze pomiędzy 0 i rmax)."
|
||
|
||
#. type: \b; header
|
||
#: ../E/float.txt:1
|
||
#, no-wrap
|
||
msgid "Type <code>float</code>"
|
||
msgstr "Typ <code>float</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/float.txt:2
|
||
#, no-wrap
|
||
msgid "Use this type for most variables that contains numbers. Variables of this type can contain positive and negative numbers, whole or real numbers, for example: "
|
||
msgstr "Typ ten jest używany dla większości zmiennych zawierających liczby. Zmienne tego typu mogą zawierać liczby dodatnie i ujemne, zarówno całkowite jak i rzeczywiste, na przykład: "
|
||
|
||
#. type: Source code
|
||
#: ../E/float.txt:4
|
||
#, no-wrap
|
||
msgid ""
|
||
"\t12.9\n"
|
||
"\t1.125\n"
|
||
"\t0.002\n"
|
||
"\t-4.1"
|
||
msgstr ""
|
||
"\t12.9\n"
|
||
"\t1.125\n"
|
||
"\t0.002\n"
|
||
"\t-4.1"
|
||
|
||
#. type: Plain text
|
||
#: ../E/float.txt:9
|
||
#, no-wrap
|
||
msgid "If you need only whole numbers (f. ex. 12 or -5000), you should rather use the type <code><a cbot|int>int</a></code>."
|
||
msgstr "Jeśli potrzebne są tylko liczby całkowite (takie jak 12 lub -5000), lepszym wyborem jest użycie typu <code><a cbot|int>int</a></code>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/float.txt:12
|
||
#, no-wrap
|
||
msgid "Do not insert space or colon characters into a number. To separate the whole part from the fractional part, use a dot. "
|
||
msgstr "Nie można wstawiać spacji ani przecinków wewnątrz liczby. Do rozdzielania części całkowitej i części ułamkowej należy używać kropki. "
|
||
|
||
#. type: Source code
|
||
#: ../E/float.txt:14
|
||
#, no-wrap
|
||
msgid ""
|
||
" Write and not\n"
|
||
" 12.56 12 . 56\n"
|
||
" -54.34 -54,34\n"
|
||
"12895.69 12,895.69"
|
||
msgstr ""
|
||
" dobrze źle\n"
|
||
" 12.56 12 . 56\n"
|
||
" -54.34 -54,34\n"
|
||
"12895.69 12,895.69"
|
||
|
||
#. type: Plain text
|
||
#: ../E/float.txt:20
|
||
#, no-wrap
|
||
msgid ""
|
||
"Floating point numbers are represented in Colobot with 32 bits.\n"
|
||
"The highest value that can be represented is 3.4E+38.\n"
|
||
"The smallest value that can be represented is 3.4E-38."
|
||
msgstr ""
|
||
"Liczby zmiennoprzecinkowe reprezentowane są w grze Colobot za pomocą 32 bitów.\n"
|
||
"Największa reprezentowalna wartość to 3.4E+38.\n"
|
||
"Najmniejsza reprezentowalna wartość to 3.4E-38."
|
||
|
||
#. type: \b; header
|
||
#: ../E/for.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>for</code>"
|
||
msgstr "Instrukcja <code>for</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/for.txt:3
|
||
#, no-wrap
|
||
msgid ""
|
||
"<c/>for ( before ; condition ; end )\n"
|
||
"{\n"
|
||
"\t<n/>Instructions ...<c/>\n"
|
||
"}"
|
||
msgstr ""
|
||
"<c/>for ( przed ; warunek ; koniec )\n"
|
||
"{\n"
|
||
"\t<n/>Instrukcje...<c/>\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/for.txt:8
|
||
#, no-wrap
|
||
msgid "This instruction allows you to execute a certain number of times the instructions contained in the <a cbot|bloc>block</a>."
|
||
msgstr "Instrukcja ta pozwala na powtórzenie określoną ilość razy instrukcji zawartych w <a cbot|bloc>bloku</a>."
|
||
|
||
#. type: \t; header
|
||
#: ../E/for.txt:10
|
||
#, no-wrap
|
||
msgid "<code>before</code>"
|
||
msgstr "<code>przed</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/for.txt:14
|
||
#, no-wrap
|
||
msgid "This <a cbot|cond>condition</a> determines if another instance of the loop must be executed. It is tested before every instance of the loop. "
|
||
msgstr "<a cbot|cond>Warunek</a> określa, czy powinno być wykonane następne przejście pętli. Jest on sprawdzany przed każdym jej przejściem. "
|
||
|
||
#. type: \t; header
|
||
#: ../E/for.txt:16
|
||
#, no-wrap
|
||
msgid "<code>end</code>"
|
||
msgstr "<code>koniec</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/for.txt:21
|
||
#, no-wrap
|
||
msgid ""
|
||
"{\n"
|
||
"\tmessage(i) ;\n"
|
||
"}"
|
||
msgstr ""
|
||
"{\n"
|
||
"\tmessage(i) ;\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/for.txt:25
|
||
#, no-wrap
|
||
msgid "The following example is strictly equivalent to a <code>for</code>-loop, but it uses the instruction <code><a cbot|while>while</a></code>:"
|
||
msgstr "Następujący przykład, równoważny pętli <code>for</code>, używa instrukcji <code><a cbot|while>while</a></code>:"
|
||
|
||
#. type: Source code
|
||
#: ../E/for.txt:26
|
||
#, no-wrap
|
||
msgid ""
|
||
"<c/>before;\n"
|
||
"while ( condition )\n"
|
||
"{\n"
|
||
"\t<n/>Instructions ...<c/>\n"
|
||
"\tend;\n"
|
||
"}"
|
||
msgstr ""
|
||
"<c/>przed;\n"
|
||
"while ( warunek )\n"
|
||
"{\n"
|
||
"\t<n/>Instrukcje...<c/>\n"
|
||
"\tkoniec;\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/for.txt:34
|
||
#, no-wrap
|
||
msgid "Do not put a <a cbot|term>semicolon</a> at the end of the line <code>for ( )</code>."
|
||
msgstr "Na końcu instrukcji <code>for ( )</code> nie należy umieszczać <a cbot|term>średnika</a>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/for.txt:36
|
||
#, no-wrap
|
||
msgid "The instructions <code><a cbot|break>break</a></code> and <code><a cbot|continue>continue</a></code> can be useful inside a block following the instruction <code>for </code>."
|
||
msgstr "Instrukcje <code><a cbot|break>break</a></code> i <code><a cbot|continue>continue</a></code> mogą być przydatne wewnątrz bloku instrukcji <code>for </code>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/function.txt:1
|
||
#, no-wrap
|
||
msgid "Functions"
|
||
msgstr "Funkcje"
|
||
|
||
#. type: Plain text
|
||
#: ../E/function.txt:118
|
||
#, no-wrap
|
||
msgid "You can also declare a function <a cbot|public>public</a> so it can be used by other bots."
|
||
msgstr "Można też zadeklarować funkcję <a cbot|public>publiczną</a>, która będzie dostępna dla wszystkich robotów."
|
||
|
||
#. type: \b; header
|
||
#: ../E/goto.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>goto</code>"
|
||
msgstr "Instrukcja <code>goto</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/goto.txt:2
|
||
#, no-wrap
|
||
msgid "The instruction <c/>goto();<n/> instructs the bot to reach a given position."
|
||
msgstr "Instrukcja <c/>goto();<n/> rozkazuje robotowi udać się do podanej pozycji."
|
||
|
||
#. type: Plain text
|
||
#: ../E/goto.txt:5
|
||
#, no-wrap
|
||
msgid "The most current use consists in moving the bot to an object located with the instruction <c/><a cbot|radar>radar</a>();<n/>. If the information returned by the <c/><a cbot|radar>radar</a>();<n/> has been stored in a certain variable, write the name of the variable followed by <code>.position</code> in order to get the position of the object. Here is an example of a program that looks for a <a object|titan>titanium cube</a>, goes to the position and grabs it:"
|
||
msgstr "Najczęstsze użycie polega na wysłaniu robota do obiektu zlokalizowanego przy użyciu instrukcji <c/><a cbot|radar>radar</a>();<n/>. Jeśli jego dane zastały zapisane w zmiennej, należy po nazwie zmiennej napisać <code>.position</code> aby otrzymać pozycję obiektu. Oto przykładowy program znajdujący <a object|titan>kostkę tytanu</a> idący na jej pozycję i podnoszący ją:"
|
||
|
||
#. type: Source code
|
||
#: ../E/goto.txt:7
|
||
#, no-wrap
|
||
msgid ""
|
||
"\titem = <a cbot|radar>radar</a>(Titanium);\n"
|
||
"\tgoto(item.position);\n"
|
||
"\t<a cbot|grab>grab</a>();"
|
||
msgstr ""
|
||
"\telement = <a cbot|radar>radar</a>(Titanium);\n"
|
||
"\tgoto(element.position);\n"
|
||
"\t<a cbot|grab>grab</a>();"
|
||
|
||
#. type: Source code
|
||
#: ../E/goto.txt:13
|
||
#, no-wrap
|
||
msgid "<c/>goto ( position, altitude, goal, crash );<n/>"
|
||
msgstr "<c/>goto ( pozycja, wysokość, cel, zderzenie );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/goto.txt:15
|
||
#, no-wrap
|
||
msgid "Tells the robot to go to the given position, avoiding all the obstacles if this is possible. "
|
||
msgstr "Rozkazuje robotowi udać się w podane miejsce unikając wszelkich przeszkód, jeśli to możliwe. "
|
||
|
||
#. type: Plain text
|
||
#: ../E/goto.txt:18
|
||
#, no-wrap
|
||
msgid "Coordinates of the goal position."
|
||
msgstr "Współrzędne pozycji docelowej."
|
||
|
||
#. type: \t; header
|
||
#: ../E/goto.txt:20
|
||
#, no-wrap
|
||
msgid "altitude: <code><a cbot|float>float</a></code>"
|
||
msgstr "wysokość: <code><a cbot|float>float</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/goto.txt:21
|
||
#, no-wrap
|
||
msgid "Flight altitude for <a object|botgj>winged bots</a>. The altitude is useful only for <a object|botgj>winged bots</a>. From the initial altitude, the bot climbs higher until it reaches the specified hight. When arriving close to destination, it goes down to touch the ground at the given position. If no value is given, an altitude of 10 meters is the default value. On very short moves, even winged bot stay on the ground. For all bot except winged bots, this parameter is ignored. "
|
||
msgstr "Wysokość lotu <a object|botgj>robota latającego</a>. Parametr ten jest użyteczny tylko w przypadku <a object|botgj>robota latającego</a>. Z wysokości początkowej, robot wznosi się do góry, do czasu osiągnięcia określonej wysokości. Po zbliżeniu się do miejsca docelowego, zmniejsza wysokość, aby opaść na ziemię w zadanej pozycji. Jeśli nie określono wysokości, domyślną wartością jest 10 metrów. Przy bardzo krótkich trasach, nawet robot latający może poruszać się po ziemi. Parametr ten jest ignorowany dla wszystkich robotów poza robotem latającym. "
|
||
|
||
#. type: \t; header
|
||
#: ../E/goto.txt:23
|
||
#, no-wrap
|
||
msgid "goal: <code><a cbot|int>int</a></code> (default value <code>0</code>)"
|
||
msgstr "cel: <code><a cbot|int>int</a></code> (domyślna wartość: <code>0</code>)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/goto.txt:24
|
||
#, no-wrap
|
||
msgid ""
|
||
"This parameter tells the bot how it must reach the goal: \n"
|
||
"<code>0</code> stops exactly at the goal position\n"
|
||
"<code>1</code> goes close to the goal position, without stopping.\n"
|
||
"If no value is given, <code>0</code> (precision) is the default value."
|
||
msgstr ""
|
||
"Określa sposób w jaki robot powinien osiągnąć swoj cel: \n"
|
||
"<code>0</code> zatrzymuje się dokładnie w pozycji docelowej\n"
|
||
"<code>1</code> zbliża się do pozycji docelowej bez zatrzymywania się.\n"
|
||
"Jeśli nie określono wartości, domyślnie przyjmowane jest <code>0</code> (dokładnie)."
|
||
|
||
#. type: Plain text
|
||
#: ../E/goto.txt:30
|
||
#, no-wrap
|
||
msgid ""
|
||
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <code>goto()</code>.\n"
|
||
"<code>== 0 </code>Goal position reached\n"
|
||
"<code>!= 0 </code>Goal position impossible to reach"
|
||
msgstr ""
|
||
"Zwykle wystąpienie błędu powoduje zatrzymanie programu. Można wyłączyć zatrzymywanie się programu w przypadku wystąpienia błędu, używając instrukcji <code><a cbot|errmode>errmode</a>(0)</code>. Wtedy w przypadku wystąpienia błędu instrukcja <code>goto()</code> zwraca w wyniku wartość różną od zera.\n"
|
||
"<code>== 0 </code>Pozycja docelowa została osiągnięta\n"
|
||
"<code>!= 0 </code>Osiągnięcie pozycji docelowej jest niemożliwe"
|
||
|
||
#. type: \b; header
|
||
#: ../E/grab.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>grab</code>"
|
||
msgstr "Instrukcja <code>grab</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/grab.txt:2
|
||
#, no-wrap
|
||
msgid "The instruction <c/>grab();<n/> instructs the bot to use the operating arm to grab an object located on the ground, on the platform of a building or on the power cell location of a bot."
|
||
msgstr "Instrukcja <c/>grab();<n/> rozkazuje robotowi podnieść za pomocą ramienia chwytającego przedmiot znajdujący się na ziemi, platformie budynku lub miejscu na ogniwo robota."
|
||
|
||
#. type: Plain text
|
||
#: ../E/grab.txt:5
|
||
#, no-wrap
|
||
msgid "The instruction <c/>grab();<n/> written in this form grabs the object located in front of the bot. Here is a short program that grabs an object in front of the bot and drops it 5 meters further:"
|
||
msgstr "Instrukcja <c/>grab();<n/> napisana w ten sposób, podniesie przedmiot znajdujący się przed robotem. Oto krótki program podnoszący przedmiot przed robotem i upuszczający go 5 metrów dalej:"
|
||
|
||
#. type: Source code
|
||
#: ../E/grab.txt:7
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tgrab();\n"
|
||
"\t<a cbot|move>move</a>(5);\n"
|
||
"\t<a cbot|drop>drop</a>();"
|
||
msgstr ""
|
||
"\tgrab();\n"
|
||
"\t<a cbot|move>move</a>(5);\n"
|
||
"\t<a cbot|drop>drop</a>();"
|
||
|
||
#. type: Source code
|
||
#: ../E/grab.txt:13
|
||
#, no-wrap
|
||
msgid "<c/>grab ( oper );<n/>"
|
||
msgstr "<c/>grab ( oper );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/grab.txt:15
|
||
#, no-wrap
|
||
msgid "This instruction appeals to the operating arm of a <a object|botgr>grabber bot</a>, in order to grab the closest object."
|
||
msgstr "Instrukcja ta odwołuje się do ramienia <a object|botgr>robota transportera</a>, powodując chwycenie najbliższego obiektu."
|
||
|
||
#. type: Plain text
|
||
#: ../E/grab.txt:18
|
||
#, no-wrap
|
||
msgid ""
|
||
"Oper indicates where the bot should look for an object to grab. If no indication is given, the object is picked up in front of the bot.\n"
|
||
"<code>InFront </code> Grabs in front (default value).\n"
|
||
"<code>Behind </code> Grabs behind.\n"
|
||
"<code>EnergyCell</code> Grabs the bot's own power cell."
|
||
msgstr ""
|
||
"Parametr oper określa gdzie robot powinien szukać przedmiotu do podniesienia. Jeśli nie jest to określone, podnoszony jest obiekt znajdujący się przed robotem:\n"
|
||
"<code>InFront </code> przed (domyślnie).\n"
|
||
"<code>Behind </code> za.\n"
|
||
"<code>EnergyCell</code> wyjmuje własne ogniwo elektryczne."
|
||
|
||
#. type: Plain text
|
||
#: ../E/grab.txt:24
|
||
#, no-wrap
|
||
msgid ""
|
||
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <c/>grab();<n/>.\n"
|
||
"<code>== 0 </code>an object was grabbed\n"
|
||
"<code>!= 0 </code>error, no object was grabbed"
|
||
msgstr ""
|
||
"Zwykle wystąpienie błędu powoduje zatrzymanie programu. Można wyłączyć zatrzymywanie się programu w przypadku wystąpienia błędu, używając instrukcji <code><a cbot|errmode>errmode</a>(0)</code>. Wtedy w przypadku wystąpienia błędu instrukcja <c/>grab();<n/> zwraca w wyniku wartość różną od zera.\n"
|
||
"<code>== 0 </code>obiekt został chwycony\n"
|
||
"<code>!= 0 </code>błąd, obiekt nie został chwycony"
|
||
|
||
#. type: \b; header
|
||
#: ../E/if.txt:1
|
||
#, no-wrap
|
||
msgid "Instructions <code>if</code> and <code>else</code>"
|
||
msgstr "Instrukcje <code>if</code> i <code>else</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/if.txt:2
|
||
#, no-wrap
|
||
msgid "With the instruction <code>if() {}</code> you can execute a set of instructions only if a certain condition is true. Write the condition in brackets <code>()</code>, and the instructions in braces <code>{}</code>."
|
||
msgstr "Używając instrukcji <code>if() {}</code> można uzależnić wykonanie zbioru instrukcji od spełnienia określonego warunku. Warunek należy zapisać w nawiasach <code>()</code>, a instrukcje w nawiasach klamrowych <code>{}</code>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/if.txt:5
|
||
#, no-wrap
|
||
msgid "Here is a concrete example: The bot will shoot only if the target is closer than 40 meters:"
|
||
msgstr "Oto konkretny przykład: Robot będzie strzelał dopiero wtedy, gdy cel będzie bliżej niż 40 metrów:"
|
||
|
||
#. type: Source code
|
||
#: ../E/if.txt:7
|
||
#, no-wrap
|
||
msgid ""
|
||
"\titem = <a cbot|radar>radar</a>(AlienAnt);\n"
|
||
"\tif (<a cbot|dist>distance</a>(position, item.position) < 40)\n"
|
||
"\t{\n"
|
||
"\t\tfire(1);\n"
|
||
"\t}"
|
||
msgstr ""
|
||
"\titem = <a cbot|radar>radar</a>(AlienAnt);\n"
|
||
"\tif (<a cbot|dist>distance</a>(position, item.position) < 40)\n"
|
||
"\t{\n"
|
||
"\t\tfire(1);\n"
|
||
"\t}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/if.txt:13
|
||
#, no-wrap
|
||
msgid "You can also test if an object exists at all. If the instruction <c/><a cbot|radar>radar</a>();<n/> does not find the requested object, it returns the value <code>null</code>. So you can test if an object does not exists with the condition <code>(item == null)</code>, or test if it exists with <code>(item != null)</code>. Two equal signs <code>==</code> test equality, an exclamation mark followed by an equal sign <code>!=</code> test inequality. Here is a test that will go to rechage the <a object|power>power cell</a> only if there is a <a object|station>power station</a>:"
|
||
msgstr "Można też sprawdzić czy obiekt istnieje w ogóle. Jeśli instrukcja <c/><a cbot|radar>radar</a>();<n/> nie znajdzie żądanego obiektu, zwraca wartość <code>null</code>. Można więc sprawdzić czy obiekt istnieje, warunkiem <code>(item != null)</code> lub czy nie istnieje <code>(item == null)</code>. Dwa znaki równości <code>==</code> sprawdzają równość, znak równości poprzedzony wykrzyknikiem <code>!=</code> sprawdza nierówność. Oto program testowy, który będzie ładował <a object|power>ogniwa elektryczne</a> tylko wtedy, gdy znajdzie <a object|station>stację energetyczną</a>:"
|
||
|
||
#. type: Source code
|
||
#: ../E/if.txt:15
|
||
#, no-wrap
|
||
msgid ""
|
||
"\titem = <a cbot|radar>radar</a>(PowerStation);\n"
|
||
"\tif (item != null)\n"
|
||
"\t{\n"
|
||
"\t\t<a cbot|goto>goto</a>(item.position);\n"
|
||
"\t\t<a cbot|wait>wait</a>(5);\n"
|
||
"\t}"
|
||
msgstr ""
|
||
"\titem = <a cbot|radar>radar</a>(PowerStation);\n"
|
||
"\tif (item != null)\n"
|
||
"\t{\n"
|
||
"\t\t<a cbot|goto>goto</a>(item.position);\n"
|
||
"\t\t<a cbot|wait>wait</a>(5);\n"
|
||
"\t}"
|
||
|
||
#. type: Source code
|
||
#: ../E/if.txt:24
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code>if ( condition )\n"
|
||
"{\n"
|
||
"\t</code>Instructions A ...<code>\n"
|
||
"}\n"
|
||
"else\n"
|
||
"{\n"
|
||
"\t</code>Instructions B ...<c/>\n"
|
||
"}"
|
||
msgstr ""
|
||
"<code>if ( warunek )\n"
|
||
"{\n"
|
||
"\t</code>Instrukcje A ...<code>\n"
|
||
"}\n"
|
||
"else\n"
|
||
"{\n"
|
||
"\t</code>Instrukcje B ...<c/>\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/if.txt:33
|
||
#, no-wrap
|
||
msgid ""
|
||
"With this conditional structure you can execute a <a cbot|bloc>bloc</a> A or a <a cbot|bloc>bloc</a> B depending on a <a cbot|cond>condition</a>. If the condition is true, bloc A is executed. If the condition is false, bloc B is executed. \n"
|
||
"Part <code>else { }</code> is not compulsory. "
|
||
msgstr ""
|
||
"Przy użyciu tej struktury warunkowej można wykonać <a cbot|bloc>blok</a> A lub <a cbot|bloc>blok</a> B w zależności od <a cbot|cond>warunku</a>. Jeśli warunek jest prawdziwy, wykonywany jest blok A. Jeśli warunek jest fałszywy, wykonywany jest blok B. \n"
|
||
"Część <code>else { }</code> nie jest obowiązkowa. "
|
||
|
||
#. type: Plain text
|
||
#: ../E/if.txt:37
|
||
#, no-wrap
|
||
msgid "Do not put a <a cbot|term>semicolon</a> at the end of the line <code>if ( )</code>."
|
||
msgstr "Na końcu linii <code>if ( )</code> nie należy stawiać <a cbot|term>średnika</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/int.txt:1
|
||
#, no-wrap
|
||
msgid "Type <code>int</code>"
|
||
msgstr "Typ <code>int</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/int.txt:2
|
||
#, no-wrap
|
||
msgid "Use this type for variables that contain only whole numbers, negative or positive. For example: "
|
||
msgstr "Jest to typ zmiennych zawierających tylko liczby całkowite, dodatnie albo ujemne. Na przykład: "
|
||
|
||
#. type: Source code
|
||
#: ../E/int.txt:4
|
||
#, no-wrap
|
||
msgid ""
|
||
"\t12\n"
|
||
"\t1000\n"
|
||
"\t-4"
|
||
msgstr ""
|
||
"\t12\n"
|
||
"\t1000\n"
|
||
"\t-4"
|
||
|
||
#. type: Plain text
|
||
#: ../E/int.txt:8
|
||
#, no-wrap
|
||
msgid "To represent real numbers like 12.05 or -0.005, use the type <code><a cbot|float>float</a></code>."
|
||
msgstr "Do reprezentacji liczb rzeczywistych, takich jak 12,05 lub -0,005 należy używać typu <code><a cbot|float>float</a></code>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/int.txt:11
|
||
#, no-wrap
|
||
msgid "Do not put space or colon signs inside a number. "
|
||
msgstr "Nie należy używać spacji ani przecinków w zapisie liczby. "
|
||
|
||
#. type: Plain text
|
||
#: ../E/int.txt:14
|
||
#, no-wrap
|
||
msgid ""
|
||
"Numbers of the type <code>int</code> are represented with 32 bits.\n"
|
||
"The highest number that can be represented is (2^31)-1, that is 2'147'483'647.\n"
|
||
"The smallest number that can be represented is -(2^31), that is -2'147'483'648."
|
||
msgstr ""
|
||
"Reprezentacja liczb typu <code>int</code> zajmuje 32 bity.\n"
|
||
"Największa reprezentowalna liczba to (2^31)-1, czyli 2 147 483 647.\n"
|
||
"Najmniejsza reprezentowalna liczba to -(2^31), czyli -2 147 483 648."
|
||
|
||
#. type: \b; header
|
||
#: ../E/jet.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>jet</code>"
|
||
msgstr "Instrukcja <code>jet</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/jet.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>jet ( power );<n/>"
|
||
msgstr "<c/>jet ( moc );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/jet.txt:5
|
||
#, no-wrap
|
||
msgid "Direct control of the jet of a <a object|botgj>winged bot</a>. The jet is what makes the bot fly. Use this instruction in order to take off, climb, descend or land."
|
||
msgstr "Umożliwia bezpośrednią kontrolę nad silnikiem odrzutowym <a object|botgj>robota latającego</a>. Silnik odrzutowy umożliwia robotom latanie. Instrukcja ta może służyć do wznoszenia się, zwiększania i zmniejszania wysokości lotu oraz lądowania."
|
||
|
||
#. type: \t; header
|
||
#: ../E/jet.txt:7 ../E/produce.txt:21
|
||
#, no-wrap
|
||
msgid "power: <code><a cbot|float>float</a></code>"
|
||
msgstr "moc: <code><a cbot|float>float</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/jet.txt:8
|
||
#, no-wrap
|
||
msgid "Power of the jet, ranges between <code>-1</code> and <code>+1</code>. <c/>jet(1);<n/> instructs the bot to climb as fast as possible, <c/>jet(-1);<n/> descends as fast as possible, <c/>jet(0);<n/> stabilizes the altitude. In order to get slower altitude changes, use intermediate values, for example <c/>jet(0.3);<n/>."
|
||
msgstr "Moc silnika odrzutowego, może zawierać się w zakresie od <code>-1</code> do <code>+1</code>. <c/>jet(1);<n/> to sposób na najszybsze wznoszenie się robota, <c/>jet(-1);<n/> zmniejsza wysokość tak szybko, jak to możliwe, <c/>jet(0);<n/> utrzymuje stałą wysokość. W celu uzyskania wolniejszych zmian wysokości, należy użyć wartości pośrednich, na przykład <c/>jet(0.3);<n/>."
|
||
|
||
#. type: \t; header
|
||
#: ../E/jet.txt:11 ../E/message.txt:21 ../E/motor.txt:35 ../E/shield.txt:15 ../E/wait.txt:18
|
||
#, no-wrap
|
||
msgid "Return value: <code><a cbot|void>void</a></code>"
|
||
msgstr "Typ wyniku: <code><a cbot|void>void</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/jet.txt:12 ../E/message.txt:22 ../E/motor.txt:36 ../E/shield.txt:16 ../E/wait.txt:19
|
||
#, no-wrap
|
||
msgid "None."
|
||
msgstr "Brak."
|
||
|
||
#. type: \b; header
|
||
#: ../E/message.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>message</code>"
|
||
msgstr "Instrukcja <code>message</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/message.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>message ( text, type );<n/>"
|
||
msgstr "<c/>message ( tekst, typ );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/message.txt:5
|
||
#, no-wrap
|
||
msgid "Prints a message on top of the screen. After a few seconds, the message disappears automatically. "
|
||
msgstr "Wyświetla wiadomość na górze ekranu. Wiadomość znika automatycznie po kilku sekundach. "
|
||
|
||
#. type: \t; header
|
||
#: ../E/message.txt:7
|
||
#, no-wrap
|
||
msgid "text: <code><a cbot|string>string</a></code>"
|
||
msgstr "tekst: <code><a cbot|string>string</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/message.txt:8
|
||
#, no-wrap
|
||
msgid ""
|
||
"Text that is to be displayed. It is possible to append several texts and/or values with the operator <code>+</code>:\n"
|
||
"<c/>message(\"Not found\");<n/> \n"
|
||
"<c/>message(angle);<n/> \n"
|
||
"<c/>message(n + \" object(s) found\");<n/> \n"
|
||
"<c/>message(\"Distance = \" + dist + \" meters\");<n/> "
|
||
msgstr ""
|
||
"Tekst do wyświetlenia. Możliwe jest złączanie tekstów i/lub wartości przy użyciu operatora <code>+</code>:\n"
|
||
"<c/>message(\"Nie znaleziono\");<n/> \n"
|
||
"<c/>message(kąt);<n/> \n"
|
||
"<c/>message(n + \" obiektów\");<n/> \n"
|
||
"<c/>message(\"Odległość = \" + dist + \" metrów\");<n/> "
|
||
|
||
#. type: \t; header
|
||
#: ../E/message.txt:14
|
||
#, no-wrap
|
||
msgid "type: <code><a cbot|int>int</a></code> (default value <code>DisplayMessage</code>)"
|
||
msgstr "typ: <code><a cbot|int>int</a></code> (domyślna wartość: <code>DisplayMessage</code>)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/message.txt:15
|
||
#, no-wrap
|
||
msgid "Type of the message, that determines the background color. "
|
||
msgstr "Typ wiadomości, określający kolor tła. "
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/message.txt:16
|
||
#, no-wrap
|
||
msgid "<code>DisplayMessage</code> Standard message on yellow background."
|
||
msgstr "<code>DisplayMessage</code> Standardowa wiadomość na żółtym tle."
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/message.txt:17
|
||
#, no-wrap
|
||
msgid "<code>DisplayInfo </code> Information on green background."
|
||
msgstr "<code>DisplayInfo </code> Informacja na zielonym tle."
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/message.txt:18
|
||
#, no-wrap
|
||
msgid "<code>DisplayWarning</code> Warning on blue background."
|
||
msgstr "<code>DisplayWarning</code> Ostrzeżenie na niebieskim tle."
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/message.txt:19
|
||
#, no-wrap
|
||
msgid "<code>DisplayError </code> Error on red background."
|
||
msgstr "<code>DisplayError </code> Błąd na czerwonym tle."
|
||
|
||
#. type: \b; header
|
||
#: ../E/motor.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>motor</code>"
|
||
msgstr "Instrukcja <code>motor</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/motor.txt:2
|
||
#, no-wrap
|
||
msgid "The instruction <c/>motor( , );<n/> sets the speed for the left-hand and the right-hand motor of the bot."
|
||
msgstr "Instrukcja <c/>motor( , );<n/> ustawia prędkość lewego i prawego silnika robota."
|
||
|
||
#. type: Plain text
|
||
#: ../E/motor.txt:5
|
||
#, no-wrap
|
||
msgid "The speed given to the motors will remain constant during the execution of the following instructions. Thanks to this characteristic it is possible to perform a rotation during the instruction <c/><a cbot|fire>fire</a>();<n/>. This will sweep a whole zone with only one burst. Here is an example that will sweep the zone in front of the bot:"
|
||
msgstr "Prędkość nadana robotowi pozostaje niezmienna podczas wykonywania następujących instrukcji. Dzięki temu możliwe jest obracanie robota podczas wykonywania instrukcji <c/><a cbot|fire>fire</a>();<n/>. Pozwala to na omiecenie całego obszaru jedną serią. Oto program omiatający całą strefę przed robotem:"
|
||
|
||
#. type: Source code
|
||
#: ../E/motor.txt:7
|
||
#, no-wrap
|
||
msgid ""
|
||
"\t<a cbot|turn>turn</a>(45); // turns 45 degrees left\n"
|
||
"\tmotor(0.5, -0.5); // slow rotation to the right\n"
|
||
"\t<a cbot|fire>fire</a>(2); // fire\n"
|
||
"\tmotor(0,0); // stops the rotation"
|
||
msgstr ""
|
||
"\t<a cbot|turn>turn</a>(45); // obróć o 45 stopnie w lewo\n"
|
||
"\tmotor(0.5, -0.5); // powoli obracaj w prawo\n"
|
||
"\t<a cbot|fire>fire</a>(2); // strzelaj\n"
|
||
"\tmotor(0,0); // zatrzymaj obracanie"
|
||
|
||
#. type: Plain text
|
||
#: ../E/motor.txt:12
|
||
#, no-wrap
|
||
msgid "With the left-hand motor turning half-speed forward and the right-hand motor turning half-speed backward, the bot will turn slowly on itself during the 2-second-burst."
|
||
msgstr "Z lewym silnikiem obracającym się z połową prędkości do przodu i prawym obracającym się z połową prędkości do tyłu, robot będzie się powoli obracał podczas 2 sekundowej serii strzałów."
|
||
|
||
#. type: Source code
|
||
#: ../E/motor.txt:16
|
||
#, no-wrap
|
||
msgid "<c/>motor ( left, right );<n/>"
|
||
msgstr "<c/>motor ( lewy, prawy );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/motor.txt:18
|
||
#, no-wrap
|
||
msgid "Gives speed instructions to the right and left motors of the robot. The motors will keep this speed until a new motor instruction is performed, or until a <code><a cbot|move>move</a></code>, <code><a cbot|turn>turn</a></code> or <code><a cbot|goto>goto</a></code> instruction is performed."
|
||
msgstr "Ustala prędkości prawego i lewego silnika. Silniki będą poruszały się z tą prędkością do czasu ustalenia nowej prędkości silników lub wykonania jednej z instrukcji: <code><a cbot|move>move</a></code>, <code><a cbot|turn>turn</a></code> lub <code><a cbot|goto>goto</a></code>."
|
||
|
||
#. type: \t; header
|
||
#: ../E/motor.txt:20
|
||
#, no-wrap
|
||
msgid "left: <code><a cbot|float>float</a></code>"
|
||
msgstr "lewy: <code><a cbot|float>float</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/motor.txt:21
|
||
#, no-wrap
|
||
msgid "Speed instruction for the left motor; the value must range between -1 and 1. "
|
||
msgstr "Prędkość lewego silnika; wartości w zakresie od -1 do 1. "
|
||
|
||
#. type: \t; header
|
||
#: ../E/motor.txt:23
|
||
#, no-wrap
|
||
msgid "right: <code><a cbot|float>float</a></code>"
|
||
msgstr "prawy: <code><a cbot|float>float</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/motor.txt:24
|
||
#, no-wrap
|
||
msgid "Speed instruction for the right motor; the value must range between -1 and 1. "
|
||
msgstr "Prędkość prawego silnika; wartości w zakresie od -1 do 1. "
|
||
|
||
#. type: Plain text
|
||
#: ../E/motor.txt:26
|
||
#, no-wrap
|
||
msgid ""
|
||
"Examples :\n"
|
||
"<c/>motor(1, 1);<n/> moves forward with highest possible speed.\n"
|
||
"<c/>motor(-0.5, -0.5);<n/> moves backward with half speed.\n"
|
||
"<c/>motor(1, -1);<n/> turns right as fast as possible. "
|
||
msgstr ""
|
||
"Przykłady :\n"
|
||
"<c/>motor(1, 1);<n/> ruch do przodu z maksymalną prędkością.\n"
|
||
"<c/>motor(-0.5, -0.5);<n/> ruch do tyłu z połową prędkości.\n"
|
||
"<c/>motor(1, -1);<n/> obrót w prawo z maksymalną prędkością. "
|
||
|
||
#. type: Plain text
|
||
#: ../E/motor.txt:31
|
||
#, no-wrap
|
||
msgid ""
|
||
"Note :\n"
|
||
"<c/>motor(2, 2);<n/> will not move forward any faster than <code>motor(1, 1)</code> \n"
|
||
"<c/>motor(-2, -2);<n/> will not move backward any faster than <code>motor(-1, -1)</code>"
|
||
msgstr ""
|
||
"Uwaga:\n"
|
||
"<c/>motor(2, 2);<n/> nie będzie poruszało robotem do przodu szybciej niż <code>motor(1, 1)</code> \n"
|
||
"<c/>motor(-2, -2);<n/> nie będzie poruszało robotem do tyłu szybciej niż <code>motor(-1, -1)</code>"
|
||
|
||
#. type: \b; header
|
||
#: ../E/move.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>move</code>"
|
||
msgstr "Instrukcja <code>move</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/move.txt:2
|
||
#, no-wrap
|
||
msgid "The instruction <c/>move();<n/> instructs the bot to move forward or backward while keeping the same orientation. In brackets you must specify the length of the move in meters."
|
||
msgstr "Instrukcja <c/>move();<n/> rozkazuje robotowi poruszać się do przodu lub do tyłu przy zachowaniu niezmiennej orientacji. W nawiasie należy podać odległość (w metrach) o jaką powinien przemieścić się robot."
|
||
|
||
#. type: Plain text
|
||
#: ../E/move.txt:5
|
||
#, no-wrap
|
||
msgid "If you want the bot to move forward 30 meters, write <c/>move(30);<n/>. In order to move the bot backward after it dropped a chunk of <a object|titanore>titanium ore</a> on the <a object|convert>converter</a>, write <c/>move(-2.5);<n/>."
|
||
msgstr "Aby robot przemieścił się do przodu o 30 metrów, należy napisać <c/>move(30);<n/>. Aby robot cofnął się po umieszczeniu <a object|titanore>rudy tytanu</a> w <a object|convert>hucie</a>, należy napisać <c/>move(-2.5);<n/>."
|
||
|
||
#. type: Source code
|
||
#: ../E/move.txt:9
|
||
#, no-wrap
|
||
msgid "<c/>move ( length );<n/>"
|
||
msgstr "<c/>move ( odległość );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/move.txt:11
|
||
#, no-wrap
|
||
msgid "Moves forward or backward of a given distance, always keeping the current orientation of the bot. "
|
||
msgstr "Porusza robotem do przodu lub do tyłu o zadaną odległość, zachowując bieżącą orientację robota. "
|
||
|
||
#. type: \t; header
|
||
#: ../E/move.txt:13
|
||
#, no-wrap
|
||
msgid "length: <code><a cbot|float>float</a></code>"
|
||
msgstr "odległość: <code><a cbot|float>float</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/move.txt:14
|
||
#, no-wrap
|
||
msgid "Length of the move, in meters. A negative value makes the bot move backward. "
|
||
msgstr "Odległość w metrach. Wartość ujemna powoduje ruch do tyłu. "
|
||
|
||
#. type: Plain text
|
||
#: ../E/move.txt:17
|
||
#, no-wrap
|
||
msgid ""
|
||
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <code>move()</code>.\n"
|
||
"<code>== 0 </code>Move executed\n"
|
||
"<code>!= 0 </code>error, the instruction was not performed correctly"
|
||
msgstr ""
|
||
"Zwykle wystąpienie błędu powoduje zatrzymanie programu. Można wyłączyć zatrzymywanie się programu w przypadku wystąpienia błędu, używając instrukcji <code><a cbot|errmode>errmode</a>(0)</code>. Wtedy w przypadku wystąpienia błędu instrukcja <c/>move();<n/> zwraca w wyniku wartość różną od zera.\n"
|
||
"<code>== 0 </code>instrukcja move zosta<74><61>a wykonana\n"
|
||
"<code>!= 0 </code>błąd, instrukcja nie została poprawnie wykonana"
|
||
|
||
#. type: \b; header
|
||
#: ../E/nan.txt:1
|
||
#, no-wrap
|
||
msgid "Type <code>nan</code>"
|
||
msgstr "Typ <code>nan</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/nan.txt:2
|
||
#, no-wrap
|
||
msgid ""
|
||
"This special value indicates that a <a cbot|var>variable</a> of type <code><a cbot|int>int</a></code> or <code><a cbot|float>float</a></code> contains no number, but \"nothing\". \n"
|
||
"For example, if the instruction <code><a cbot|receive>receive</a></code> can not get the requested information, it returns <code>nan</code> :"
|
||
msgstr ""
|
||
"Specjalna wartość oznaczająca, że <a cbot|var>zmienna</a> typu <code><a cbot|int>int</a></code> lub <code><a cbot|float>float</a></code> nie zawiera liczby ale \"nic\". \n"
|
||
"Na przykład jeśli instrukcja <code><a cbot|receive>receive</a></code> nie może uzyskać żądanej informacji, zwraca w wyniku wartość <code>nan</code>:"
|
||
|
||
#. type: Source code
|
||
#: ../E/nan.txt:5
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tvalue = receive(\"Length\");\n"
|
||
"\tif ( value == nan ) // not found ?\n"
|
||
"\t{\n"
|
||
"\t\t\n"
|
||
"\t}"
|
||
msgstr ""
|
||
"\twartość = receive(\"Length\");\n"
|
||
"\tif ( wartość == nan ) // nie znaleziono?\n"
|
||
"\t{\n"
|
||
"\t\t\n"
|
||
"\t}"
|
||
|
||
#. type: \t; header
|
||
#: ../E/nan.txt:11
|
||
#, no-wrap
|
||
msgid "Dictionnary"
|
||
msgstr "Słownik"
|
||
|
||
#. type: Plain text
|
||
#: ../E/nan.txt:12
|
||
#, no-wrap
|
||
msgid "<code>nan</code> = Not A Number "
|
||
msgstr "<code>nan</code> = Not A Number (nie liczba) "
|
||
|
||
#. type: \b; header
|
||
#: ../E/new.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>new</code> (for specialists)"
|
||
msgstr "Instrukcja <code>new</code> (dla specjalistów)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/new.txt:2
|
||
#, no-wrap
|
||
msgid ""
|
||
"The <code>new</code> operator creates a <a cbot|class>class</a> instance:\n"
|
||
"<c/><s/>\tMyClass item; // now item is a null reference"
|
||
msgstr ""
|
||
"Operator <code>new</code> tworzy nową instancję <a cbot|class>klasy</a>:\n"
|
||
"<c/><s/>\tMojaKlasa element; // jest teraz wskaźnikiem null"
|
||
|
||
#. type: Source code
|
||
#: ../E/new.txt:4
|
||
#, no-wrap
|
||
msgid ""
|
||
"\titem = new MyClass(); // now item is a reference\n"
|
||
"\t // to a new class instance"
|
||
msgstr ""
|
||
"\telement = new MojaKlasa(); // jest teraz wskaźnikiem\n"
|
||
"\t // do nowej instancji klasy"
|
||
|
||
#. type: Plain text
|
||
#: ../E/new.txt:7
|
||
#, no-wrap
|
||
msgid "If you want to create a new instance at declaration time you can ommit the new <code>new</code> operator by putting () after the declaration:"
|
||
msgstr "W przypadku tworzenia nowej instancji podczas deklaracji, można ominąć operator <code>new</code>, dodając () na końcu deklaracji:"
|
||
|
||
#. type: Plain text
|
||
#: ../E/new.txt:9
|
||
#, no-wrap
|
||
msgid ""
|
||
"Instead of:\n"
|
||
"<c/><s/>\tMyClass item = new MyClass();\n"
|
||
"<n/>you can write:\n"
|
||
"<c/><s/>\tMyClass item();"
|
||
msgstr ""
|
||
"Zamiast:\n"
|
||
"<c/><s/>\tMojaKlasa element = new MojaKlasa();\n"
|
||
"<n/>można napisać:\n"
|
||
"<c/><s/>\tMojaKlasa element();"
|
||
|
||
#. type: Plain text
|
||
#: ../E/new.txt:14
|
||
#, no-wrap
|
||
msgid ""
|
||
"If your class has a constructor with parameters you can write:\n"
|
||
"<c/><s/>\tMyClass item = new MyClass(2, 3);\n"
|
||
"<n/>or:\n"
|
||
"<c/><s/>\tMyClass item(2, 3);"
|
||
msgstr ""
|
||
"Jeśli klasa ma konstruktor z parametrami, można napisać:\n"
|
||
"<c/><s/>\tMojaKlasa element = new MojaKlasa(2, 3);\n"
|
||
"<n/>lub:\n"
|
||
"<c/><s/>\tMojaKlasa element(2, 3);"
|
||
|
||
#. type: Plain text
|
||
#: ../E/new.txt:21
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|class>class</a></code>, <code><a cbot|pointer>reference</a></code>\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<code><a cbot|class>klasa</a></code>, <code><a cbot|pointer>wskaźnik</a></code>\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/null.txt:1
|
||
#, no-wrap
|
||
msgid "Type <code>null</code>"
|
||
msgstr "Typ <code>null</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/null.txt:2
|
||
#, no-wrap
|
||
msgid "This special value indicates that the variable containing it does not reference an instance."
|
||
msgstr "Specjalna wartość oznaczająca, że zmienna, która ją zawiera nie wskazuje na żadną instancję."
|
||
|
||
#. type: Plain text
|
||
#: ../E/null.txt:5
|
||
#, no-wrap
|
||
msgid ""
|
||
"<a cbot|pointer>References</a>\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<a cbot|pointer>Wskaźniki</a>\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/object.txt:1
|
||
#, no-wrap
|
||
msgid "Type <code>object</code>"
|
||
msgstr "Typ <code>object</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/object.txt:21
|
||
#, no-wrap
|
||
msgid "<code>category</code>"
|
||
msgstr "<code>category</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/object.txt:24
|
||
#, no-wrap
|
||
msgid "<code>position</code>"
|
||
msgstr "<code>position</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/object.txt:25
|
||
#, no-wrap
|
||
msgid "Position of the object on the planet, in meters. The coordinates <code>x</code> and <code>y</code> correspond to the location on a map, the <code>z</code> coordinate corresponds to the altitude above (respectively below) sea level. "
|
||
msgstr "Położenie obiektu na planecie, w metrach. Współrzędne <code>x</code> i <code>y</code> odnoszą się do położenia na mapie, współrzędna <code>z</code> odpowiada wysokości nad (lub odpowiednio pod) poziomem morza. "
|
||
|
||
#. type: Source code
|
||
#: ../E/object.txt:27
|
||
#, no-wrap
|
||
msgid "<code>orientation</code>"
|
||
msgstr "<code>orientation</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/object.txt:28
|
||
#, no-wrap
|
||
msgid "Orientation of the object, in degrees. The orientation tells you what direction the object is facing. An orientation of <code>0</code> corresponds to an object facing eastwards, thus following the positive <code>x</code> axis. The orientation is measured counterclockwise. "
|
||
msgstr "Orientacja obiektu, w stopniach. Określa kierunek, w którym obrócony jest obiekt. Wartość <code>0</code> odpowiada orientacji na wschód, zgodnie z dodatnią osią <code>x</code>. Orientacja liczona jest przeciwnie do ruchu wskazówek zegara. "
|
||
|
||
#. type: Source code
|
||
#: ../E/object.txt:30
|
||
#, no-wrap
|
||
msgid "<code>pitch</code>"
|
||
msgstr "<code>pitch</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/object.txt:31
|
||
#, no-wrap
|
||
msgid "Forward/backward angle of the robot. A pitch of <code>0</code> means that the bot is standing on flat ground. A positive inclination means that it is facing upwards, a negative inclination means that it is facing downwards. "
|
||
msgstr "Pochylenie robota w przód/tył. Wartość <code>0</code> oznacza, że robot stoi na płaskim terenie. Wartość dodatnia oznacza, że robot \"patrzy\" w górę, wartość ujemna, że w dół. "
|
||
|
||
#. type: Source code
|
||
#: ../E/object.txt:33
|
||
#, no-wrap
|
||
msgid "<code>roll</code>"
|
||
msgstr "<code>roll</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/object.txt:34
|
||
#, no-wrap
|
||
msgid "Left/right angle of the bot, in degrees. A positive value means that the bot is leaning to the left side, a negative value means that it is leaning to the right side. "
|
||
msgstr "Pochylenie robota w lewo/prawo. Wartość dodatnia oznacza, że robot jest przechylony na lewą stronę, wartość ujemna, że na prawą. "
|
||
|
||
#. type: Source code
|
||
#: ../E/object.txt:36
|
||
#, no-wrap
|
||
msgid "<code>energyLevel</code>"
|
||
msgstr "<code>energyLevel</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/object.txt:37
|
||
#, no-wrap
|
||
msgid "Energy level, between 0 and 1. A normal <a object|power>power cell</a> that is fully charged returns the value <code>1</code>. A <a object|atomic>nuclear power cell</a> never returns a value higher than 1, it just lasts longer. Attention: The energy level of a bot is always zero, because the energy is not contained in the bot, but in the power cell. To know the energy level of the power cell of a bot, you must write <code>energyCell.energyLevel</code>. "
|
||
msgstr "Poziom energii, pomiędzy 0 i 1. Dla w pełni naładowanego <a object|power>zwykłego ogniwa elektrycznego</a> zwracana jest wartość <code>1</code>. <a object|atomic>Atomowe ogniwo elektryczne</a> nigdy nie zwraca wartości większej niż 1, jedynie działa dłużej. Uwaga: Poziom energii robota zawsze jest równy zero, gdyż energia nie jest zawarta w robocie ale w ogniwie elektrycznym. Aby poznać poziom energii ogniwa elektrycznego robota, należy napisać <code>energyCell.energyLevel</code>. "
|
||
|
||
#. type: Source code
|
||
#: ../E/object.txt:39
|
||
#, no-wrap
|
||
msgid "<code>shieldLevel</code>"
|
||
msgstr "<code>shieldLevel</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/object.txt:40
|
||
#, no-wrap
|
||
msgid ""
|
||
"Shield level of a robot or building. A level <code>1</code> indicates that the shield is still perfect. Every time that the bot or building gets a bullet or collides with another object, the shield level decreases. When the level reaches <code>0</code>, the next bullet or collision will destroy the bot or building. \n"
|
||
"Bots can re-energize their shield on a <a object|repair>repair center</a>. The shield of a building is repaired if it lays inside the protection sphere of a <a object|botshld>shielder</a>."
|
||
msgstr ""
|
||
"Poziom osłony robota albo budynku. Wartość <code>1</code> oznacza w pełni sprawną osłonę. Za każdym uderzeniem pocisku lub zderzeniem z innym obiektem, zmniejsza się poziom osłony. Gdy osiągnie on <code>0</code>, następny pocisk bądź zderzenie spowoduje zniszczenie robota albo budynku. \n"
|
||
"Roboty mogą zregenerować osłony w <a object|repair>warsztacie</a>. Powłoka budynku regenerowana jest gdy znajdzie się w zasięgu sfery ochronnej robota <a object|botshld>osłaniacza</a>."
|
||
|
||
#. type: Source code
|
||
#: ../E/object.txt:43
|
||
#, no-wrap
|
||
msgid "<code>temperature</code>"
|
||
msgstr "<code>temperature</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/object.txt:44
|
||
#, no-wrap
|
||
msgid "Temperature of the jet of <a object|botgj>winged bots</a>. <code>0</code> corresponds to a cold jet. When used, the temperature increases progressively. When it reaches the value <code>1</code>, the jet is overheated and stops working, until it cooled down a little. "
|
||
msgstr "Temperatura silnika odrzutowego <a object|botgj>robotów latających</a>. <code>0</code> odpowiada zimnemu silnikowi. W miarę używania, wzrasta jego temperatura. Gdy osiągnie wartość <code>1</code>, silnik przegrzewa się i przestaje działać do czasu ostygnięcia. "
|
||
|
||
#. type: Source code
|
||
#: ../E/object.txt:46
|
||
#, no-wrap
|
||
msgid "<code>altitude</code>"
|
||
msgstr "<code>altitude</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/object.txt:47
|
||
#, no-wrap
|
||
msgid "The <code>z</code> coordinate of the position indicates the altitude above sea level, whereas the <code>altitude</code> indicates the height above ground. This value is meaningful only for <a object|botgj>winged bots</a> and for <a object|wasp>wasps</a>. For all other objects, this value is zero. "
|
||
msgstr "Współrzędna <code>z</code> oznacza wysokość nad poziomem morza, podczas gdy <code>altitude</code> oznacza wysokość nad poziomem ziemi. Wartość ta ma znaczenie jedynie dla <a object|botgj>robotów latających</a> i <a object|wasp>os</a>. Dla pozostałych obiektów jest zerowa. "
|
||
|
||
#. type: Source code
|
||
#: ../E/object.txt:49
|
||
#, no-wrap
|
||
msgid "<code>lifeTime</code>"
|
||
msgstr "<code>lifeTime</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/object.txt:50
|
||
#, no-wrap
|
||
msgid "The age of the object in seconds since it's creation."
|
||
msgstr "Wiek obiektów, w sekundach, od czasu ich powstania."
|
||
|
||
#. type: Source code
|
||
#: ../E/object.txt:52
|
||
#, no-wrap
|
||
msgid "<code>energyCell</code>"
|
||
msgstr "<code>energyCell</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/object.txt:53
|
||
#, no-wrap
|
||
msgid ""
|
||
"This information is special, because it returns the information about another object, in this case the power pack. This means that energyCell contains all the characteristics of a normal object, for example <code>category</code> (PowerCell or NuclearCell), <code>position</code> (the position of the cell), etc.\n"
|
||
"If you want to know the energy level of a robot, you must not check <code>energyLevel</code>, but <code>energyCell.energyLevel</code>.\n"
|
||
"If the bot has bot no power cell, <code>energyCell</code> returns <code>null</code>."
|
||
msgstr ""
|
||
"Jest to specjalna informacja, gdyż zwraca informacje o innym obiekcie, w tym przypadku ogniwie elektrycznym. Oznacza to, że energyCell zawiera wszystkie charakterystyki normalnego obiektu, na przykład <code>category</code> (PowerCell lub NuclearCell), <code>position</code> (pozycję ogniwa), itp.\n"
|
||
"Aby poznać poziom energii robota, zamiast <code>energyLevel</code>, należy sprawdzić <code>energyCell.energyLevel</code>.\n"
|
||
"Jeśli robot nie zawiera ogniwa elektrycznego, <code>energyCell</code> jest równe <code>null</code>."
|
||
|
||
#. type: Source code
|
||
#: ../E/object.txt:57
|
||
#, no-wrap
|
||
msgid "<code>load</code>"
|
||
msgstr "<code>load</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/object.txt:58
|
||
#, no-wrap
|
||
msgid "This information also returns the description of a whole object: the description of the object carried by a <a object|botgr>grabber</a>. If it carries nothing, <code>load</code> returns <code>null</code>."
|
||
msgstr "Ta informacja również zwraca opis całego obiektu, a mianowicie opis obiektu trzymanego przez <a object|botgr>transporter</a>. Jeśli nie niesie on niczego, <code>load</code> jest równe <code>null</code>."
|
||
|
||
#. type: \t; header, \b; header
|
||
#: ../E/expr.txt:99 ../E/expr.txt:123 ../E/expr.txt:145 ../E/expr.txt:170 ../E/expr.txt:187 ../E/object.txt:66
|
||
#, no-wrap
|
||
msgid "Examples"
|
||
msgstr "Przykłady"
|
||
|
||
#. type: Plain text
|
||
#: ../E/object.txt:67
|
||
#, no-wrap
|
||
msgid "The type <code>object</code> returns the special value <code><a cbot|null>null</a></code> when the object does not exist. For example:"
|
||
msgstr "Typ <code>object</code> zwraca specjalną wartość <code><a cbot|null>null</a></code> gdy obiekt nie istnieje. Na przykład:"
|
||
|
||
#. type: Source code
|
||
#: ../E/object.txt:69
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tobject a;\n"
|
||
"\ta = radar(BotGrabberRoller);\n"
|
||
"\tif ( a == null ) // object does not exist ?\n"
|
||
"\t{\n"
|
||
"\t}\n"
|
||
"\tif ( a.position.z > 50 ) // is it on a mountain ?\n"
|
||
"\t{\n"
|
||
"\t}"
|
||
msgstr ""
|
||
"\tobject a;\n"
|
||
"\ta = radar(BotGrabberRoller);\n"
|
||
"\tif ( a == null ) // obiekt nie istnieje?\n"
|
||
"\t{\n"
|
||
"\t}\n"
|
||
"\tif ( a.position.z > 50 ) // czy jest na górze?\n"
|
||
"\t{\n"
|
||
"\t}"
|
||
|
||
#. type: \b; header
|
||
#: ../E/open.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>open</code>"
|
||
msgstr "Instrukcja <code>open</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/open.txt:2
|
||
#, no-wrap
|
||
msgid "Open a text file in the files/ folder. This is a method of the <code><a cbot|file>file</a></code> class. This is the reason why we always write <code>handle.open()</code>:"
|
||
msgstr "Otwiera plik tekstowy w folderze files/. Jest to metoda klasy <code><a cbot|file>file</a></code>, dlatego zawsze należy używać konstrukcji <code>handle.open()</code>:"
|
||
|
||
#. type: Source code
|
||
#: ../E/open.txt:4
|
||
#, no-wrap
|
||
msgid "\thandle.open(\"test.txt\", \"w\");"
|
||
msgstr "\thandle.open(\"test.txt\", \"w\");"
|
||
|
||
#. type: Plain text
|
||
#: ../E/open.txt:6
|
||
#, no-wrap
|
||
msgid "To open a file, proceed as follows:"
|
||
msgstr "Aby otworzyć plik, należy postępować następująco:"
|
||
|
||
#. type: Source code
|
||
#: ../E/open.txt:8
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tfile handle();\n"
|
||
"\thandle.open(\"filename\", \"w\");\n"
|
||
"\thandle.writeln(\"abc\");\n"
|
||
"\thandle.close();"
|
||
msgstr ""
|
||
"\tfile handle();\n"
|
||
"\thandle.open(\"nazwapliku\", \"w\");\n"
|
||
"\thandle.writeln(\"abc\");\n"
|
||
"\thandle.close();"
|
||
|
||
#. type: Plain text
|
||
#: ../E/open.txt:17
|
||
#, no-wrap
|
||
msgid "Files can only be created and opened in the files/ folder which is located in the folder inside Colobot save directory. You cannot not create or open files that are located elsewhere than in the files/ folder."
|
||
msgstr "Pliki mogą być tworzone tylko w folderze files/ znajdującym się w folderze zapisów gry Colobot. Nie jest możliwe tworzenie ani otwieranie plików znajdujących się w innych folderach."
|
||
|
||
#. type: Plain text
|
||
#: ../E/open.txt:20
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|file>file</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|readln>readln</a></code>, <code><a cbot|writeln>writeln</a></code> and <code><a cbot|eof>eof</a></code>.\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<code><a cbot|file>file</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|readln>readln</a></code>, <code><a cbot|writeln>writeln</a></code> i <code><a cbot|eof>eof</a></code>.\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/openfile.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>openfile</code>"
|
||
msgstr "Instrukcja <code>openfile</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/openfile.txt:4
|
||
#, no-wrap
|
||
msgid "file handle = openfile(\"filename\", \"r\");"
|
||
msgstr "file handle = openfile(\"nazwapliku\", \"r\");"
|
||
|
||
#. type: \b; header
|
||
#: ../E/point.txt:1
|
||
#, no-wrap
|
||
msgid "Type <code>point</code>"
|
||
msgstr "Typ <code>point</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/point.txt:2
|
||
#, no-wrap
|
||
msgid ""
|
||
"Variables of this type contain the coordinates of a point in space. This type is made of three values that represent the <code>x</code>, <code>y</code> and <code>z</code> coordinates.\n"
|
||
"<code>x</code> and <code>y</code> correspond to the place on the ground. The positive <code>x</code> axis faces towards east, the positive <code>y</code> axis faces towards north. \n"
|
||
"The <code>z</code> value corresponds to the altitude above sea level. "
|
||
msgstr ""
|
||
"Zmienne tego typu zawierają współrzędne punktu w przestrzeni. Składa się on z trzech wartości reprezentujących współrzędne <code>x</code>, <code>y</code> oraz \\ c;z<n/>.\n"
|
||
"<code>x</code> i <code>y</code> odpowiadają miejscu na powierzchni ziemi. Dodatnia oś <code>x</code> wskazuje wschód, dodatnia oś <code>y</code> wskazuje północ. \n"
|
||
"Wartość <code>z</code> odpowiada wysokości nad poziomem morza. "
|
||
|
||
#. type: Plain text
|
||
#: ../E/point.txt:6
|
||
#, no-wrap
|
||
msgid "If you want to declare a variable of type point, you can write: "
|
||
msgstr "Aby zadeklarować zmienną typu point, można napisać: "
|
||
|
||
#. type: Source code
|
||
#: ../E/point.txt:8
|
||
#, no-wrap
|
||
msgid "\tpoint a (10, 20, 30);"
|
||
msgstr "\tpoint a (10, 20, 30);"
|
||
|
||
#. type: Plain text
|
||
#: ../E/point.txt:10
|
||
#, no-wrap
|
||
msgid "You can also set the variable taking one value after another:"
|
||
msgstr "Można również pojedynczo ustawić wartości współrzędnych:"
|
||
|
||
#. type: Source code
|
||
#: ../E/point.txt:12
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tpoint b;\n"
|
||
"\tb.x = 10;\n"
|
||
"\tb.y = 20;\n"
|
||
"\tb.z = 30;"
|
||
msgstr ""
|
||
"\tpoint b;\n"
|
||
"\tb.x = 10;\n"
|
||
"\tb.y = 20;\n"
|
||
"\tb.z = 30;"
|
||
|
||
#. type: Plain text
|
||
#: ../E/point.txt:17
|
||
#, no-wrap
|
||
msgid "With these examples, the following <a cbot|cond>condition</a> is true:"
|
||
msgstr "W przykładach tych, następujący <a cbot|cond>warunek</a> jest prawdziwy:"
|
||
|
||
#. type: Source code
|
||
#: ../E/point.txt:19
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tif ( a == b )\n"
|
||
"\t{\n"
|
||
"\t}"
|
||
msgstr ""
|
||
"\tif ( a == b )\n"
|
||
"\t{\n"
|
||
"\t}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/point.txt:22
|
||
#, no-wrap
|
||
msgid ""
|
||
"<n/> \n"
|
||
"The following declaration :"
|
||
msgstr ""
|
||
"<n/> \n"
|
||
"Następująca deklaracja:"
|
||
|
||
#. type: Source code
|
||
#: ../E/point.txt:25
|
||
#, no-wrap
|
||
msgid "\tpoint c (4, 7);"
|
||
msgstr "\tpoint c (4, 7);"
|
||
|
||
#. type: Plain text
|
||
#: ../E/point.txt:27
|
||
#, no-wrap
|
||
msgid "Is equivalent to :"
|
||
msgstr "Jest równoważna poniższej:"
|
||
|
||
#. type: Source code
|
||
#: ../E/point.txt:29
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tpoint c;\n"
|
||
"\tc.x = 4;\n"
|
||
"\tc.y = 7;\n"
|
||
"\tc.z = 0;"
|
||
msgstr ""
|
||
"\tpoint c;\n"
|
||
"\tc.x = 4;\n"
|
||
"\tc.y = 7;\n"
|
||
"\tc.z = 0;"
|
||
|
||
#. type: \b; header
|
||
#: ../E/pointer.txt:1
|
||
#, no-wrap
|
||
msgid "References (for specialists)"
|
||
msgstr "Wskaźniki (dla specjalistów)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/pointer.txt:2
|
||
#, no-wrap
|
||
msgid "CBOT uses references for <a cbot|class>classes</a> and <a cbot|array>arrays</a>. Any class variable actually contains a reference to the instance. The instance actually contains the class fields. Several references can reference the same instance. A <code><a cbot|null>null</a></code> reference references nothing. You can compare an instance to a suitcase and a reference to a carrier. Each time we need a new suitcase we create a new instance with a carrier. But a suitcase can be carried by more than one carrier. A carrier who carries no suitcase is a <code><a cbot|null>null</a></code> reference."
|
||
msgstr "CBOT używa odwołań do <a cbot|class>klas</a> i <a cbot|array>tablic</a>. Każda zmienna w rzeczywistości zawiera odwołanie do instancji. Instancja natomiast zawiera pola klasy. Wiele wskaźników może odwoływać się do tej samej instancji. Wskaźnik <code><a cbot|null>null</a></code> nie odwołuje się do niczego. Instancję można porównać do teczki, a wskaźnik do trzymającego. Za każdym razem gdy potrzebujemy nowej teczki, tworzymy nową instancję z trzymającym. Ale teczka może być trzymana przez więcej niż jedną osobę. Osoba nie trzymająca żadnej teczki to wskaźnik na <code><a cbot|null>null</a></code>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/pointer.txt:4
|
||
#, no-wrap
|
||
msgid ""
|
||
"Example:\n"
|
||
"<c/><s/>{"
|
||
msgstr ""
|
||
"Przykład:\n"
|
||
"<c/><s/>{"
|
||
|
||
#. type: Source code
|
||
#: ../E/pointer.txt:6
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tMyClass item1(); // create a new instance\n"
|
||
"\t // referenced by item1\n"
|
||
"\tMyClass item2; // create a null reference\n"
|
||
"\titem2 = item1; // copy the reference,\n"
|
||
"\t // item2 and item1 now reference\n"
|
||
"\t // the same instance\n"
|
||
"\titem1.a = 12; // modifies the instance\n"
|
||
"\t // referenced by item1 (and item2)\n"
|
||
"\tmessage(item2.a);// displays 12\n"
|
||
"}"
|
||
msgstr ""
|
||
"\tMojaKlasa item1();// utwórz nową instancję\n"
|
||
"\t // wskazywaną przez item1\n"
|
||
"\tMojaKlasa item2; // utwórz wskaźnik null\n"
|
||
"\titem2 = item1; // skopiuj wskaźnik,\n"
|
||
"\t // item2 i item1 wskazują\n"
|
||
"\t // teraz tę samą instancję\n"
|
||
"\titem1.a = 12; // zmodyfikuj instancję \n"
|
||
"\t // wskazywaną przez item1 (i item2)\n"
|
||
"\tmessage(item2.a); // wyświetla liczbę 12\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/pointer.txt:17
|
||
#, no-wrap
|
||
msgid "If you pass a <a cbot|class>class</a> instance as parameter to a function, the function only receives a reference to the instance. That means if you modify the instance in the function, the instance that has been specified by the caller will be actuallay modified."
|
||
msgstr "W przypadku przekazania instancji <a cbot|class>klasy</a> jako parametru funkcji, funkcja otrzymuje wskaźnik do tej instancji. Oznacza to, że w przypadku modyfikacji instancji wewnątrz funkcji, zostanie zmodyfikowana instancja podana przy wywołaniu funkcji jako parametr."
|
||
|
||
#. type: Plain text
|
||
#: ../E/pointer.txt:19
|
||
#, no-wrap
|
||
msgid "<c/><s/>void Test( MyClass item )"
|
||
msgstr "<c/><s/>void Test( MojaKlasa item )"
|
||
|
||
#. type: Source code
|
||
#: ../E/pointer.txt:20
|
||
#, no-wrap
|
||
msgid ""
|
||
"{\n"
|
||
"\titem.a = 12; // modify the original instance\n"
|
||
"\titem = new MyClass(); // new local instance\n"
|
||
"\titem.a = 33; // modifie the local instance\n"
|
||
"}"
|
||
msgstr ""
|
||
"{\n"
|
||
"\titem.a = 12; // zmodyfikuj oryginalną instancję\n"
|
||
"\titem = new MojaKlasa(); // nowa instancja lokalna\n"
|
||
"\titem.a = 33; // zmodyfikuj instancję lokalną\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/pointer.txt:26
|
||
#, no-wrap
|
||
msgid ""
|
||
"Calling the fucntion <code>Test()</code>:\n"
|
||
"<c/><s/>{"
|
||
msgstr ""
|
||
"Wywołanie funkcji <code>Test()</code>:\n"
|
||
"<c/><s/>{"
|
||
|
||
#. type: Source code
|
||
#: ../E/pointer.txt:28
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tMyClass toto();\n"
|
||
"\tTest(toto);\n"
|
||
"\tmessage(toto.a); // displays 12\n"
|
||
"}"
|
||
msgstr ""
|
||
"\tMojaKlasa toto();\n"
|
||
"\tTest(toto);\n"
|
||
"\tmessage(toto.a); // wyświetla 12\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/pointer.txt:33
|
||
#, no-wrap
|
||
msgid "The instance containing the field <code>a = 33</code> is referenced only by the newly created instance <code>item</code> inside the fucntion <code>Test</code>. At the end of <code>Test</code> this newly created instance referenced by <code>item</code> is automatically deleted."
|
||
msgstr "Instancja zawierająca pole <code>a = 33</code> jest wskazywana tylko przez nowoutworzoną instancję <code>item</code> wewnątrz funkcji <code>Test</code>. Na końcu funkcji <code>Test</code> ta instancja wskazywana przez <code>item</code> jest automatycznie usuwana."
|
||
|
||
#. type: Plain text
|
||
#: ../E/pointer.txt:35
|
||
#, no-wrap
|
||
msgid ""
|
||
"A function can return an instance:\n"
|
||
"<c/><s/>MyClass Test2( )"
|
||
msgstr ""
|
||
"Funkcja może zwrócić instancję:\n"
|
||
"<c/><s/>MojaKlasa Test2( )"
|
||
|
||
#. type: Source code
|
||
#: ../E/pointer.txt:37
|
||
#, no-wrap
|
||
msgid ""
|
||
"{\n"
|
||
"\tMyClass item = new MyClass();\n"
|
||
"\titem.x = 33;\n"
|
||
"\treturn item;\n"
|
||
"}"
|
||
msgstr ""
|
||
"{\n"
|
||
"\tMojaKlasa item = new MojaKlasa();\n"
|
||
"\titem.x = 33;\n"
|
||
"\treturn item;\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/pointer.txt:43
|
||
#, no-wrap
|
||
msgid ""
|
||
"Call the function like this:\n"
|
||
"<c/><s/>{"
|
||
msgstr ""
|
||
"W taki sposób należy wywoływać funkcję:\n"
|
||
"<c/><s/>{"
|
||
|
||
#. type: Source code
|
||
#: ../E/pointer.txt:45
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tMyClass toto;\n"
|
||
"\ttoto = Test2(); // toto will contain a reference to\n"
|
||
"\t // the instance created by Test2()\n"
|
||
"\tmessage(toto.a); // displays 33\n"
|
||
"}"
|
||
msgstr ""
|
||
"\tMojaKlasa toto;\n"
|
||
"\ttoto = Test2(); // toto będzie zawierać wskaźnik do\n"
|
||
"\t // instancji utworzonej przez Test2()\n"
|
||
"\tmessage(toto.a); // wyświetla 33\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/pointer.txt:52
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|class>class</a></code>, <code><a cbot|new>new</a></code>\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<code><a cbot|class>class</a></code>, <code><a cbot|new>new</a></code>\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/private.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>private</code> (for specialists)"
|
||
msgstr "Instrukcja <code>private</code> (dla specjalistów)"
|
||
|
||
#. type: Source code
|
||
#: ../E/private.txt:6
|
||
#, no-wrap
|
||
msgid ""
|
||
"public class MyClass\n"
|
||
"{\n"
|
||
"\tint b; // public by default\n"
|
||
"\tpublic int a; // also public \n"
|
||
"\tprivate point position; // private\n"
|
||
"}\n"
|
||
"void Test()\n"
|
||
"{\n"
|
||
"\tMyClass item;\n"
|
||
"\titem.a = item.b = 12; // ok\n"
|
||
"\tmessage( item.position ); // this is an error\n"
|
||
"}"
|
||
msgstr ""
|
||
"public class MojaKlasa\n"
|
||
"{\n"
|
||
"\tint b; // publiczna domyślnie\n"
|
||
"\tpublic int a; // również publiczna \n"
|
||
"\tprivate point position; // prywatna\n"
|
||
"}\n"
|
||
"void Test()\n"
|
||
"{\n"
|
||
"\tMojaKlasa item;\n"
|
||
"\titem.a = item.b = 12; // ok\n"
|
||
"\tmessage( item.position ); // powoduje błąd\n"
|
||
"}"
|
||
|
||
#. type: \b; header
|
||
#: ../E/public.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>public</code> (for specialists)"
|
||
msgstr "Instrukcja <code>public</code> (dla specjalistów)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/public.txt:2
|
||
#, no-wrap
|
||
msgid "This instruction has two distinct purposes:"
|
||
msgstr "Instrukcja ta ma dwa podstawowe zadania:"
|
||
|
||
#. type: Bullet: '1)'
|
||
#: ../E/public.txt:4
|
||
#, no-wrap
|
||
msgid "Make a function available to other bots."
|
||
msgstr "Czyni funkcję dostępną dla innych robotów."
|
||
|
||
#. type: Bullet: '2)'
|
||
#: ../E/public.txt:5
|
||
#, no-wrap
|
||
msgid "Make a class member accessible from outside the class definition."
|
||
msgstr "Sprawia, że element klasy jest widoczny poza definicją klasy."
|
||
|
||
#. type: \b; header
|
||
#: ../E/public.txt:7
|
||
#, no-wrap
|
||
msgid "Instruction <code>public</code> for functions"
|
||
msgstr "Instrukcja <code>public</code> dla funkcji"
|
||
|
||
#. type: Plain text
|
||
#: ../E/public.txt:8
|
||
#, no-wrap
|
||
msgid "If you put <code>public</code> before a <a cbot|function>function</a> definition, you can make the function available to programs in other bots in the same mission."
|
||
msgstr "Umieszczenie instrukcji <code>public</code> przed definicją <a cbot|function>funkcji</a> sprawi, że funkcja będzie dostępna dla innych robotów podczas tej misji."
|
||
|
||
#. type: Plain text
|
||
#: ../E/public.txt:10
|
||
#, no-wrap
|
||
msgid "For example in the first bot we would have:"
|
||
msgstr "Na przykład pierwszy robot może zawierać:"
|
||
|
||
#. type: Source code
|
||
#: ../E/public.txt:12
|
||
#, no-wrap
|
||
msgid ""
|
||
"public void object::Segment(float dist, float angle)\n"
|
||
"{\n"
|
||
"\tmove(dist);\n"
|
||
"\tturn(angle);\n"
|
||
"}"
|
||
msgstr ""
|
||
"public void object::Segment(float odl, float kąt)\n"
|
||
"{\n"
|
||
"\tmove(odl);\n"
|
||
"\tturn(kąt);\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/public.txt:18
|
||
#, no-wrap
|
||
msgid "And in another bot we would have:"
|
||
msgstr "A inny:"
|
||
|
||
#. type: Source code
|
||
#: ../E/public.txt:20
|
||
#, no-wrap
|
||
msgid ""
|
||
"extern void object::Square( )\n"
|
||
"{\n"
|
||
"\tfor ( int i=0 ; i<4 ; i++ )\n"
|
||
"\t{\n"
|
||
"\t\tSegment(10, 90);\n"
|
||
"\t\tfire(1);\n"
|
||
"\t}\n"
|
||
"}"
|
||
msgstr ""
|
||
"extern void object::Kwadrat( )\n"
|
||
"{\n"
|
||
"\tfor ( int i=0 ; i<4 ; i++ )\n"
|
||
"\t{\n"
|
||
"\t\tSegment(10, 90);\n"
|
||
"\t\tfire(1);\n"
|
||
"\t}\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/public.txt:29
|
||
#, no-wrap
|
||
msgid "If you have declared a function <code>public</code>, you cannot define a function with the same name and arguments in another bot of the same mission."
|
||
msgstr "Jeśli funkcję zadeklarowano jako <code>public</code>, nie można zadeklarować funkcji o tej samej nazwie i parametrach w innym robocie podczas tej samej misji."
|
||
|
||
#. type: Plain text
|
||
#: ../E/public.txt:31
|
||
#, no-wrap
|
||
msgid "If a bot containing a <code>public</code> function is destroyed, the other bots that make use of this function will be stopped with an error."
|
||
msgstr "Jeśli robot zawierający funkcję zadeklarowaną jako <code>public</code> zostanie zniszczony, inne roboty używające tej funkcji zatrzymają się sygnalizując wystąpienie błędu."
|
||
|
||
#. type: \b; header
|
||
#: ../E/public.txt:33
|
||
#, no-wrap
|
||
msgid "Instruction <code>public</code> for classes"
|
||
msgstr "Instrukcja <code>public</code> dla klas"
|
||
|
||
#. type: Source code
|
||
#: ../E/public.txt:36
|
||
#, no-wrap
|
||
msgid ""
|
||
"public class MyClass\n"
|
||
"{\n"
|
||
"\tint b; // public by default\n"
|
||
"\tpublic int a; // also public \n"
|
||
"\tprivate point position; // privat\n"
|
||
"}\n"
|
||
"void Test()\n"
|
||
"{\n"
|
||
"\tMyClass item;\n"
|
||
"\titem.a = item.b = 12; // ok\n"
|
||
"\tmessage( item.position ); // this is an error\n"
|
||
"}"
|
||
msgstr ""
|
||
"public class MojaKlasa\n"
|
||
"{\n"
|
||
"\tint b; // publiczna domyślnie\n"
|
||
"\tpublic int a; // również publiczna \n"
|
||
"\tprivate point position; // prywatna\n"
|
||
"}\n"
|
||
"void Test()\n"
|
||
"{\n"
|
||
"\tMojaKlasa item;\n"
|
||
"\titem.a = item.b = 12; // ok\n"
|
||
"\tmessage( item.position ); // powoduje błąd\n"
|
||
"}"
|
||
|
||
#. type: \b; header
|
||
#: ../E/radar.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>radar</code>"
|
||
msgstr "Instrukcja <code>radar</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/radar.txt:5
|
||
#, no-wrap
|
||
msgid "Write in brackets the <a cbot|category>name of the object</a> that you look for. Put the result in a variable of the <a cbot|type>type</a> <code>object</code>. Here is an example that looks for the closest ant:"
|
||
msgstr "W nawiasach należy napisać <a cbot|category>nazwę poszukiwanego obiektu</a>. Wynik należy umieścić w zmiennej <a cbot|type>typu</a> <code>object</code>. Oto przykład znajdujący najbliższą mrówkę:"
|
||
|
||
#. type: Source code
|
||
#: ../E/radar.txt:7
|
||
#, no-wrap
|
||
msgid ""
|
||
"// At the beginning of the program:\n"
|
||
"object item; // variable declaration\n"
|
||
"\n"
|
||
"// Look for the closest ant\n"
|
||
"item = radar(AlienAnt);"
|
||
msgstr ""
|
||
"// Na początku programu:\n"
|
||
"object item; // deklaracja zmiennej\n"
|
||
"\n"
|
||
"// Znajdź najbliższą mrówkę\n"
|
||
"item = radar(AlienAnt);"
|
||
|
||
#. type: Plain text
|
||
#: ../E/radar.txt:17
|
||
#, no-wrap
|
||
msgid "Detects an object according to several parameters. "
|
||
msgstr "Wykrywa obiekty w zależnie od różnych parametrów. "
|
||
|
||
#. type: Image filename
|
||
#: ../E/radar.txt:19
|
||
#, no-wrap
|
||
msgid "radar1"
|
||
msgstr "radar1"
|
||
|
||
#. type: Plain text
|
||
#: ../E/radar.txt:20
|
||
#, no-wrap
|
||
msgid "Seen from above, the purple zone corresponds to the zone where objects will be detected. "
|
||
msgstr "Patrząc z góry, czerwona strefa odpowiada strefie, w której będą wykrywane obiekty. "
|
||
|
||
#. type: \t; header
|
||
#: ../E/produce.txt:15 ../E/search.txt:7
|
||
#, no-wrap
|
||
msgid "category: <code><a cbot|int>int</a></code>"
|
||
msgstr "kategoria: <code><a cbot|int>int</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/radar.txt:34
|
||
#, no-wrap
|
||
msgid ""
|
||
"Direction that the radar is facing, in degrees. \n"
|
||
"<code> 0</code> -> radar is facing straight ahead\n"
|
||
"<code>-90</code> -> radar is facing a quarter turn right\n"
|
||
"<code> 90</code> -> radar is facing a quarter turn left"
|
||
msgstr ""
|
||
"Kierunek, w którym \"patrzy\" radar, w stopniach: \n"
|
||
"<code> 0</code> -> na wprost \n"
|
||
"<code>-90</code> -> ćwierć obrotu w prawo\n"
|
||
"<code> 90</code> -> ćwierć obrotu w lewo"
|
||
|
||
#. type: Plain text
|
||
#: ../E/radar.txt:40
|
||
#, no-wrap
|
||
msgid "Opening angle of the radar, in degrees. "
|
||
msgstr "Kąt widzenia radaru, w stopniach. "
|
||
|
||
#. type: Plain text
|
||
#: ../E/radar.txt:43
|
||
#, no-wrap
|
||
msgid "Minimum detection distance, in meters. Objects that are closer than the minimum distance will not be detected. "
|
||
msgstr "Minimalna odległość wykrywania, w metrach. Obiekty znajdujące się bliżej nie będą wykryte. "
|
||
|
||
#. type: Plain text
|
||
#: ../E/radar.txt:46
|
||
#, no-wrap
|
||
msgid "Maximum detection distance, in meters. Objects that are farther away than the maximum distance will not be detected. "
|
||
msgstr "Maksymalna odległość wykrywania, w metrach. Obiekty znajdujące się dalej nie będą wykryte. "
|
||
|
||
#. type: Plain text
|
||
#: ../E/radar.txt:49
|
||
#, no-wrap
|
||
msgid "Determines which way the objects are detected. With value <code>1</code>, returns the closest object found in the specified zone. With value <code>-1</code>, the farthest object in the zone will be returned. "
|
||
msgstr "Określa sposób wykrywania obiektu. Przy wartości <code>1</code>, znajduje najbliższy obiekt w podanej strefie. Przy wartości<code>-1</code>, znajduje najdalszy obiekt w strefie. "
|
||
|
||
#. type: \t; header
|
||
#: ../E/radar.txt:65 ../E/retobj.txt:10 ../E/search.txt:22
|
||
#, no-wrap
|
||
msgid "Return value: <code><a cbot|object>object</a></code>"
|
||
msgstr "Typ wyniku: <code><a cbot|object>object</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/radar.txt:66
|
||
#, no-wrap
|
||
msgid "Returns the first object found that corresponds to the specified category in the specified zone. If no object was found, returns the value <code><a cbot|null>null</a></code>."
|
||
msgstr "Zwraca pierwszy znaleziony obiekt odpowiadający podanej kategorii w podanej strefie. Jeśli nie znaleziono obiektu, zwracana jest wartość <code><a cbot|null>null</a></code>."
|
||
|
||
#. type: \t; header
|
||
#: ../E/expr.txt:131 ../E/radar.txt:68
|
||
#, no-wrap
|
||
msgid "Remark"
|
||
msgstr "Uwaga"
|
||
|
||
#. type: Plain text
|
||
#: ../E/radar.txt:69
|
||
#, no-wrap
|
||
msgid "You do not have to give all the parameters. Here are two examples of instructions that are equivalent: "
|
||
msgstr "Nie jest konieczne podawanie wszystkich parametrów. Oto dwa przykłady równoważnych instrukcji: "
|
||
|
||
#. type: Source code
|
||
#: ../E/radar.txt:71
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tradar(Titanium, 0, 360, 0, 1000);\n"
|
||
"\tradar(Titanium); // equivalent"
|
||
msgstr ""
|
||
"\tradar(Titanium, 0, 360, 0, 1000);\n"
|
||
"\tradar(Titanium); // równoważne"
|
||
|
||
#. type: Source code
|
||
#: ../E/radar.txt:74
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tradar(Titanium, 0, 90, 0, 1000);\n"
|
||
"\tradar(Titanium, 0, 90); // equivalent"
|
||
msgstr ""
|
||
"\tradar(Titanium, 0, 90, 0, 1000);\n"
|
||
"\tradar(Titanium, 0, 90); // równoważne"
|
||
|
||
#. type: Plain text
|
||
#: ../E/radar.txt:77
|
||
#, no-wrap
|
||
msgid ""
|
||
"When one or more parameters are not specified, the default values indicated above are used instead; only the first parameter is compulsory.\n"
|
||
"Generally, only the first parameter is specified: f. ex. <code>radar (AlienAnt)</code> detects the closest ant, wherever it may be. "
|
||
msgstr ""
|
||
"Jeśli pominięto jeden lub więcej parametrów, przyjmowane są wymienione powyżej wartości domyślne; tylko pierwszy parametr jest obowiązkowy.\n"
|
||
"Zwykle określony jest tylko pierwszy parametr, np. <code>radar (AlienAnt)</code> wykrywa najbliższą mrówkę, niezależnie od jej położenia. "
|
||
|
||
#. type: \b; header
|
||
#: ../E/readln.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>readln</code>"
|
||
msgstr "Instrukcja <code>readln</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/readln.txt:2
|
||
#, no-wrap
|
||
msgid "Read one line from an open file in the files/ folder. This is a method of the <code><a cbot|file>file</a></code> class. This is the reason why we always write <code>handle.readln()</code>:"
|
||
msgstr "Wczytuje jedną linię z otwartego pliku w folderze files/. Jest to metoda klasy <code><a cbot|file>file</a></code>, dlatego też zawsze należy używać konstrukcji <code>handle.readln()</code>:"
|
||
|
||
#. type: Source code
|
||
#: ../E/readln.txt:4
|
||
#, no-wrap
|
||
msgid "\ts = handle.readln();"
|
||
msgstr "\ts = handle.readln();"
|
||
|
||
#. type: Plain text
|
||
#: ../E/readln.txt:6
|
||
#, no-wrap
|
||
msgid "The file must have been opened for reading (<code>\"r\"</code>) with the <code><a cbot|open>open</a></code> instruction. <code>readln</code> returns the string containing the whole line but without the end of line characters 0x0D (CR) and 0x0A (LF)."
|
||
msgstr "Plik musi być otwarty do odczytu (<code>\"r\"</code>) przy użyciu instrukcji <code><a cbot|open>open</a></code>. Metoda <code>readln</code> zwraca cały wiersz ale bez znaków końca linii 0x0D (CR) i 0x0A (LF)"
|
||
|
||
#. type: Source code
|
||
#: ../E/readln.txt:9
|
||
#, no-wrap
|
||
msgid "<c/>string = handle.readln ( );<n/>"
|
||
msgstr "<c/>string = handle.readln ( );<n/>"
|
||
|
||
#. type: Source code
|
||
#: ../E/readln.txt:13
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tstring s;\n"
|
||
"\ts = handle.readln();\n"
|
||
"\tif ( s == \"abc\" )\n"
|
||
"\t..."
|
||
msgstr ""
|
||
"\tstring s;\n"
|
||
"\ts = handle.readln();\n"
|
||
"\tif ( s == \"abc\" )\n"
|
||
"\t..."
|
||
|
||
#. type: Plain text
|
||
#: ../E/readln.txt:19
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|file>file</a></code>, <code><a cbot|open>open</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|writeln>writeln</a></code> and <code><a cbot|eof>eof</a></code>.\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<code><a cbot|file>file</a></code>, <code><a cbot|open>open</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|writeln>writeln</a></code> i <code><a cbot|eof>eof</a></code>.\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/receive.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>receive</code>"
|
||
msgstr "Instrukcja <code>receive</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/receive.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>receive ( name, power );<n/>"
|
||
msgstr "<c/>receive ( nazwa, moc );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/receive.txt:5
|
||
#, no-wrap
|
||
msgid "Retrieves an information from the closest <a object|exchange>information exchange post</a>."
|
||
msgstr "Pobiera informację z najbliższej <a object|exchange>stacji przekaźnikowej informacji</a>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/receive.txt:8
|
||
#, no-wrap
|
||
msgid "Name of the information required from the exchange post. This name is a string: it must be written in quotation marks \"\"."
|
||
msgstr "Nazwa informacji żądanej od stacji przekaźnikowej. Jest ona łańcuchem i powinna być zapisana w cudzysłowach \"\"."
|
||
|
||
#. type: Plain text
|
||
#: ../E/receive.txt:11
|
||
#, no-wrap
|
||
msgid "Power of the receiver, which corresponds to maximal distance between the receiver and the exchange post. If the distance is longer, no information is received. Default value is 10 metres."
|
||
msgstr "Moc odbiornika, która odpowiada maksymalnej odległości pomiędzy odbiorcą i stacją przekaźnikową. Jeśli odległość jest większa, nie zostanie pobrana żadna informacja. Domyślną wartością jest 10 metrów."
|
||
|
||
#. type: Plain text
|
||
#: ../E/receive.txt:14
|
||
#, no-wrap
|
||
msgid "Value of the retrieved information. If no exchange post is close enough, or if the name of the requested information does not exist in the exchange post, the value <code>nan</code> is returned."
|
||
msgstr "Wartość pobranej informacji. Jeśli wystarczająco blisko nie ma żadnej stacji przekaźnikowej, lub jeśli informacja o podanej nazwie nie istnieje, zwracana jest wartość <code>nan</code>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/receive.txt:17
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|send>send</a></code>, <code><a cbot|testinfo>testinfo</a></code> and <code><a cbot|delinfo>deleteinfo</a></code>.\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<code><a cbot|send>send</a></code>, <code><a cbot|testinfo>testinfo</a></code> i <code><a cbot|delinfo>deleteinfo</a></code>.\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/recycle.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>recycle</code>"
|
||
msgstr "Instrukcja <code>recycle</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/recycle.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>recycle ( );<n/>"
|
||
msgstr "<c/>recycle ( );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/recycle.txt:5
|
||
#, no-wrap
|
||
msgid "Recycles the derelict bot in front of the <a object|botrecy>recycler</a> into a <a object|titan>titanium cube</a>."
|
||
msgstr "Odzyskuje surowce z pozostałości robota znajdującego się bezpośrednio przed robotem <a object|botrecy>recyklerem</a> i tworzy <a object|titan>kostkę tytanu</a>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/recycle.txt:8
|
||
#, no-wrap
|
||
msgid ""
|
||
"Zero if OK, or a value different from zero if an error occurred.\n"
|
||
"<code>== 0 </code>the derelict bot has been recycled\n"
|
||
"<code>!= 0 </code>error, no derelict bot could be recycled"
|
||
msgstr ""
|
||
"Zero jeśli wszystko w porządku, lub wartość inna od zera w przypadku wystąpienia błędu.\n"
|
||
"<code>== 0 </code>odzyskano surowce z pozostałości robota\n"
|
||
"<code>!= 0 </code>błąd, pozostałość robota nie mogła zostać przetworzona"
|
||
|
||
#. type: \b; header
|
||
#: ../E/retobj.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>retobject</code>"
|
||
msgstr "Instrukcja <code>retobject</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/retobj.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>retobject ( number );<n/>"
|
||
msgstr "<c/>retobject ( numer );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/retobj.txt:5
|
||
#, no-wrap
|
||
msgid "Returns the object corresponding to the given number."
|
||
msgstr "Zwraca obiekt odpowiadający podanemu numerowi."
|
||
|
||
#. type: \t; header
|
||
#: ../E/retobj.txt:7
|
||
#, no-wrap
|
||
msgid "number: <code><a cbot|int>int</a></code>"
|
||
msgstr "numer: <code><a cbot|int>int</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/retobj.txt:8
|
||
#, no-wrap
|
||
msgid "Number of the object, between 0 and n. \"n\" represents the total number of objects in the scene. "
|
||
msgstr "Numer obiektu, pomiędzy 0 i n, gdzie \"n\" to liczba wszystkich obiektów na planecie. "
|
||
|
||
#. type: Plain text
|
||
#: ../E/retobj.txt:11
|
||
#, no-wrap
|
||
msgid "Object corresponding to the number. The return value <code><a cbot|null>null</a></code> means that no object corresponds to this number, because the number was too high, and there are not so many objects in the scene. "
|
||
msgstr "Obiekt odpowiadający numerowi. Wartość <code><a cbot|null>null</a></code> oznacza, że nie ma obiektu odpowiadającego podanemu numerowi, gdyż nie ma aż tylu obiektów na tej planecie. "
|
||
|
||
#. type: \b; header
|
||
#: ../E/return.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>return</code>"
|
||
msgstr "Instrukcja <code>return</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/return.txt:2
|
||
#, no-wrap
|
||
msgid "Returns from a function. Syntax:"
|
||
msgstr "Powrót z funkcji. Składnia:"
|
||
|
||
#. type: Source code
|
||
#: ../E/return.txt:4
|
||
#, no-wrap
|
||
msgid ""
|
||
"void function ( )\n"
|
||
"{\n"
|
||
"\treturn;\n"
|
||
"}"
|
||
msgstr ""
|
||
"void funkcja ( )\n"
|
||
"{\n"
|
||
"\treturn;\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/return.txt:10
|
||
#, no-wrap
|
||
msgid "If the <a cbot|function>function</a> has a return type, the <code>return</code> instruction must be followed by the value to be returned:"
|
||
msgstr "Jeśli <a cbot|function>funkcja</a> ma określony typ wyniku, po instrukcji <code>return</code> musi wystąpić wartość, która ma być zwrócona przez funkcję:"
|
||
|
||
#. type: Source code
|
||
#: ../E/return.txt:12
|
||
#, no-wrap
|
||
msgid ""
|
||
"float Pi ( )\n"
|
||
"{\n"
|
||
"\treturn 3.1415;\n"
|
||
"}"
|
||
msgstr ""
|
||
"float Pi ( )\n"
|
||
"{\n"
|
||
"\treturn 3.1415;\n"
|
||
"}"
|
||
|
||
#. type: Source code
|
||
#: ../E/return.txt:17
|
||
#, no-wrap
|
||
msgid ""
|
||
"float Mean (float a, float b)\n"
|
||
"{\n"
|
||
"\treturn (a+b)/2;\n"
|
||
"}"
|
||
msgstr ""
|
||
"float Średnia (float a, float b)\n"
|
||
"{\n"
|
||
"\treturn (a+b)/2;\n"
|
||
"}"
|
||
|
||
#. type: Source code
|
||
#: ../E/return.txt:22
|
||
#, no-wrap
|
||
msgid ""
|
||
"string Sign (float a)\n"
|
||
"{\n"
|
||
"\tif ( a > 0 ) return \"positive\";\n"
|
||
"\tif ( a < 0 ) return \"negative\";\n"
|
||
"\treturn \"null\";\n"
|
||
"}"
|
||
msgstr ""
|
||
"string Znak (float a)\n"
|
||
"{\n"
|
||
"\tif ( a > 0 ) return \"dodatnia\";\n"
|
||
"\tif ( a < 0 ) return \"ujemna\";\n"
|
||
"\treturn \"zero\";\n"
|
||
"}"
|
||
|
||
#. type: \b; header
|
||
#: ../E/search.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>search</code>"
|
||
msgstr "Instrukcja <code>search</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/search.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>search ( category, position );<n/>"
|
||
msgstr "<c/>search ( kategoria, pozycja );<n/>"
|
||
|
||
#. type: \t; header
|
||
#: ../E/produce.txt:9 ../E/topo.txt:7
|
||
#, no-wrap
|
||
msgid "position: <code><a cbot|point>point</a></code>"
|
||
msgstr "pozycja: <code><a cbot|point>point</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/search.txt:20
|
||
#, no-wrap
|
||
msgid "<code>search</code> returns the object of the given category that is closest to the position indicated here. "
|
||
msgstr "Funkcja <code>search</code> zwraca obiekt o podanej kategorii znajdujący się najbliżej określonej tutaj pozycji. "
|
||
|
||
#. type: Plain text
|
||
#: ../E/search.txt:23
|
||
#, no-wrap
|
||
msgid "Characteristics of the object that has been found. The value <code><a cbot|null>null</a></code> means that no object of this category has been found. "
|
||
msgstr "Charakterystyka znalezionego obiektu. Wartość <code><a cbot|null>null</a></code> oznacza, że nie znaleziono obiektu o podanej kategorii. "
|
||
|
||
#. type: \b; header
|
||
#: ../E/send.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>send</code>"
|
||
msgstr "Instrukcja <code>send</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/send.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>send ( name, value, power );<n/>"
|
||
msgstr "<c/>send ( nazwa, wartość, moc );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/send.txt:5
|
||
#, no-wrap
|
||
msgid "Sends an information to the closest <a object|exchange>information exchange post</a>."
|
||
msgstr "Wysyła informację do najbliższej <a object|exchange>stacji przekaźnikowej</a>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/send.txt:8
|
||
#, no-wrap
|
||
msgid ""
|
||
"Name of the information to be sent to the exchange post. This name is a string: it must be written in quotation marks \"\".\n"
|
||
"If there is any information having this name, a new entry is created, as far as the total number of entries does not exceed 10. If there is already an information having this name, value is simply replaced by the new."
|
||
msgstr ""
|
||
"Nazwa informacji wysyłanej do stacji przekaźnikowej. Jest to łańcuch, który powinien być zapisany w cudzysłowach \"\".\n"
|
||
"Jeśli nie ma informacji o podanej nazwie, tworzony jest nowy wpis, o ile ich liczba nie przekroczy 10. Jeśli istnieje już informacja o podanej nazwie, zastępowana jest ona nową wartością."
|
||
|
||
#. type: \t; header
|
||
#: ../E/send.txt:11
|
||
#, no-wrap
|
||
msgid "value: <code>float</code>"
|
||
msgstr "wartość: <code>float</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/send.txt:12
|
||
#, no-wrap
|
||
msgid "Value of the information to be sent."
|
||
msgstr "Wartość informacji do wysłania."
|
||
|
||
#. type: Plain text
|
||
#: ../E/send.txt:15
|
||
#, no-wrap
|
||
msgid "Power of the transmitter, which corresponds to the maximal distance to where information can be the sent. Default value is 10 metres."
|
||
msgstr "Moc transmitera, odpowiadająca maksymalnej odległości gdzie ma być przesłana informacja. Domyślna wartość to 10 metrów."
|
||
|
||
#. type: Plain text
|
||
#: ../E/send.txt:18
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|receive>receive</a></code>, <code><a cbot|testinfo>testinfo</a></code> and <code><a cbot|delinfo>deleteinfo</a></code>.\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<code><a cbot|receive>receive</a></code>, <code><a cbot|testinfo>testinfo</a></code> i <code><a cbot|delinfo>deleteinfo</a></code>.\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/shield.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>shield</code>"
|
||
msgstr "Instrukcja <code>shield</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/shield.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>shield ( oper, radius );<n/>"
|
||
msgstr "<c/>shield ( oper, promień );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/shield.txt:5
|
||
#, no-wrap
|
||
msgid "Activates or deactivates the shield of the <a object|botshld>shielder</a>. You can of course move the shielder when the shield is active. It protects all objects that are inside the shielded sphere from enemy fire. The radius of the sphere can range between 10 and 25 meters."
|
||
msgstr "Aktywuje lub dezaktywuje osłonę robota <a object|botshld>osłaniacza</a>. Oczywiście można poruszać robotem przy aktywnej osłonie. Zabezpiecza ona wszystkie obiekty znajdujące się wewnątrz strefy przed atakami wroga. Promień sfery może się zawierać pomiędzy 10 a 25 metrami."
|
||
|
||
#. type: \t; header
|
||
#: ../E/shield.txt:7
|
||
#, no-wrap
|
||
msgid "oper: <code><a cbot|float>float</a></code>"
|
||
msgstr "oper: <code><a cbot|float>float</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/shield.txt:8
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code>1</code> activates the shield.\n"
|
||
"<code>0</code> deactivates the shield\n"
|
||
"A normal <a object|power>power cell</a> fully charged can maintain the shield active during 20 seconds. When the cell is empty, the shield deactivates."
|
||
msgstr ""
|
||
"<code>1</code> aktywuje osłonę.\n"
|
||
"<code>0</code> dezaktywuje osłonę\n"
|
||
"Zwykłe, w pełni naładowane <a object|power>ogniwo elektryczne</a> wystarcza na 20 sekund aktywności osłony. Gdy ogniwo się wyczerpie, osłona jest wyłączana."
|
||
|
||
#. type: \t; header
|
||
#: ../E/shield.txt:12
|
||
#, no-wrap
|
||
msgid "radius: <code><a cbot|float>float</a></code>"
|
||
msgstr "promień: <code><a cbot|float>float</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/shield.txt:13
|
||
#, no-wrap
|
||
msgid "Radius of the shield, ranging between 10 and 25 meters."
|
||
msgstr "Promień sfery ochronnej, pomiędzy 10 a 25 metrów."
|
||
|
||
#. type: \b; header
|
||
#: ../E/sizeof.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>sizeof</code>"
|
||
msgstr "Instrukcja <code>sizeof</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/sizeof.txt:2
|
||
#, no-wrap
|
||
msgid ""
|
||
"The sizeof function lets you know the number of elements contained in an <a cbot|array>array</a>.\n"
|
||
"That is the index of the last element plus one (\"empty\" elements are counted)."
|
||
msgstr ""
|
||
"Funkcja sizeof pozwala poznać ilość elementów zawartych w <a cbot|array>tablicy</a>.\n"
|
||
"Jest to indeks ostatniego elementu plus jeden (liczone są również \"puste\" elementy)."
|
||
|
||
#. type: Source code
|
||
#: ../E/sizeof.txt:5
|
||
#, no-wrap
|
||
msgid ""
|
||
"{\n"
|
||
"\tint a[12];\n"
|
||
"\ta[5] = 345;\n"
|
||
"\tmessage( sizeof(a) ); // will display 6\n"
|
||
"}"
|
||
msgstr ""
|
||
"{\n"
|
||
"\tint a[12];\n"
|
||
"\ta[5] = 345;\n"
|
||
"\tmessage( sizeof(a) ); // wyświetli liczbę 6\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/sizeof.txt:11
|
||
#, no-wrap
|
||
msgid "In this example we have 6 elements in the array after <code>a[5]=345</code>. The non initialized elements <code>[0]</code>, <code>[1]</code>, <code>[2]</code>, <code>[3]</code> and <code>[4]</code> will be counted."
|
||
msgstr "W tym przykładzie po operacji <code>a[5]=345</code> tablica ma 6 elementów. Liczone są również następujące niezainicjalizowane elementy: <code>[0]</code>, <code>[1]</code>, <code>[2]</code>, <code>[3]</code> i <code>[4]</code>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/sizeof.txt:13
|
||
#, no-wrap
|
||
msgid "With multidimensionnal arrays you can get the size of a sub array:"
|
||
msgstr "W przypadku tablicy wielowymiarowej można otrzymać rozmiar podtablicy:"
|
||
|
||
#. type: Source code
|
||
#: ../E/sizeof.txt:15
|
||
#, no-wrap
|
||
msgid ""
|
||
"float xy[][]; // 2 dimensionnal array\n"
|
||
"xy[5][10] = 67;\n"
|
||
"message( sizeof(xy) ); // will display 6\n"
|
||
"message( sizeof(xy[5]) ); // will display 11\n"
|
||
msgstr ""
|
||
"float xy[][]; // tablica dwuwymiarowa\n"
|
||
"xy[5][10] = 67;\n"
|
||
"message( sizeof(xy) ); // wyświetli liczbę 6\n"
|
||
"message( sizeof(xy[5]) ); // wyświetli liczbę 11\n"
|
||
|
||
#. type: \b; header
|
||
#: ../E/sniff.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>sniff</code>"
|
||
msgstr "Instrukcja <code>sniff</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/sniff.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>sniff ( );<n/>"
|
||
msgstr "<c/>sniff ( );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/sniff.txt:5
|
||
#, no-wrap
|
||
msgid "Sounds the underground in front of the <a object|botsr>sniffer</a>. According to what raw materials were detected, the following objects will be created: "
|
||
msgstr "Analizuje grunt przed robotem <a object|botsr>szperaczem</a>. W zależności od wykrytego surowca, pojawia się następujący znacznik: "
|
||
|
||
#. type: Plain text
|
||
#: ../E/sniff.txt:7
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code>TitaniumSpot</code> -> <a object|stonspot>Red cross</a>\n"
|
||
"<code>UraniumSpot </code> -> <a object|uranspot>Yellow circle</a>\n"
|
||
"<code>PowerSpot </code> -> <a object|enerspot>Green cross</a>"
|
||
msgstr ""
|
||
"<code>Złoże tytanu</code> -> <a object|stonspot>Czerwony plus</a>\n"
|
||
"<code>Złoże uranu </code> -> <a object|uranspot>Żółte kółko</a>\n"
|
||
"<code>Źródło energii </code> -> <a object|enerspot>Zielony plus</a>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/sniff.txt:12
|
||
#, no-wrap
|
||
msgid ""
|
||
"Zero if everything is OK, or a value different from zero if an error occurred. \n"
|
||
"<code>== 0 </code>sounding performed\n"
|
||
"<code>!= 0 </code>sounding impossible"
|
||
msgstr ""
|
||
"Zero jeśli wszystko jest w porządku, lub wartość inna od zera w przypadku wystąpienia błędu. \n"
|
||
"<code>== 0 </code>analiza wykonana\n"
|
||
"<code>!= 0 </code>analiza niemożliwa"
|
||
|
||
#. type: \b; header
|
||
#: ../E/space.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>space</code>"
|
||
msgstr "Instrukcja <code>space</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/space.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>space ( center, rmin, rmax, dist );<n/>"
|
||
msgstr "<c/>space ( środek, rmin, rmaks, odl );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/space.txt:5
|
||
#, no-wrap
|
||
msgid "Determines the position of the nearest free space around a given position."
|
||
msgstr "Określa pozycję najbliższego wolnego miejsca w pobliżu podanej pozycji."
|
||
|
||
#. type: \t; header
|
||
#: ../E/space.txt:7
|
||
#, no-wrap
|
||
msgid "center: <code><a cbot|point>point</a></code> (default: bot position)"
|
||
msgstr "środek: <code><a cbot|point>point</a></code> (domyślnie: pozycja robota)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/flatspace.txt:8 ../E/space.txt:8
|
||
#, no-wrap
|
||
msgid "Desired position of the free space."
|
||
msgstr "Preferowana pozycja wolnego miejsca."
|
||
|
||
#. type: \t; header
|
||
#: ../E/flatspace.txt:13 ../E/space.txt:10
|
||
#, no-wrap
|
||
msgid "rmin: <code><a cbot|float>float</a></code> (default value: <code>8</code>)"
|
||
msgstr "rmin: <code><a cbot|float>float</a></code> (domyślna wartość: <code>8</code>)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/flatspace.txt:14 ../E/space.txt:11
|
||
#, no-wrap
|
||
msgid "Minimum distance from the desired position."
|
||
msgstr "Minimalna odległość od żądanej pozycji."
|
||
|
||
#. type: \t; header
|
||
#: ../E/flatspace.txt:16 ../E/space.txt:13
|
||
#, no-wrap
|
||
msgid "rmax: <code><a cbot|float>float</a></code> (default value: <code>50</code>)"
|
||
msgstr "rmaks: <code><a cbot|float>float</a></code> (domyślna wartość: <code>50</code>)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/flatspace.txt:17 ../E/space.txt:14
|
||
#, no-wrap
|
||
msgid "Maximum distance from the desired position."
|
||
msgstr "Maksymalna odległość od żądanej pozycji."
|
||
|
||
#. type: \t; header
|
||
#: ../E/flatspace.txt:19 ../E/space.txt:16
|
||
#, no-wrap
|
||
msgid "dist: <code><a cbot|float>float</a></code> (default value: <code>4</code>)"
|
||
msgstr "odl: <code><a cbot|float>float</a></code> (domyślna wartość: <code>4</code>)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/flatspace.txt:20 ../E/space.txt:17
|
||
#, no-wrap
|
||
msgid "Required distance between two free spaces."
|
||
msgstr "Wymagana odległość między dwoma wolnymi miejscami."
|
||
|
||
#. type: \t; header
|
||
#: ../E/flatspace.txt:22 ../E/space.txt:19
|
||
#, no-wrap
|
||
msgid "Return: <code><a cbot|point>point</a></code>"
|
||
msgstr "Wynik: <code><a cbot|point>point</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/flatspace.txt:23 ../E/space.txt:20
|
||
#, no-wrap
|
||
msgid "Position of the free space."
|
||
msgstr "Pozycja wolnego miejsca."
|
||
|
||
#. type: \b; header
|
||
#: ../E/static.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>static</code> (for specialists)"
|
||
msgstr "Instrukcja <code>static</code> (dla specjalistów)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/static.txt:2
|
||
#, no-wrap
|
||
msgid "<a cbot|class>Class</a> members declared with <code>static</code> are shared between all instances of the class."
|
||
msgstr "Elementy <a cbot|class>klasy</a> zadeklarowane jako <code>static</code> są współdzielone przez wszystkie instancje klasy."
|
||
|
||
#. type: Source code
|
||
#: ../E/static.txt:4
|
||
#, no-wrap
|
||
msgid ""
|
||
"public class MyClass\n"
|
||
"{\n"
|
||
"\tstatic int nb = 1;\n"
|
||
"\tstatic string [ ] list = null;\n"
|
||
"}\n"
|
||
"void Test ()\n"
|
||
"{\n"
|
||
"\tMyClasse item1();\n"
|
||
"\tMyClasse item2();\n"
|
||
"\titem1.nb = 3;\n"
|
||
"\titem1.list[item1.nb] = \"Hello\";\n"
|
||
"\tmessage( item2.list[item2.nb] ); // display \"Hello\"\n"
|
||
"}"
|
||
msgstr ""
|
||
"public class MojaKlasa\n"
|
||
"{\n"
|
||
"\tstatic int nb = 1;\n"
|
||
"\tstatic string [ ] list = null;\n"
|
||
"}\n"
|
||
"void Test ()\n"
|
||
"{\n"
|
||
"\tMojaKlasa item1();\n"
|
||
"\tMojaKlasa item2();\n"
|
||
"\titem1.nb = 3;\n"
|
||
"\titem1.list[item1.nb] = \"Cześć\";\n"
|
||
"\tmessage( item2.list[item2.nb] ); // wyświetla komunikat \"Cześć\"\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/static.txt:18
|
||
#, no-wrap
|
||
msgid "<code>Static</code> members can be declared <code><a cbot|private>private</a></code> so they will be only acessible from within class members (including constructors and destructors)."
|
||
msgstr "Elementy <code>static</code> mogą być zadeklarowane jako <code><a cbot|private>private</a></code>, co spowoduje, że będą dostępne tylko dla elementów klasy (włączając konstruktory i destruktory)."
|
||
|
||
#. type: Plain text
|
||
#: ../E/static.txt:21
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|class>class</a></code>, <code><a cbot|synchro>synchronized</a></code>\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<code><a cbot|class>class</a></code>, <code><a cbot|synchro>synchronized</a></code>\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/strfind.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>strfind</code>"
|
||
msgstr "Instrukcja <code>strfind</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/strfind.txt:2
|
||
#, no-wrap
|
||
msgid "Find a substring in a string and returns the position of the first substring found or <a cbot|nan>nan</a> if the substring has not been found."
|
||
msgstr "Znajduje podciąg w łańcuchu i zwraca pozycję pierwszego znalezionego podciągu lub wartość <a cbot|nan>nan</a> jeśli podciągu nie znaleziono."
|
||
|
||
#. type: Source code
|
||
#: ../E/strfind.txt:5
|
||
#, no-wrap
|
||
msgid "<c/>strfind ( string, sub );<n/>"
|
||
msgstr "<c/>strfind ( łańcuch, sub );<n/>"
|
||
|
||
#. type: \t; header
|
||
#: ../E/strfind.txt:7
|
||
#, no-wrap
|
||
msgid "string: <code><a cbot|string>string</a></code>"
|
||
msgstr "łańcuch: <code><a cbot|string>string</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/strfind.txt:8
|
||
#, no-wrap
|
||
msgid "String we are searching in."
|
||
msgstr "Przeszukiwany łańcuch."
|
||
|
||
#. type: \t; header
|
||
#: ../E/strfind.txt:10
|
||
#, no-wrap
|
||
msgid "sub: <code><a cbot|string>string</a></code>"
|
||
msgstr "sub: <code><a cbot|string>string</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/strfind.txt:11
|
||
#, no-wrap
|
||
msgid "Substring we are searching for."
|
||
msgstr "Podciąg, który ma zostać znaleziony."
|
||
|
||
#. type: Plain text
|
||
#: ../E/array.txt:35 ../E/strfind.txt:13 ../E/strleft.txt:10 ../E/strlen.txt:7 ../E/strlower.txt:7 ../E/strmid.txt:13 ../E/strright.txt:10 ../E/strupper.txt:7 ../E/strval.txt:4 ../E/strval.txt:11 ../E/writeln.txt:11
|
||
#, no-wrap
|
||
msgid "Examples:"
|
||
msgstr "Przykłady:"
|
||
|
||
#. type: Source code
|
||
#: ../E/strfind.txt:14
|
||
#, no-wrap
|
||
msgid ""
|
||
"<c/>\tint pos = strfind(\"abcdef\", \"ab\"); // pos will be 0\n"
|
||
"\tint pos = strfind(\"abcdef\", \"de\"); // pos will be 3\n"
|
||
"\tint pos = strfind(\"abcdef\", \"xy\"); // pos will be <a cbot|nan>nan</a>"
|
||
msgstr ""
|
||
"<c/>\tint pos = strfind(\"abcdef\", \"ab\"); // pos równe 0\n"
|
||
"\tint pos = strfind(\"abcdef\", \"de\"); // pos równe 3\n"
|
||
"\tint pos = strfind(\"abcdef\", \"xy\"); // pos równe <a cbot|nan>nan</a>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/strfind.txt:19
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/string.txt:1
|
||
#, no-wrap
|
||
msgid "Type <code>string</code>"
|
||
msgstr "Typ <code>string</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/string.txt:2
|
||
#, no-wrap
|
||
msgid "Use a variable of this type for storing characters or strings."
|
||
msgstr "Zmiennej tego typu można używać do przechowywania znaków lub ciągów znaków."
|
||
|
||
#. type: Plain text
|
||
#: ../E/string.txt:4
|
||
#, no-wrap
|
||
msgid "For example: "
|
||
msgstr "Na przykład: "
|
||
|
||
#. type: Source code
|
||
#: ../E/string.txt:5
|
||
#, no-wrap
|
||
msgid ""
|
||
"<c/>\t\"Hello!\"\n"
|
||
"\t\"This is a string\"\n"
|
||
"\t\"x\"\n"
|
||
"\t\"\" // empty string"
|
||
msgstr ""
|
||
"<c/>\t\"Cześć!\"\n"
|
||
"\t\"To jest łańcuch\"\n"
|
||
"\t\"x\"\n"
|
||
"\t\"\" // pusty łańcuch"
|
||
|
||
#. type: Plain text
|
||
#: ../E/string.txt:10
|
||
#, no-wrap
|
||
msgid "You can append two strings with the <code>+</code> operator :"
|
||
msgstr "Dwa łańcuchy można złączać, używając operatora <code>+</code>:"
|
||
|
||
#. type: Source code
|
||
#: ../E/string.txt:11
|
||
#, no-wrap
|
||
msgid "<c/>\t\"Good morning,\" + \" \" + \"Sir\""
|
||
msgstr "<c/>\t\"Dzień dobry\" + \" \" + \"Panu\""
|
||
|
||
#. type: Plain text
|
||
#: ../E/string.txt:13
|
||
#, no-wrap
|
||
msgid "Returns the string:"
|
||
msgstr "Daje w wyniku łańcuch:"
|
||
|
||
#. type: Source code
|
||
#: ../E/string.txt:14
|
||
#, no-wrap
|
||
msgid "<c/>\t\"Good morning, Sir\""
|
||
msgstr "<c/>\t\"Dzień dobry Panu\""
|
||
|
||
#. type: Plain text
|
||
#: ../E/string.txt:16
|
||
#, no-wrap
|
||
msgid "If you want to put a quotation mark (\") or a backslash (\\) in a string you must write:"
|
||
msgstr "Aby użyć cudzysłowu (\") lub odwróconej kreski ułamkowej (\\) w łańcuchu, należy napisać:"
|
||
|
||
#. type: Source code
|
||
#: ../E/string.txt:17
|
||
#, no-wrap
|
||
msgid "<c/>\"This is \\\"very\\\" important\""
|
||
msgstr "<c/>\"To jest \\\"bardzo\\\" ważne\""
|
||
|
||
#. type: Plain text
|
||
#: ../E/string.txt:18
|
||
#, no-wrap
|
||
msgid "<n/>which will result in the string <c/> This is \"very\" important."
|
||
msgstr "<n/>czego wynikiem będzie <c/> To jest \"bardzo\" ważne."
|
||
|
||
#. type: Source code
|
||
#: ../E/string.txt:19
|
||
#, no-wrap
|
||
msgid "<c/>\"%user%\\\\ant.txt\""
|
||
msgstr "<c/>\"%user%\\\\ant.txt\""
|
||
|
||
#. type: Plain text
|
||
#: ../E/string.txt:20
|
||
#, no-wrap
|
||
msgid "<n/>will result in <c/>%user%\\ant.txt"
|
||
msgstr "<n/>czego wynikiem będzie <c/>%user%\\ant.txt"
|
||
|
||
#. type: Plain text
|
||
#: ../E/string.txt:22
|
||
#, no-wrap
|
||
msgid ""
|
||
"Following instructions can be used with strings:\n"
|
||
"<code><a cbot|strlen>strlen</a> </code>Get string length\n"
|
||
"<code><a cbot|strleft>strleft</a> </code>Extract left part\n"
|
||
"<code><a cbot|strright>strright</a> </code>Extract right part\n"
|
||
"<code><a cbot|strmid>strmid</a> </code>Extract center part\n"
|
||
"<code><a cbot|strfind>strfind</a> </code>Find a substring.\n"
|
||
"<code><a cbot|strval>strval</a> </code>Convert string to number\n"
|
||
"<code><a cbot|strupper>strupper</a> </code>Convert to upper case\n"
|
||
"<code><a cbot|strlower>strlower</a> </code>Convert to lower case"
|
||
msgstr ""
|
||
"Następujące instrukcje mogą być używane na łańcuchach:\n"
|
||
"<code><a cbot|strlen>strlen</a> </code>Podaje długość łańcucha\n"
|
||
"<code><a cbot|strleft>strleft</a> </code>Wyodrębnia lewą część\n"
|
||
"<code><a cbot|strright>strright</a> </code>Wyodrębnia prawą część\n"
|
||
"<code><a cbot|strmid>strmid</a> </code>Wyodrębnia środkową część\n"
|
||
"<code><a cbot|strfind>strfind</a> </code>Znajduje podłańcuch\n"
|
||
"<code><a cbot|strval>strval</a> </code>Zamienia łańcuch na liczbę\n"
|
||
"<code><a cbot|strupper>strupper</a> </code>Zamienia litery na wielkie\n"
|
||
"<code><a cbot|strlower>strlower</a> </code>Zamienia litery na małe"
|
||
|
||
#. type: \b; header
|
||
#: ../E/strleft.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>strleft</code>"
|
||
msgstr "Instrukcja <code>strleft</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/strleft.txt:2
|
||
#, no-wrap
|
||
msgid "Extracts the first (that is, leftmost) characters from a string."
|
||
msgstr "Wyodrębnia początkowe (najbardziej na lewo) znaki z łańcucha."
|
||
|
||
#. type: Source code
|
||
#: ../E/strleft.txt:5
|
||
#, no-wrap
|
||
msgid "<c/>strleft ( string, len );<n/>"
|
||
msgstr "<c/>strleft ( łańcuch, długość );<n/>"
|
||
|
||
#. type: \t; header
|
||
#: ../E/strleft.txt:7 ../E/strmid.txt:10 ../E/strright.txt:7
|
||
#, no-wrap
|
||
msgid "len: <code><a cbot|int>int</a></code>"
|
||
msgstr "długość: <code><a cbot|int>int</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/strleft.txt:8 ../E/strmid.txt:11 ../E/strright.txt:8
|
||
#, no-wrap
|
||
msgid "Number of characters to be extracted."
|
||
msgstr "Liczba znaków do wyodrębnienia."
|
||
|
||
#. type: Source code
|
||
#: ../E/strleft.txt:11
|
||
#, no-wrap
|
||
msgid ""
|
||
"<c/>\tstring s = strleft(\"abcdef\", 2); // s is \"ab\"\n"
|
||
"\tstring s = strleft(\"abc\", 10); // s is \"abc\""
|
||
msgstr ""
|
||
"<c/>\tstring s = strleft(\"abcdef\", 2); // s równe \"ab\"\n"
|
||
"\tstring s = strleft(\"abc\", 10); // s równe \"abc\""
|
||
|
||
#. type: Plain text
|
||
#: ../E/strleft.txt:15
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/strlen.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>strlen</code>"
|
||
msgstr "Instrukcja <code>strlen</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/strlen.txt:2
|
||
#, no-wrap
|
||
msgid "Get the length of a string."
|
||
msgstr "Podaje długość łańcucha."
|
||
|
||
#. type: Source code
|
||
#: ../E/strlen.txt:5
|
||
#, no-wrap
|
||
msgid "<c/>strlen ( string );<n/>"
|
||
msgstr "<c/>strlen ( łańcuch );<n/>"
|
||
|
||
#. type: Source code
|
||
#: ../E/strlen.txt:8
|
||
#, no-wrap
|
||
msgid ""
|
||
"<c/>\tint len = strlen(\"abc\"); // len is 3\n"
|
||
"\tint len = strlen(\"\"); // len is 0\n"
|
||
"\tif ( strlen(s) == 0 ) // is string empty ?"
|
||
msgstr ""
|
||
"<c/>\tint len = strlen(\"abc\"); // len równe 3\n"
|
||
"\tint len = strlen(\"\"); // len równe 0\n"
|
||
"\tif ( strlen(s) == 0 ) // czy łańcuch pusty?"
|
||
|
||
#. type: Plain text
|
||
#: ../E/strlen.txt:13
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/strlower.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>strlower</code>"
|
||
msgstr "Instrukcja <code>strlower</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/strlower.txt:2
|
||
#, no-wrap
|
||
msgid "Convert all characters in a string to lowercase."
|
||
msgstr "Zamienia wszystkie znaki łańcucha na małe litery."
|
||
|
||
#. type: Source code
|
||
#: ../E/strlower.txt:5
|
||
#, no-wrap
|
||
msgid "<c/>strlower ( string );<n/>"
|
||
msgstr "<c/>strlower ( łańcuch );<n/>"
|
||
|
||
#. type: Source code
|
||
#: ../E/strlower.txt:8
|
||
#, no-wrap
|
||
msgid "<c/>\tstring s = strlower(\"Abc\"); // s is \"abc\""
|
||
msgstr "<c/>\tstring s = strlower(\"Abc\"); // s jest równe \"abc\""
|
||
|
||
#. type: Plain text
|
||
#: ../E/strlower.txt:11
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/strmid.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>strmid</code>"
|
||
msgstr "Instrukcja <code>strmid</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/strmid.txt:2
|
||
#, no-wrap
|
||
msgid "Extracts a substring of a given length starting at a given position from a string."
|
||
msgstr "Wyodrębnia z łańcucha podłańcuch o określonej długości i określonej pozycji początkowej."
|
||
|
||
#. type: Source code
|
||
#: ../E/strmid.txt:5
|
||
#, no-wrap
|
||
msgid "<c/>strmid ( string, pos, len );<n/>"
|
||
msgstr "<c/>strmid ( łańcuch, pozycja, długość );<n/>"
|
||
|
||
#. type: \t; header
|
||
#: ../E/strmid.txt:7
|
||
#, no-wrap
|
||
msgid "pos: <code><a cbot|int>int</a></code>"
|
||
msgstr "pozycja: <code><a cbot|int>int</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/strmid.txt:8
|
||
#, no-wrap
|
||
msgid "The index of the first character that is to be included in the extracted substring."
|
||
msgstr "Indeks pierwszego znaku, który powinien wystąpić w wyodrębnionym podłańcuchu."
|
||
|
||
#. type: Source code
|
||
#: ../E/strmid.txt:14
|
||
#, no-wrap
|
||
msgid ""
|
||
"<c/>\tstring s = strmid(\"abcdef\", 1, 2); // s is \"bc\"\n"
|
||
"\tstring s = strmid(\"abcdef\", 4, 5); // s is \"ef\"\n"
|
||
"\tstring s = strmid(\"abcdef\", 9, 2); // s is \"\""
|
||
msgstr ""
|
||
"<c/>\tstring s = strmid(\"abcdef\", 1, 2); // s równe \"bc\"\n"
|
||
"\tstring s = strmid(\"abcdef\", 4, 5); // s równe \"ef\"\n"
|
||
"\tstring s = strmid(\"abcdef\", 9, 2); // s równe \"\""
|
||
|
||
#. type: Plain text
|
||
#: ../E/strmid.txt:19
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/strright.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>strright</code>"
|
||
msgstr "Instrukcja <code>strright</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/strright.txt:2
|
||
#, no-wrap
|
||
msgid "Extracts the last (that is, rightmost) characters from a string."
|
||
msgstr "Wyodrębnia końcowe (najbardziej na prawo) znaki z łańcucha."
|
||
|
||
#. type: Source code
|
||
#: ../E/strright.txt:5
|
||
#, no-wrap
|
||
msgid "<c/>strright ( string, len );<n/>"
|
||
msgstr "<c/>strright ( łańcuch, długość );<n/>"
|
||
|
||
#. type: Source code
|
||
#: ../E/strright.txt:11
|
||
#, no-wrap
|
||
msgid ""
|
||
"<c/>\tstring s = strright(\"abcdef\", 2); // s is \"ef\"\n"
|
||
"\tstring s = strright(\"abc\", 10); // s is \"abc\""
|
||
msgstr ""
|
||
"<c/>\tstring s = strright(\"abcdef\", 2); // s równe \"ef\"\n"
|
||
"\tstring s = strright(\"abc\", 10); // s równe \"abc\""
|
||
|
||
#. type: Plain text
|
||
#: ../E/strright.txt:15
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/strupper.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>strupper</code>"
|
||
msgstr "Instrukcja <code>strupper</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/strupper.txt:2
|
||
#, no-wrap
|
||
msgid "Convert all characters in a string to uppercase."
|
||
msgstr "Zamienia wszystkie znaki łańcucha na wielkie litery."
|
||
|
||
#. type: Source code
|
||
#: ../E/strupper.txt:5
|
||
#, no-wrap
|
||
msgid "<c/>strupper ( string );<n/>"
|
||
msgstr "<c/>strupper ( łańcuch );<n/>"
|
||
|
||
#. type: Source code
|
||
#: ../E/strupper.txt:8
|
||
#, no-wrap
|
||
msgid "<c/>\tstring s = strupper(\"Abc\"); // s is \"ABC\""
|
||
msgstr "<c/>\tstring s = strupper(\"Abc\"); // s jest równe \"ABC\""
|
||
|
||
#. type: Plain text
|
||
#: ../E/strupper.txt:11
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/strval.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>strval</code>"
|
||
msgstr "Instrukcja <code>strval</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/strval.txt:2
|
||
#, no-wrap
|
||
msgid "Convert a string to a number. Don't confuse the string <code>\"45\"</code> that contains actually the two characters <code>4</code> and <code>5</code> and the number <code>45</code>."
|
||
msgstr "Zamienia łańcuch na liczbę. Nie należy mylić łańcucha <code>\"45\"</code>, zawierającego dwa znaki <code>4</code> i <code>5</code> oraz liczby <code>45</code>."
|
||
|
||
#. type: Source code
|
||
#: ../E/strval.txt:5
|
||
#, no-wrap
|
||
msgid ""
|
||
"<c/>\tstring s = \"45\"+\"12\"; // s contains \"4512\"\n"
|
||
"\tfloat n = 45 + 12; // n contains 67"
|
||
msgstr ""
|
||
"<c/>\tstring s = \"45\"+\"12\"; // s zawiera \"4512\"\n"
|
||
"\tfloat n = 45 + 12; // n zawiera 67"
|
||
|
||
#. type: Source code
|
||
#: ../E/strval.txt:9
|
||
#, no-wrap
|
||
msgid "<c/>strval ( string );<n/>"
|
||
msgstr "<c/>strval ( łańcuch );<n/>"
|
||
|
||
#. type: Source code
|
||
#: ../E/strval.txt:12
|
||
#, no-wrap
|
||
msgid ""
|
||
"<c/>\tfloat n = strval(\"1.23\"); // n is 1.23\n"
|
||
"\tfloat n = strval(\"12abc45\"); // n is 12\n"
|
||
"\tfloat n = strval(\"abc\"); // n is 0\n"
|
||
"\tfloat n = strval(\"100\")+2; // n is 102"
|
||
msgstr ""
|
||
"<c/>\tfloat n = strval(\"1.23\"); // n równe 1,23\n"
|
||
"\tfloat n = strval(\"12abc45\"); // n równe 12\n"
|
||
"\tfloat n = strval(\"abc\"); // n równe 0\n"
|
||
"\tfloat n = strval(\"100\")+2; // n równe 102"
|
||
|
||
#. type: Plain text
|
||
#: ../E/strval.txt:18
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/synchro.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>synchronized</code> (for specialists)"
|
||
msgstr "Instrukcja <code>synchronized</code> (dla specjalistów)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/synchro.txt:2
|
||
#, no-wrap
|
||
msgid "A <a cbot|class>class</a> method can be declared <code>synchronized</code>. This is to make sure that the method is never being executed by more than one bot at the same time."
|
||
msgstr "Metoda <a cbot|class>klasy</a> może być zadeklarowana jako <code>synchronized</code>. Dzięki temu można zapewnić, że metoda będzie uruchamiana nie więcej niż przez jednego robota w tym samym czasie."
|
||
|
||
#. type: Plain text
|
||
#: ../E/synchro.txt:4
|
||
#, no-wrap
|
||
msgid "The following example illustrates the problem:"
|
||
msgstr "Następujący przykład pomoże zilustrować problem:"
|
||
|
||
#. type: Source code
|
||
#: ../E/synchro.txt:6
|
||
#, no-wrap
|
||
msgid ""
|
||
"class blocking\n"
|
||
"{\n"
|
||
"\tstatic int nb = 33;\n"
|
||
"\tsynchronized int inc( )\n"
|
||
"\t{\n"
|
||
"\t\tint val = nb;\n"
|
||
"\t\twait ( 2 ); // wait 2 sec.\n"
|
||
"\t\tnb = nb + 1;\n"
|
||
"\t\treturn val;\n"
|
||
"\t}\n"
|
||
"}"
|
||
msgstr ""
|
||
"class blokowanie\n"
|
||
"{\n"
|
||
"\tstatic int nb = 33;\n"
|
||
"\tsynchronized int inc( )\n"
|
||
"\t{\n"
|
||
"\t\tint val = nb;\n"
|
||
"\t\twait ( 2 ); // czekaj 2 sekundy\n"
|
||
"\t\tnb = nb + 1;\n"
|
||
"\t\treturn val;\n"
|
||
"\t}\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/synchro.txt:18
|
||
#, no-wrap
|
||
msgid ""
|
||
"What happens if two bots execute the <code>inc</code> method at the same time?\n"
|
||
"Both of them will execute <code>val=nb</code> and wait 2 seconds so both of them will have <code>val=33</code>. With <code>synchronized</code> the first bot starts execution with <code>val=33</code> and then waits 2 seconds and returns. Only once the first bot has returned from the <code>inc</code> method, the second bot will be allowed to enter the <code>inc</code> method and therefore the second bot will always have <code>val=34</code>."
|
||
msgstr ""
|
||
"Co się dzieje, gdy dwa roboty wykonają metodę <code>inc</code> w tym samym czasie?\n"
|
||
"Oba wykonają polecenie <code>val=nb</code> i poczekają 2 sekundy, a więc oba otrzymają <code>val=33</code>. Gdy użyjemy instrukcji <code>synchronized</code> pierwszy robot rozpocznie wykonywanie z <code>val=33</code> poczeka 2 sekundy i wyjdzie z metody. Dopiero po zakończeniu wykonywania metody <code>inc</code> przez pierwszego robota, drugi robot będzie miał możliwość wykonania metody <code>inc</code>, wobec czego otrzyma on zawsze <code>val=34</code>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/synchro.txt:21
|
||
#, no-wrap
|
||
msgid "You can have more than one synchronized method in your <a cbot|class>class</a> in order to prevent simultaneous execution across more than one method. In other words: as long as a bot's program is inside a synchronized method, no other bot can enter any synchronized method of the same class."
|
||
msgstr "Można mieć więcej niż jedną zsynchronizowaną metodę w <a cbot|class>klasie</a> w celu zapobieżenia równoczesnemu wykonywaniu więcej niż jednej metody. Innymi słowy: tak długo, jak długo robot jest wewnątrz zsynchronizowanej metody, żaden inny robot nie może wykonywać żadnej zsynchronizowanej metody tej samej klasy."
|
||
|
||
#. type: Plain text
|
||
#: ../E/synchro.txt:24
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|class>class</a></code>, <code><a cbot|static>static</a></code>\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<code><a cbot|class>klasa</a></code>, <code><a cbot|static>static</a></code>\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/term.txt:1
|
||
#, no-wrap
|
||
msgid "Semicolon"
|
||
msgstr "Średnik"
|
||
|
||
#. type: Plain text
|
||
#: ../E/term.txt:2
|
||
#, no-wrap
|
||
msgid "Always use a semicolon <c/>;<n/> after a simple expression. For example: "
|
||
msgstr "Po prostych wyrażeniach zawsze należy używać średnika <c/>;<n/>. Na przykład: "
|
||
|
||
#. type: Source code
|
||
#: ../E/term.txt:4
|
||
#, no-wrap
|
||
msgid "\tint counter = 0;"
|
||
msgstr "\tint licznik = 0;"
|
||
|
||
#. type: Plain text
|
||
#: ../E/term.txt:6
|
||
#, no-wrap
|
||
msgid "However, after a <a cbot|bloc>bloc</a>, never put a semicolon:"
|
||
msgstr "Nie należy jednak używać średnika na zakończenie <a cbot|bloc>bloku</a>:"
|
||
|
||
#. type: Source code
|
||
#: ../E/term.txt:8
|
||
#, no-wrap
|
||
msgid ""
|
||
"\t{\n"
|
||
"\t\tfloat dist;\n"
|
||
"\t\tdist = distance(p1, p2);\n"
|
||
"\t} <n/>// no semicolon here!<c/>"
|
||
msgstr ""
|
||
"\t{\n"
|
||
"\t\tfloat odl;\n"
|
||
"\t\todl = distance(p1, p2);\n"
|
||
"\t} <n/>// tutaj bez średnika!<c/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/term.txt:13
|
||
#, no-wrap
|
||
msgid "Do not use a semicolon either immediately after the instructions <code><a cbot|while>while</a></code>, <code><a cbot|if>if</a></code> or <code><a cbot|for>for</a></code>:"
|
||
msgstr "Nie należy również stosować średnika bezpośrednio po instrukcjach <code><a cbot|while>while</a></code>, <code><a cbot|if>if</a></code> lub <code><a cbot|for>for</a></code>:"
|
||
|
||
#. type: Source code
|
||
#: ../E/term.txt:15
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tif ( a < b ) <n/>// no semicolon here!<c/>\n"
|
||
"\t{\n"
|
||
"\t\tb = 100-a;\n"
|
||
"\t}"
|
||
msgstr ""
|
||
"\tif ( a < b ) <n/>// tutaj bez średnika!<c/>\n"
|
||
"\t{\n"
|
||
"\t\tb = 100-a;\n"
|
||
"\t}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/term.txt:20
|
||
#, no-wrap
|
||
msgid "An instruction is always ended by a semicolon, and not by the end of the line. So you can very well put several instructions on the same line: "
|
||
msgstr "Ponieważ instrukcje zawsze kończą się średnikiem a nie znakiem końca linii, można umieścić kilka instrukcji w jednej linii: "
|
||
|
||
#. type: Source code
|
||
#: ../E/term.txt:22
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tint d=20;\n"
|
||
"\tmove(d);\n"
|
||
"\tturn(90);"
|
||
msgstr ""
|
||
"\tint d=20;\n"
|
||
"\tmove(d);\n"
|
||
"\tturn(90);"
|
||
|
||
#. type: Plain text
|
||
#: ../E/term.txt:26
|
||
#, no-wrap
|
||
msgid "Is equivalent to:"
|
||
msgstr "Jest równoważne:"
|
||
|
||
#. type: Source code
|
||
#: ../E/term.txt:28
|
||
#, no-wrap
|
||
msgid "\tint d=20; move(d); turn(90);"
|
||
msgstr "\tint d=20; move(d); turn(90);"
|
||
|
||
#. type: \b; header
|
||
#: ../E/testinfo.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>testinfo</code>"
|
||
msgstr "Instrukcja <code>testinfo</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/testinfo.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>testinfo ( name, power );<n/>"
|
||
msgstr "<c/>testinfo ( nazwa, moc );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/testinfo.txt:5
|
||
#, no-wrap
|
||
msgid "Tests if an information exists in the closest <a object|exchange>information exchange post</a>."
|
||
msgstr "Sprawdza czy istnieje żądana informacja w najbliższej <a object|exchange>stacji przekaźnikowej</a>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/testinfo.txt:8
|
||
#, no-wrap
|
||
msgid "Name of the information to be tested in the exchange post. This name is a string: it must be written in quotation marks \"\"."
|
||
msgstr "Nazwa informacji do sprawdzenia. Jest ona łańcuchem i powinna być zapisana w cudzysłowach \"\"."
|
||
|
||
#. type: Plain text
|
||
#: ../E/testinfo.txt:11
|
||
#, no-wrap
|
||
msgid "Power of the transmitter, which corresponds to the maximal distance between the transmitter and the exchange post. If the distance is longer, the function returns <code>false</code>. Default value is 10 metres."
|
||
msgstr "Moc transmitera, odpowiadająca maksymalnej odległości pomiędzy transmiterem i stacją przekaźnikową. Jeśli odległość jest większa, funkcja zwraca wartość <code>false</code>. Domyślna wartość to 10 metrów."
|
||
|
||
#. type: \t; header
|
||
#: ../E/testinfo.txt:13
|
||
#, no-wrap
|
||
msgid "Return: <code><a cbot|bool>bool</a></code>"
|
||
msgstr "Typ wyniku: <code><a cbot|bool>bool</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/testinfo.txt:14
|
||
#, no-wrap
|
||
msgid "Return <code>true</code> if the information exists. Return and <code>false</code> if the information does not exist or if the receiver is too far away from the exchange post."
|
||
msgstr "Daje w wyniku <code>true</code> jesli informacja istnieje, oraz <code>false</code> jeśli informacja nie istnieje lub odbiorca jest za daleko od stacji przekaźnikowej."
|
||
|
||
#. type: Plain text
|
||
#: ../E/testinfo.txt:17
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|receive>receive</a></code>, <code><a cbot|send>send</a></code> and <code><a cbot|delinfo>deleteinfo</a></code>.\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<code><a cbot|receive>receive</a></code>, <code><a cbot|send>send</a></code> i <code><a cbot|delinfo>deleteinfo</a></code>.\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/this.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>this</code>"
|
||
msgstr "Instrukcja <code>this</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/this.txt:2
|
||
#, no-wrap
|
||
msgid "Occasionally, a <a cbot|class>class</a> method needs to know the reference to the instance it is acting upon. For example the instance might want to pass it's own reference to another function. An implicit reference name <code>this</code> is available to methods and <code>this</code> is a reference to the current instance."
|
||
msgstr "Czasami metoda <a cbot|class>klasy</a> potrzebuje wskaźnika do instancji, w której działa. Na przykład instancja może chcieć przekazać wskaźnik do samej siebie jako parametr dla innej funkcji. Odwołanie wprost poprzez <code>this</code> jest dostępne również dla metod; <code>this</code> jest odwołaniem do bieżącej instancji."
|
||
|
||
#. type: Source code
|
||
#: ../E/this.txt:4
|
||
#, no-wrap
|
||
msgid ""
|
||
"public class MyClass\n"
|
||
"{\n"
|
||
"\tint m_int;\n"
|
||
"\tstring m_str;\n"
|
||
"\tvoid MyFunction()\n"
|
||
"\t{\n"
|
||
"\t\tOtherFunction(this);\n"
|
||
"\t\tm_int = 2;\n"
|
||
"\t}\n"
|
||
"}\n"
|
||
"\n"
|
||
"void OtherFunction(MyClass obj)\n"
|
||
"{\n"
|
||
"\tmessage(obj.m_str);\n"
|
||
"}\n"
|
||
"\n"
|
||
"extern void object::Test()\n"
|
||
"{\n"
|
||
"\tMyClass item();\n"
|
||
"\titem.m_str = \"Hello\";\n"
|
||
"\titem.MyFunction(); // display \"Hello\"\n"
|
||
"}"
|
||
msgstr ""
|
||
"public class MojaKlasa\n"
|
||
"{\n"
|
||
"\tint m_int;\n"
|
||
"\tstring m_str;\n"
|
||
"\tvoid MojaFunkcja()\n"
|
||
"\t{\n"
|
||
"\t\tInnaFunkcja(this);\n"
|
||
"\t\tm_int = 2;\n"
|
||
"\t}\n"
|
||
"}\n"
|
||
"\n"
|
||
"void InnaFunkcja(MojaKlasa obj)\n"
|
||
"{\n"
|
||
"\tmessage(obj.m_str);\n"
|
||
"}\n"
|
||
"\n"
|
||
"extern void object::Test()\n"
|
||
"{\n"
|
||
"\tMojaKlasa item();\n"
|
||
"\titem.m_str = \"Cześć\";\n"
|
||
"\titem.MojaFunkcja(); // wyświetla \"Cześć\"\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/this.txt:27
|
||
#, no-wrap
|
||
msgid "You can also put <code>this</code> before a field name in a method but this is not necessary. In the example above in the method <code>MyFunction()</code> following two lines have strictly the same meaning:"
|
||
msgstr "Można również umieścić <code>this</code> przed nazwą pola w metodzie, ale nie jest to konieczne. W powyższym przykładzie metody <code>MojaFunkcja()</code> następujące dwie linie mają identyczne znaczenie:"
|
||
|
||
#. type: Source code
|
||
#: ../E/this.txt:29
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tm_int = 2;\n"
|
||
"\tthis.m_int = 2; // identical"
|
||
msgstr ""
|
||
"\tm_int = 2;\n"
|
||
"\tthis.m_int = 2; // identyczne"
|
||
|
||
#. type: Plain text
|
||
#: ../E/this.txt:32
|
||
#, no-wrap
|
||
msgid "In a method of the <code><a cbot|object>object</a></code> class, you can also use <code>this.</code> before a fieldname."
|
||
msgstr "Również w metodzie klasy <code><a cbot|object>object</a></code> można użyć <code>this.</code> przed nazwą pola."
|
||
|
||
#. type: Source code
|
||
#: ../E/this.txt:34
|
||
#, no-wrap
|
||
msgid ""
|
||
"extern void object::Display()\n"
|
||
"{\n"
|
||
"\tmessage(orientation);\n"
|
||
"\tmessage(this.orientation); // same thing but\n"
|
||
"\t // more explicit\n"
|
||
"}"
|
||
msgstr ""
|
||
"extern void object::Display()\n"
|
||
"{\n"
|
||
"\tmessage(orientation);\n"
|
||
"\tmessage(this.orientation); // to samo ale\n"
|
||
"\t // bardziej jednoznacznie\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/this.txt:41
|
||
#, no-wrap
|
||
msgid "However if a field name is hidden by a parameter declaration or a variable declaration you must use <code>this</code>. In the following example the name <code>value</code> of the parameter is the same as the name of the field <code>value</code> of the <a cbot|class>class</a> <code>MyClass</code>, we must therefore write <code>this.value</code> in order to distinguish the field from the parameter."
|
||
msgstr "Jednakże jeśli nazwa pola jest ukryta poprzez deklarację parametru lub zmiennej, należy użyć <code>this</code>. W następującym przykładzie nazwa parametru <code>value</code> jest taka sama jak nazwa pola <code>value</code> w <a cbot|class>klasie</a> <code>MojaKlasa</code>, wobec tego w celu rozróżnienia pola od parametru, konieczne jest napisanie <code>this.value</code>."
|
||
|
||
#. type: Source code
|
||
#: ../E/this.txt:43
|
||
#, no-wrap
|
||
msgid ""
|
||
"public class MyClass\n"
|
||
"{\n"
|
||
"\tint value;\n"
|
||
"\tvoid Put( int value )\n"
|
||
"\t{\n"
|
||
"\t\tthis.value = value;\n"
|
||
"\t}\n"
|
||
"}"
|
||
msgstr ""
|
||
"public class MojaKlasa\n"
|
||
"{\n"
|
||
"\tint value;\n"
|
||
"\tvoid Put( int value )\n"
|
||
"\t{\n"
|
||
"\t\tthis.value = value;\n"
|
||
"\t}\n"
|
||
"}"
|
||
|
||
#. type: \b; header
|
||
#: ../E/thump.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>thump</code>"
|
||
msgstr "Instrukcja <code>thump</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/thump.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>thump ( );<n/>"
|
||
msgstr "<c/>thump ( );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/thump.txt:5
|
||
#, no-wrap
|
||
msgid "Activates the weapon system of the <a object|bottump>thumper</a>, that turns ants and spiders belly up and makes them completely harmless for a while."
|
||
msgstr "Uruchamia system broni robota <a object|bottump>uderzacza</a>, który przewraca mrówki i pająki do góry brzuchem, powodując ich chwilowe unieszkodliwienie."
|
||
|
||
#. type: Plain text
|
||
#: ../E/thump.txt:8
|
||
#, no-wrap
|
||
msgid ""
|
||
"Zero if everything is OK, a value different from zero if an error occurred. \n"
|
||
"<code>== 0 </code>Thumping performed\n"
|
||
"<code>!= 0 </code>Operation impossible"
|
||
msgstr ""
|
||
"Zero w przypadku powodzenia lub inna wartość, jeśli wystąpił błąd. \n"
|
||
"<code>== 0 </code>Uderzenie wykonane\n"
|
||
"<code>!= 0 </code>Operacja niemożliwa"
|
||
|
||
#. type: \b; header
|
||
#: ../E/topo.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>topo</code>"
|
||
msgstr "Instrukcja <code>topo</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/topo.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>topo ( position );<n/>"
|
||
msgstr "<c/>topo ( pozycja );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/topo.txt:5
|
||
#, no-wrap
|
||
msgid "Returns the altitude of the ground at a give position. The altitude zero corresponds to sea level. A negative value indicates that at this position ground is covered with water. "
|
||
msgstr "Podaje wysokość gruntu w podanej pozycji. Wysokość zerowa odpowiada poziomowi morza. Wartość ujemna oznacza, że sprawdzany punkt jest przykryty wodą. "
|
||
|
||
#. type: Plain text
|
||
#: ../E/topo.txt:8
|
||
#, no-wrap
|
||
msgid "Coordinates of the position whose altitude you want to know. "
|
||
msgstr "Współrzędne pozycji, której wysokość ma być sprawdzona. "
|
||
|
||
#. type: Plain text
|
||
#: ../E/topo.txt:11
|
||
#, no-wrap
|
||
msgid "Altitude of the ground at the given position."
|
||
msgstr "Wysokość gruntu w podanej pozycji."
|
||
|
||
#. type: \b; header
|
||
#: ../E/true.txt:1
|
||
#, no-wrap
|
||
msgid "Type <code>true</code>"
|
||
msgstr "Typ <code>true</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/true.txt:2
|
||
#, no-wrap
|
||
msgid "This value means that a condition is true; it is one of the two values that a <a cbot|bool>boolean</a> <a cbot|var>variable</a> can take."
|
||
msgstr "Wartość ta oznacza, że warunek jest prawdziwy; jest to jedna z dwóch wartości <a cbot|var>zmiennej</a> typu <a cbot|bool>boolean</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/turn.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>turn</code>"
|
||
msgstr "Instrukcja <code>turn</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/turn.txt:2
|
||
#, no-wrap
|
||
msgid "Use the instruction <c/>turn();<n/> to instruct the bot to perform a rotation on itself of a certain number of degrees."
|
||
msgstr "Instrukcja <c/>turn();<n/> służy do wykonania przez robota obrotu o określoną liczbę stopni."
|
||
|
||
#. type: Plain text
|
||
#: ../E/turn.txt:5
|
||
#, no-wrap
|
||
msgid "90 degreed means a quarter turn, 180 degrees means a half turn. A positive angle will perform a counterclockwise rotation, a negative angle means a clockwise rotation. Here are some examples with <c/>turn();<n/>:"
|
||
msgstr "90 stopni oznacza ćwierć obrotu, 180 stopni to pół obrotu. Kąt dodatni to obrót przeciwny do ruchu wskazówek zegara, kąt ujemny oznacza obrót zgodny z ruchem wskazówek zegara. Oto kilka przykładów użycia instrukcji <c/>turn();<n/>:"
|
||
|
||
#. type: Plain text
|
||
#: ../E/turn.txt:7
|
||
#, no-wrap
|
||
msgid ""
|
||
"<c/>turn(90);<n/> quarter turn to the left\n"
|
||
"<c/>turn(-90);<n/> quarter turn to the right (negative angle)\n"
|
||
"<c/>turn(180);<n/> half turn"
|
||
msgstr ""
|
||
"<c/>turn(90);<n/> ćwierć obrotu w lewo\n"
|
||
"<c/>turn(-90);<n/> ćwierć obrotu w prawo (ujemny kąt)\n"
|
||
"<c/>turn(180);<n/> połowa obrotu"
|
||
|
||
#. type: Plain text
|
||
#: ../E/turn.txt:11
|
||
#, no-wrap
|
||
msgid "In order to turn the bot towards an object found with the instruction <c/><a cbot|radar>radar</a>();<n/>, you must calculate the rotation angle with the instruction <code><a cbot|direct>direction</a>()</code>:"
|
||
msgstr "Aby obrócić robota w kierunku obiektu znalezionego przy użyciu instrukcji <c/><a cbot|radar>radar</a>();<n/>, należy obliczyć kąt obrotu przy pomocy instrukcji <code><a cbot|direct>direction</a>()</code>:"
|
||
|
||
#. type: Source code
|
||
#: ../E/turn.txt:13
|
||
#, no-wrap
|
||
msgid ""
|
||
"\titem = <a cbot|radar>radar</a>(AlienSpider);\n"
|
||
"\tturn(<a cbot|direct>direction</a>(item.position));"
|
||
msgstr ""
|
||
"\titem = <a cbot|radar>radar</a>(AlienSpider);\n"
|
||
"\tturn(<a cbot|direct>direction</a>(item.position));"
|
||
|
||
#. type: Plain text
|
||
#: ../E/turn.txt:16
|
||
#, no-wrap
|
||
msgid "After these lines, just fire the cannon, and there is one hostile element less."
|
||
msgstr "Po tych liniach wystarczy wystrzelić z działa i już mamy jednego wroga mniej."
|
||
|
||
#. type: Source code
|
||
#: ../E/turn.txt:20
|
||
#, no-wrap
|
||
msgid "<c/>turn ( angle );<n/>"
|
||
msgstr "<c/>turn ( kąt );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/turn.txt:22
|
||
#, no-wrap
|
||
msgid "Turns the bot with a given angle, right or left, without moving either forward or backward. "
|
||
msgstr "Obraca robota o podany kąt, w prawo lub w lewo, bez poruszania do przodu ani do tyłu. "
|
||
|
||
#. type: Plain text
|
||
#: ../E/turn.txt:25
|
||
#, no-wrap
|
||
msgid "Angle of the required rotation, in degrees. A positive value turns left, a negative value turns right. <code>turn(180)</code> turns round completely. "
|
||
msgstr "Kąt obrotu w stopniach. Wartość dodatnia to obrót w lewo, ujemna - w prawo. <code>turn(180)</code> obraca do tyłu. "
|
||
|
||
#. type: Plain text
|
||
#: ../E/turn.txt:28
|
||
#, no-wrap
|
||
msgid ""
|
||
"Zero if everything is OK, or a value different from zero if an error occurred. \n"
|
||
"<code>== 0 </code>rotation performed\n"
|
||
"<code>!= 0 </code>rotation impossible"
|
||
msgstr ""
|
||
"Zero w przypadku powodzenia lub inna wartość, jeśli wystąpił błąd. \n"
|
||
"<code>== 0 </code>obrót wykonany\n"
|
||
"<code>!= 0 </code>obrót niemożliwy"
|
||
|
||
#. type: \b; header
|
||
#: ../E/type.txt:1
|
||
#, no-wrap
|
||
msgid "Variable types"
|
||
msgstr "Typy zmiennych"
|
||
|
||
#. type: Plain text
|
||
#: ../E/type.txt:2
|
||
#, no-wrap
|
||
msgid "When you define a <a cbot|var>variable</a>, you must give two elements: "
|
||
msgstr "Definiując <a cbot|var>zmienną</a> należy podać dwa elementy: "
|
||
|
||
#. type: Bullet: '1)'
|
||
#: ../E/type.txt:4
|
||
#, no-wrap
|
||
msgid "a name"
|
||
msgstr "nazwę"
|
||
|
||
#. type: Bullet: '2)'
|
||
#: ../E/type.txt:5
|
||
#, no-wrap
|
||
msgid "a type"
|
||
msgstr "typ"
|
||
|
||
#. type: Plain text
|
||
#: ../E/type.txt:7
|
||
#, no-wrap
|
||
msgid "Once you defined a variable, you can use it to put information in it. However, the information that a variable can contain must always be of the correct type: a variable of type <a cbot|float>float</a> can not contain a string, etc."
|
||
msgstr "Po zdefiniowaniu zmiennej można w niej umieszczać informacje. Jednakże informacja, którą może przechowywać zmienna musi być odpowiedniego typu: zmienna typu <a cbot|float>float</a> nie może zawierać łańcucha itd."
|
||
|
||
#. type: Source code
|
||
#: ../E/type.txt:11
|
||
#, no-wrap
|
||
msgid "<code><a cbot|int>int</a></code>"
|
||
msgstr "<code><a cbot|int>int</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/type.txt:12
|
||
#, no-wrap
|
||
msgid "For a whole number (12, -500, etc.)."
|
||
msgstr "Dla liczb całkowitych (12, -500, itd.)"
|
||
|
||
#. type: Source code
|
||
#: ../E/type.txt:14
|
||
#, no-wrap
|
||
msgid "<code><a cbot|float>float</a></code>"
|
||
msgstr "<code><a cbot|float>float</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/type.txt:15
|
||
#, no-wrap
|
||
msgid "For a real number (12, 3.14, 0.2, -99.98, etc.)."
|
||
msgstr "Dla liczb rzeczywistych (12, 3.14, 0.2, -99.98, itd.)"
|
||
|
||
#. type: Source code
|
||
#: ../E/type.txt:17
|
||
#, no-wrap
|
||
msgid "<code><a cbot|bool>bool</a></code>"
|
||
msgstr "<code><a cbot|bool>bool</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/type.txt:18
|
||
#, no-wrap
|
||
msgid "For a boolean variable, that can only take the values <code>true</code> or <code>false</code>."
|
||
msgstr "Dla zmiennych logicznych, które mogą zawierać wartości <code>true</code> lub <code>false</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/type.txt:20
|
||
#, no-wrap
|
||
msgid "<code><a cbot|string>string</a></code>"
|
||
msgstr "<code><a cbot|string>string</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/type.txt:21
|
||
#, no-wrap
|
||
msgid "For texts (\"Hello!\", \"No object found\", etc.)"
|
||
msgstr "Dla tekstów (\"Cześć!\", \"Nie znaleziono obiektu\", itd.)"
|
||
|
||
#. type: Source code
|
||
#: ../E/type.txt:23
|
||
#, no-wrap
|
||
msgid "<code><a cbot|point>point</a></code>"
|
||
msgstr "<code><a cbot|point>point</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/type.txt:24
|
||
#, no-wrap
|
||
msgid "For the coordinates of a point in space; a variable of this type consists of three parts named x, y and z."
|
||
msgstr "Dla współrzędnych punktu w przestrzeni; zmienna tego typu składa się z trzech części nazwanych x, y oraz z."
|
||
|
||
#. type: Source code
|
||
#: ../E/type.txt:26
|
||
#, no-wrap
|
||
msgid "<code><a cbot|object>object</a></code>"
|
||
msgstr "<code><a cbot|object>object</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/type.txt:27
|
||
#, no-wrap
|
||
msgid "A variable of this type contains the information about an object (bot, building, enemy, etc.)."
|
||
msgstr "Zmienna tego typu może zawierać informacje o obiekcie (robocie, budynku, wrogu, itd.)"
|
||
|
||
#. type: Source code
|
||
#: ../E/type.txt:29
|
||
#, no-wrap
|
||
msgid "<code><a cbot|void>void</a></code>"
|
||
msgstr "<code><a cbot|void>void</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/type.txt:30
|
||
#, no-wrap
|
||
msgid "This type is an \"empty type\", that you use when you do not want to specify a type."
|
||
msgstr "Jest to \"typ pusty\", używany wtedy, gdy nie chcemy określać typu."
|
||
|
||
#. type: \b; header
|
||
#: ../E/var.txt:1
|
||
#, no-wrap
|
||
msgid "Variables"
|
||
msgstr "Zmienne"
|
||
|
||
#. type: Plain text
|
||
#: ../E/var.txt:2
|
||
#, no-wrap
|
||
msgid "A variable is like a box, where you can put some information. The content of the variable can change during the execution of the program."
|
||
msgstr "Zmienna jest jak pudełko, do którego można wkładać różne informacje. Wartość zmiennej może się zmieniać podczas wykonywania programu."
|
||
|
||
#. type: Plain text
|
||
#: ../E/var.txt:4
|
||
#, no-wrap
|
||
msgid "For example, you can use a variable to count the number of titanium ore units that the grabber has collected and carried to the converter. First, you must find a name for it: the name should not be too long, but explain by itself what the variable is used for. Let's call it <code>countTit</code>. This variable must contain only whole numbers, so choose the type <code>int</code>. At the beginning of the program, you must declare the variable. Then you put the value <code>0</code> into the variable, and every time you grab a titanium ore, you increase the variable by <code>1</code>. At every moment, the variable contains the number of titanium ore units that the grabber collected."
|
||
msgstr "Na przykład można użyć zmiennej do liczenia jednostek rudy tytanu zebranych i przeniesionych przez transporter do huty. Najpierw należy ustalić odpowiednią nazwę dla zmiennej: nie powinna być ona zbyt długa, ale powinna wyjaśniać do czego używana jest zmienna. Nazwijmy ją <code>liczTyt</code>. Zmienna ta będzie zawierała tylko liczby całkowite, dlatego odpowiednim dla niej typem będzie <code>int</code>. Na początku programu zmienną trzeba zadeklarować. Następnie można w niej umieścić wartość <code>0</code>, zwiększając ją o <code>1</code> za każdym razem, gdy robot podniesie rudę tytanu. Zmienna ta będzie zawierać liczbę porcji rudy tytanu zebranych do tej pory przez robota."
|
||
|
||
#. type: Plain text
|
||
#: ../E/var.txt:6
|
||
#, no-wrap
|
||
msgid ""
|
||
"For the declaration of the variable, write the following line: \n"
|
||
"<c/><s/>\tint countTit;<n/>"
|
||
msgstr ""
|
||
"Aby zadeklarować zmienną, należy napisać: \n"
|
||
"<c/><s/>\tint liczTyt;<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/var.txt:9
|
||
#, no-wrap
|
||
msgid ""
|
||
"To put <code>0</code> into the variable, write:\n"
|
||
"<c/><s/>\tcountTit = 0;<n/>"
|
||
msgstr ""
|
||
"Aby przypisać jej wartość <code>0</code>, należy napisać:\n"
|
||
"<c/><s/>\tliczTyt = 0;<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/var.txt:12
|
||
#, no-wrap
|
||
msgid ""
|
||
"At every titanium ore grabbed, write:\n"
|
||
"<c/><s/>\tcountTit = countTit + 1<n/>"
|
||
msgstr ""
|
||
"Po zebraniu każdej porcji rudy tytanu należy napisać:\n"
|
||
"<c/><s/>\tliczTyt = liczTyt + 1<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/var.txt:15
|
||
#, no-wrap
|
||
msgid ""
|
||
"You have much freedom in the choice of the name for a variable, you can call them by any name, f. ex.: <code>dist</code>, <code>direct</code>, <code>p2</code>, <code>a</code>, <code>x</code>, <code>nothing_2_shoot_at</code>, etc.\n"
|
||
"A variable name must always begin with a letter. It can be followed by any combination of letters, digits or the underscore character <code>_</code>. You can of course not use the keywords of the CBOT language like <code><a cbot|for>for</a></code>, <code><a cbot|while>while</a></code>, <code><a cbot|break>break</a></code>, <code><a cbot|continue>continue</a></code>, <code>do</code>, etc.\n"
|
||
"You should be careful about the choice of the names that you give to variables; writing a program can become very difficult if you forget the names of variables or if you do not remember what they are used for. Elaborate your own system to find variable names, and do not use names like <code>Bmo45</code>, <code>a</code> or <code>tgBinX</code>."
|
||
msgstr ""
|
||
"W wyborze nazwy dla zmiennej jest dużo swobody, można ją nazwać dowolnie, np.: <code>odl</code>, <code>kierunek</code>, <code>p2</code>, <code>a</code>, <code>x</code>, <code>nic_do_zestrzelenia</code>, itd.\n"
|
||
"Nazwa zmiennej musi zaczynać się od litery, po której może następować dowolna kombinacja liter, cyfr i znaków podkreślenia <code>_</code>. Oczywiście nie można używać słów kluczowych języka CBOT takich jak <code><a cbot|for>for</a></code>, <code><a cbot|while>while</a></code>, <code><a cbot|break>break</a></code>, <code><a cbot|continue>continue</a></code>, <code>do</code>, itd.\n"
|
||
"Należy być ostrożnym w wyborze nazw przydzielanych zmiennym; pisanie programu może okazać się bardzo trudne jeśli zapomni się nazwy zmiennych lub nie pamięta do czego one służyły. Należy opracować własny system nazywania zmiennych i raczej nie używać nazw podobnych do <code>Bmo45</code>, <code>a</code> czy <code>tgBinX</code>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/var.txt:19
|
||
#, no-wrap
|
||
msgid "In the example above, the keyword <code>int</code> indicates that this variable can contain only whole numbers, which is adequate to counting objects. If you want to measure a distance, better use a variable that can contain also real numbers, with a fractional part (like 3.45 or 0.034): in this case, use the type <code>float</code>."
|
||
msgstr "W powyższym przykładzie, słowo <code>int</code> określa, że zmienna może zawierać tylko liczby całkowite, odpowiednie do liczenia obiektów. Do mierzenia odległości lepiej jest użyć zmiennej, która może również zawierać liczby rzeczywiste z częścią ułamkową (takie jak 3.45 lub 0.034): w tym przypadku odpowiedniejszy jest typ <code>float</code>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/var.txt:21
|
||
#, no-wrap
|
||
msgid "In fact, a variable is made up of three parts:"
|
||
msgstr "Zmienna składa się z trzech części:"
|
||
|
||
#. type: Bullet: '1)'
|
||
#: ../E/var.txt:22
|
||
#, no-wrap
|
||
msgid "the name,"
|
||
msgstr "nazwy,"
|
||
|
||
#. type: Bullet: '2)'
|
||
#: ../E/var.txt:23
|
||
#, no-wrap
|
||
msgid "the type of the information stored inside,"
|
||
msgstr "typu informacji przez nią przechowywanych,"
|
||
|
||
#. type: Bullet: '3)'
|
||
#: ../E/var.txt:24
|
||
#, no-wrap
|
||
msgid "the content, i.e. the information itself."
|
||
msgstr "zawartości, czyli samej informacji."
|
||
|
||
#. type: \t; header
|
||
#: ../E/var.txt:26
|
||
#, no-wrap
|
||
msgid "the name"
|
||
msgstr "nazwa"
|
||
|
||
#. type: Plain text
|
||
#: ../E/var.txt:27
|
||
#, no-wrap
|
||
msgid "You need the name to be able to distinguish the different variables from each other."
|
||
msgstr "Jest niezbędna do rozróżniania zmiennych pomiędzy sobą."
|
||
|
||
#. type: \t; header
|
||
#: ../E/var.txt:29
|
||
#, no-wrap
|
||
msgid "the type"
|
||
msgstr "typ"
|
||
|
||
#. type: Plain text
|
||
#: ../E/var.txt:30
|
||
#, no-wrap
|
||
msgid ""
|
||
"The <a cbot|type>type</a> determines what kind of information the variable can contain. According to the type, a variable can contain a whole number, a real number, a string, the coordinates of a point, information about an object, etc. \n"
|
||
"Here is a list of the most common variable types:"
|
||
msgstr ""
|
||
"<a cbot|type>Typ</a> warunkuje rodzaj informacji, jaką może zawierać zmienna. Zależnie od typu, zmienna może zawierać liczby całkowite, liczby rzeczywiste, łańcuchy, współrzędne punktu, informacje o obiekcie, itd. \n"
|
||
"Oto lista najczęściej występujących typów zmiennych:"
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/var.txt:32
|
||
#, no-wrap
|
||
msgid "<code><a cbot|int>int</a></code> for a whole number (12, -500, etc.)"
|
||
msgstr "<code><a cbot|int>int</a></code> dla liczb całkowitych (12, -500, itd.)"
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/var.txt:33
|
||
#, no-wrap
|
||
msgid "<code><a cbot|float>float</a></code> for a real number (3.14, 0.2, -99.98, etc.)"
|
||
msgstr "<code><a cbot|float>float</a></code> dla liczb rzeczywistych (3.14, 0.2, -99.98, itd.)"
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/var.txt:34
|
||
#, no-wrap
|
||
msgid "<code><a cbot|string>string</a></code> for a character string (\"Hello!\", \"No object found\", etc.)"
|
||
msgstr "<code><a cbot|string>string</a></code> dla łańcuchów znakowych (\"Cześć!\", \"Nie znaleziono obiektu\", itd.)"
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/var.txt:35
|
||
#, no-wrap
|
||
msgid "<code><a cbot|point>point</a></code> for a x,y,z-coordinate in space"
|
||
msgstr "<code><a cbot|point>point</a></code> dla współrzędnych x, y, z w przestrzeni"
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/var.txt:36
|
||
#, no-wrap
|
||
msgid "<code><a cbot|object>object</a></code> for information about an object (bot, building, etc.)"
|
||
msgstr "<code><a cbot|object>object</a></code> dla informacji o obiekcie (robocie, budynku, itd.)"
|
||
|
||
#. type: \t; header
|
||
#: ../E/var.txt:38
|
||
#, no-wrap
|
||
msgid "The content"
|
||
msgstr "zawartość"
|
||
|
||
#. type: Plain text
|
||
#: ../E/var.txt:39
|
||
#, no-wrap
|
||
msgid "The content of a variable is an information of the kind specified in the type. It can change during the execution of the program. "
|
||
msgstr "Zawartością zmiennej jest informacja, której rodzaj jest określony przez typ. Może się ona zmieniać w trakcie działania programu. "
|
||
|
||
#. type: Plain text
|
||
#: ../E/var.txt:41
|
||
#, no-wrap
|
||
msgid ""
|
||
"Once you declared a variable, it still does not contain any value. Before you can use it, you must put a value inside: \n"
|
||
"<c/><s/>\tint i, j;"
|
||
msgstr ""
|
||
"Po zadeklarowaniu zmiennej nie zawiera ona żadnej wartości. Zanim będzie można jej użyć, trzeba nadać jej wartość: \n"
|
||
"<c/><s/>\tint i, j;"
|
||
|
||
#. type: Source code
|
||
#: ../E/var.txt:43
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tj = 25; // j takes the value 25\n"
|
||
"\tj = i; // can not write this, because i has got no content yet."
|
||
msgstr ""
|
||
"\tj = 25; // j przyjmuje wartość 25\n"
|
||
"\tj = i; // tak nie można napisać, gdyż i nie ma jeszcze żadnej wartości."
|
||
|
||
#. type: Plain text
|
||
#: ../E/var.txt:46
|
||
#, no-wrap
|
||
msgid ""
|
||
"You can also declare a variable and put a value inside in the same line, writing: \n"
|
||
"<c/><s/>\tint countTit = 0;"
|
||
msgstr ""
|
||
"Możliwe jest zadeklarowanie zmiennej i przypisanie jej wartości w tym samym wierszu: \n"
|
||
"<c/><s/>\tint liczTyt = 0;"
|
||
|
||
#. type: Plain text
|
||
#: ../E/var.txt:49
|
||
#, no-wrap
|
||
msgid ""
|
||
"When you assign a value to a variable with the equals sign <code>=</code>, the value on the right side is copied into the value on the left side. Consider the following example: \n"
|
||
"<c/><s/>\tint i, j;"
|
||
msgstr ""
|
||
"Przy wykonywaniu przypisania wartości zmiennej przy użyciu znaku równości<code>=</code>, wartość z prawej strony jest kopiowana do wartości po lewej stronie. Rozważmy następujący przykład: \n"
|
||
"<c/><s/>\tint i, j;"
|
||
|
||
#. type: Source code
|
||
#: ../E/var.txt:51
|
||
#, no-wrap
|
||
msgid ""
|
||
"\ti = 5+2; // i takes the value 7\n"
|
||
"\tj = i+6; // j takes the value of i plus 6, this is 13\n"
|
||
"\ti = j; // i takes the value of j, this is 13"
|
||
msgstr ""
|
||
"\ti = 5+2; // i przyjmuje wartość 7\n"
|
||
"\tj = i+6; // j przyjmuje wartość i plus 6, czyli 13\n"
|
||
"\ti = j; // i przyjmuje wartość j, czyli 13"
|
||
|
||
#. type: Plain text
|
||
#: ../E/var.txt:55
|
||
#, no-wrap
|
||
msgid "At the end of this example, both variables <code>i</code> and <code>j</code> contain the value <code>13</code>."
|
||
msgstr "Na końcu tego przykładu obie zmienne <code>i</code> i <code>j</code> zawierają wartość <code>13</code>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/var.txt:57
|
||
#, no-wrap
|
||
msgid ""
|
||
"The following assignment is not correct, because on the left side of the equals sign <code>=</code>, there can be only a variable name:\n"
|
||
"<c/><s/>\ti+2 = j; // impossible"
|
||
msgstr ""
|
||
"Następujące przypisanie jest niepoprawne, gdyż po lewej stronie znaku równości <code>=</code> może występować tylko nazwa zmiennej:\n"
|
||
"<c/><s/>\ti+2 = j; // niemożliwe"
|
||
|
||
#. type: Plain text
|
||
#: ../E/var.txt:60
|
||
#, no-wrap
|
||
msgid ""
|
||
"If you want to exchange the values of two variables, you must use a third variable. Here is an example to exchange the content of two variables <code>a</code> and <code>b</code> :\n"
|
||
"<c/><s/>\tint temp;"
|
||
msgstr ""
|
||
"Do zamiany zawartości dwóch zmiennych konieczne jest użycie trzeciej zmiennej. Oto przykład zamieniający zawartość zmiennych <code>a</code> i <code>b</code>:\n"
|
||
"<c/><s/>\tint pom;"
|
||
|
||
#. type: Source code
|
||
#: ../E/var.txt:62
|
||
#, no-wrap
|
||
msgid ""
|
||
"\ttemp = a; // temp takes the value of a\n"
|
||
"\ta = b; // the content of b is copied into a\n"
|
||
"\tb = temp; // the content of temp is copied into b"
|
||
msgstr ""
|
||
"\tpom = a; // pom przyjmuje wartość a\n"
|
||
"\ta = b; // zawartość b jest kopiowana do a\n"
|
||
"\tb = pom; // zawartość pom jest kopiowana do b"
|
||
|
||
#. type: \b; header
|
||
#: ../E/void.txt:1
|
||
#, no-wrap
|
||
msgid "Type <code>void</code>"
|
||
msgstr "Typ <code>void</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/void.txt:2
|
||
#, no-wrap
|
||
msgid "Use this type when you want to declare a function that returns nothing."
|
||
msgstr "Tego typu należy użyć do deklaracji funkcji, która nie zwraca żadnego wyniku."
|
||
|
||
#. type: Plain text
|
||
#: ../E/void.txt:4
|
||
#, no-wrap
|
||
msgid ""
|
||
"Example:\n"
|
||
"<c/><s/>void MyFunction(int a)"
|
||
msgstr ""
|
||
"Przykład:\n"
|
||
"<c/><s/>void MojaFunkcja(int a)"
|
||
|
||
#. type: Source code
|
||
#: ../E/void.txt:6
|
||
#, no-wrap
|
||
msgid ""
|
||
"{\n"
|
||
"\t...\n"
|
||
"}"
|
||
msgstr ""
|
||
"{\n"
|
||
"\t...\n"
|
||
"}"
|
||
|
||
#. type: \b; header
|
||
#: ../E/wait.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>wait</code>"
|
||
msgstr "Instrukcja <code>wait</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/wait.txt:2
|
||
#, no-wrap
|
||
msgid "The instruction <c/>wait();<n/> instructs the bot to wait for some seconds, according to the value written in brackets."
|
||
msgstr "Instrukcja <c/>wait();<n/> każe robotowi czekać przez kilka sekund, zależnie od wartości podanej w nawiasach."
|
||
|
||
#. type: Plain text
|
||
#: ../E/wait.txt:5
|
||
#, no-wrap
|
||
msgid "In order to wait until the <a object|power>power cell</a> is recharged on a power station, wait 5 seconds with <c/>wait(5);<n/>."
|
||
msgstr "Na naładowanie <a object|power>ogniwa elektrycznego</a> w stacji energetycznej należy poczekać 5 sekund używając instrukcji <c/>wait(5);<n/>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/wait.txt:7
|
||
#, no-wrap
|
||
msgid "In order to wait until the <a object|convert>converter</a> finished transforming some <a object|titanore>titanium ore</a> in a <a object|titan>titanium cube</a>, wait 15 seconds with <c/>wait(15);<n/>."
|
||
msgstr "Na przetopienie <a object|titanore>rudy tytanu</a> w <a object|titan>kostkę tytanu</a> w <a object|convert>hucie</a> należy poczekać 15 sekund używając instrukcji <c/>wait(15);<n/>."
|
||
|
||
#. type: Source code
|
||
#: ../E/wait.txt:11
|
||
#, no-wrap
|
||
msgid "<c/>wait ( time );<n/>"
|
||
msgstr "<c/>wait ( czas );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/wait.txt:13
|
||
#, no-wrap
|
||
msgid "Waits for a moment."
|
||
msgstr "Czeka przez chwilę."
|
||
|
||
#. type: Plain text
|
||
#: ../E/wait.txt:16
|
||
#, no-wrap
|
||
msgid "Specifies the time that the bot must wait."
|
||
msgstr "Określa czas przez jaki robot powinien czekać."
|
||
|
||
#. type: \b; header
|
||
#: ../E/while.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>while</code>"
|
||
msgstr "Instrukcja <code>while</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/while.txt:2
|
||
#, no-wrap
|
||
msgid "The instruction <code>while () {}</code> is used to repeat a set of instructions several times."
|
||
msgstr "Instrukcja <code>while () {}</code> jest używana do wielokrotnego powtarzania zbioru instrukcji."
|
||
|
||
#. type: Plain text
|
||
#: ../E/while.txt:5
|
||
#, no-wrap
|
||
msgid "The most frequent use of <code>while</code> consists in repeating a set of instructions again and again. In order to achieve this, write <code>while (true) {}</code> and put the instructions to be repeated in braces <code>{}</code>. As an example, here is a program that repeats again and again the following actions:"
|
||
msgstr "Najczęstsze użycie instrukcji <code>while</code> polega na nieskończonym powtarzaniu zbioru instrukcji. Aby to osiągnąć, należy napisać <code>while (true) {}</code>, a instrukcje, które mają być powtarzane zapisać w nawiasach klamrowych <code>{}</code>. Oto przykładowy program powtarzający w nieskończoność następujące czynności:"
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/while.txt:6
|
||
#, no-wrap
|
||
msgid "look for a spider,"
|
||
msgstr "znajdź pająka,"
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/while.txt:7
|
||
#, no-wrap
|
||
msgid "turn towards it,"
|
||
msgstr "obróć się w jego stronę,"
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/while.txt:8
|
||
#, no-wrap
|
||
msgid "shoot."
|
||
msgstr "strzelaj."
|
||
|
||
#. type: Source code
|
||
#: ../E/while.txt:10
|
||
#, no-wrap
|
||
msgid ""
|
||
"\twhile (true)\n"
|
||
"\t{\n"
|
||
"\t\titem = <a cbot|radar>radar</a>(AlienSpider);\n"
|
||
"\t\t<a cbot|turn>turn</a>(direction(item.position));\n"
|
||
"\t\t<a cbot|fire>fire</a>(1);\n"
|
||
"\t}"
|
||
msgstr ""
|
||
"\twhile (true)\n"
|
||
"\t{\n"
|
||
"\t\titem = <a cbot|radar>radar</a>(AlienSpider);\n"
|
||
"\t\t<a cbot|turn>turn</a>(direction(item.position));\n"
|
||
"\t\t<a cbot|fire>fire</a>(1);\n"
|
||
"\t}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/while.txt:17
|
||
#, no-wrap
|
||
msgid "Just execute this program once, and it will kill all spiders around it."
|
||
msgstr "Wystarczy raz uruchomić ten program, a zabije on wszystkie pająki dookoła robota."
|
||
|
||
#. type: Source code
|
||
#: ../E/while.txt:21
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code>while ( condition )\n"
|
||
"{\n"
|
||
"\t</code>Instructions ...<c/>\n"
|
||
"}"
|
||
msgstr ""
|
||
"<code>while ( warunek )\n"
|
||
"{\n"
|
||
"\t</code>Instrukcje ...<c/>\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/while.txt:26
|
||
#, no-wrap
|
||
msgid "This instruction allows you to perform the instructions inside the <a cbot|bloc>block</a> several times."
|
||
msgstr "Instrukcja ta pozwala na wielokrotne powtarzanie instrukcji wewnątrz <a cbot|bloc>bloku</a>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/while.txt:28
|
||
#, no-wrap
|
||
msgid "Be careful not to confuse the instruction <code>while( ) { }</code> with the instruction <c/><a cbot|do>do</a> { } while( );<n/>; the latter tests the condition only after the instructions in the block have been performed a first time. "
|
||
msgstr "Nie należy mylić instrukcji <code>while( ) { }</code> z instrukcją <c/><a cbot|do>do</a> { } while( );<n/>; ta druga sprawdza warunek dopiero po pierwszym wykonaniu instrukcji w bloku. "
|
||
|
||
#. type: Source code
|
||
#: ../E/while.txt:34
|
||
#, no-wrap
|
||
msgid ""
|
||
"<c/>int i = 0;\n"
|
||
"while ( i < 10 )\n"
|
||
"{\n"
|
||
"\t<n/>Instructions ...<c/>\n"
|
||
"\ti = i+1;\n"
|
||
"}"
|
||
msgstr ""
|
||
"<c/>int i = 0;\n"
|
||
"while ( i < 10 )\n"
|
||
"{\n"
|
||
"\t<n/>Instrukcje...<c/>\n"
|
||
"\ti = i+1;\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/while.txt:42
|
||
#, no-wrap
|
||
msgid "Do not put a <a cbot|term>semicolon</a> at the end of the line <code>while ( )</code>."
|
||
msgstr "Na końcu instrukcji <code>while ( )</code> nie należy umieszczać <a cbot|term>średnika</a>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/while.txt:44
|
||
#, no-wrap
|
||
msgid "The instructions <code><a cbot|break>break</a></code> and <code><a cbot|continue>continue</a></code> can be useful inside a block following the instruction <code>while { }</code>."
|
||
msgstr "Instrukcje <code><a cbot|break>break</a></code> i <code><a cbot|continue>continue</a></code> mogą być przydatne wewnątrz bloku instrukcji <code>while ( )</code>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/writeln.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>writeln</code>"
|
||
msgstr "Instrukcja <code>writeln</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/writeln.txt:2
|
||
#, no-wrap
|
||
msgid "Write one line of text to an open file in the files/ folder. This is a method of the <code><a cbot|file>file</a></code> class. This is the reason why we always write <code>handle.writeln()</code>:"
|
||
msgstr "Zapisuje linię tekstu do otwartego pliku w folderze files/. Jest to metoda klasy <code><a cbot|file>file</a></code>, dlatego też zawsze należy używać konstrukcji <code>handle.writeln()</code>:"
|
||
|
||
#. type: Source code
|
||
#: ../E/writeln.txt:4
|
||
#, no-wrap
|
||
msgid "\thandle.writeln(\"abc\");"
|
||
msgstr "\thandle.writeln(\"abc\");"
|
||
|
||
#. type: Plain text
|
||
#: ../E/writeln.txt:6
|
||
#, no-wrap
|
||
msgid "The file must have been opened for writing (<code>\"w\"</code>) with the <code><a cbot|open>open</a></code> instruction. The line will automatically be terminated by the end of line characters 0x0D (CR) and 0x0A (LF)."
|
||
msgstr "Plik musi być otwarty do zapisu (<code>\"w\"</code>) przy użyciu instrukcji <code><a cbot|open>open</a></code>. Zapisywany wiersz zostanie automatycznie zakończony znakami końca linii 0x0D (CR) i 0x0A (LF)."
|
||
|
||
#. type: Source code
|
||
#: ../E/writeln.txt:9
|
||
#, no-wrap
|
||
msgid "<c/>handle.writeln ( string );<n/>"
|
||
msgstr "<c/>handle.writeln ( string );<n/>"
|
||
|
||
#. type: Source code
|
||
#: ../E/writeln.txt:13
|
||
#, no-wrap
|
||
msgid "\twriteln(\"Line of text\");"
|
||
msgstr "\twriteln(\"Linia tekstu\");"
|
||
|
||
#. type: Source code
|
||
#: ../E/writeln.txt:15
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tstring s1 = \"abc\";\n"
|
||
"\tstring s2 = \"def\";\n"
|
||
"\twriteln(s1 + \" \" + s2);"
|
||
msgstr ""
|
||
"\tstring s1 = \"abc\";\n"
|
||
"\tstring s2 = \"def\";\n"
|
||
"\twriteln(s1 + \" \" + s2);"
|
||
|
||
#. type: Plain text
|
||
#: ../E/writeln.txt:20
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|file>file</a></code>, <code><a cbot|open>open</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|readln>readln</a></code> and <code><a cbot|eof>eof</a></code>.\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
"<code><a cbot|file>file</a></code>, <code><a cbot|open>open</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|readln>readln</a></code> i <code><a cbot|eof>eof</a></code>.\n"
|
||
"<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/acos.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>acos</code>"
|
||
msgstr "Instrukcja <code>acos</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/acos.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>acos ( value );<n/>"
|
||
msgstr "<c/>acos ( wartość );<n/>"
|
||
|
||
#. type: \t; header
|
||
#: ../E/acos.txt:5 ../E/asin.txt:5 ../E/atan.txt:5 ../E/ceil.txt:6 ../E/floor.txt:6 ../E/round.txt:6 ../E/sqrt.txt:5 ../E/trunc.txt:6
|
||
#, no-wrap
|
||
msgid "value: <code><a cbot|float>float</a></code>"
|
||
msgstr "wynik: <code><a cbot|float>float</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/acos.txt:6 ../E/asin.txt:6
|
||
#, no-wrap
|
||
msgid "Number between -1 and 1 (including both)."
|
||
msgstr "Liczba z przedziału od -1 do 1 (obustronnie domkniętego)."
|
||
|
||
#. type: Plain text
|
||
#: ../E/acos.txt:9
|
||
#, no-wrap
|
||
msgid "Arcus cosine (in degrees) of the value."
|
||
msgstr "Arcus cosinus (w kątach) danej wartości."
|
||
|
||
#. type: Plain text
|
||
#: ../E/acos.txt:12 ../E/asin.txt:12 ../E/atan.txt:12 ../E/atan2.txt:17 ../E/cos.txt:12 ../E/pow.txt:15 ../E/rand.txt:9 ../E/sin.txt:12 ../E/sqrt.txt:12 ../E/tan.txt:12
|
||
#, no-wrap
|
||
msgid "<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|expr>expressions</a>."
|
||
msgstr "<a cbot>Programowanie</a>, <a cbot|type>typy</a> i <a cbot|expr>wyrażenia</a>."
|
||
|
||
#. type: Source code
|
||
#: ../E/aim.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>aim ( y, x );<n/>"
|
||
msgstr "<c/>aim ( y, x );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/aim.txt:5
|
||
#, no-wrap
|
||
msgid "This instruction sets the vertical and the horizontal angle of the cannon. The following robots are equipped with a cannon: "
|
||
msgstr "Instrukcja ta ustawia działo pod określony kątem, zarówno w pionie, jak i w poziomie. W działo są wyposażone następujące roboty:"
|
||
|
||
#. type: Plain text
|
||
#: ../E/aim.txt:10
|
||
#, no-wrap
|
||
msgid "When controlling the robot through programming, the gun can be also turned left or right by turning the whole robot with the instruction <code><a cbot|turn>turn</a></code>."
|
||
msgstr "Podczas kontrolowania działanie robota przy użyciu programu, lufę można obrócić w prawo lub w lewo, obracając całego robota instrukcją <code><a cbot|turn>turn</a></code>."
|
||
|
||
#. type: \t; header
|
||
#: ../E/aim.txt:12 ../E/atan2.txt:7 ../E/pow.txt:8
|
||
#, no-wrap
|
||
msgid "y: <code><a cbot|float>float</a></code>"
|
||
msgstr "y: <a cbot|float><code>float</code></a>"
|
||
|
||
#. type: \t; header
|
||
#: ../E/aim.txt:15
|
||
#, no-wrap
|
||
msgid "x: <code><a cbot|float>float</a></code> (default value: <code>0</code>)"
|
||
msgstr "x: <code><a cbot|float>float</a></code> (domyślna wartość: <code>0</code>)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/aim.txt:16
|
||
#, no-wrap
|
||
msgid "Angle in degrees of the gun relative to the robot. A positive value orients the gun to the right. The angle must range from <code>-40</code> to <code>+40</code> degrees for all shooters."
|
||
msgstr "Kąt w stopniach w odniesieniu do robota. Wartość dodatnia ustawia lufę w prawo. Ograniczeniem jest przedział od <code>-40</code> do <code>+40</code> stopni; dotyczy on wszystkich dział. "
|
||
|
||
#. type: \b; header
|
||
#: ../E/asin.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>asin</code>"
|
||
msgstr "Instrukcja <code>asin</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/asin.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>asin ( value );<n/>"
|
||
msgstr "<c/>asin ( wartość );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/asin.txt:9
|
||
#, no-wrap
|
||
msgid "Arcus sine (in degrees) of the value."
|
||
msgstr "Arcus sinus (w kątach) danej wartości."
|
||
|
||
#. type: \b; header
|
||
#: ../E/atan.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>atan</code>"
|
||
msgstr "Instrukcja <code>atan</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/atan.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>atan ( value );<n/>"
|
||
msgstr "<c/>atan ( wartość );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/atan.txt:6 ../E/atan2.txt:8 ../E/atan2.txt:11 ../E/ceil.txt:7 ../E/floor.txt:7 ../E/round.txt:7 ../E/trunc.txt:7
|
||
#, no-wrap
|
||
msgid "Number."
|
||
msgstr "Liczba:"
|
||
|
||
#. type: Plain text
|
||
#: ../E/atan.txt:9
|
||
#, no-wrap
|
||
msgid "Arcus tangent (in degrees) of the value."
|
||
msgstr "Arcus tangens (w kątach) danej wartości."
|
||
|
||
#. type: \b; header
|
||
#: ../E/atan2.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>atan2</code>"
|
||
msgstr "Instrukcja <code>atan2</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/atan2.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>atan2 ( y, x );<n/>"
|
||
msgstr "<c/>atan2 ( y, x );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/atan2.txt:5
|
||
#, no-wrap
|
||
msgid "The purpose of using two arguments instead of one is to gather information on the signs of the inputs in order to return the appropriate quadrant of the computed angle, which is not possible for the single-argument <c/><a cbot|atan>atan();</a><n/> function. For example, consider a point <code>(-1, -1)</code>: <c/>atan(-1/-1);<n/> is <code>45.00</code> degrees, whereas <c/>atan2(-1, -1);<n/> is <code>-135.00</code> degrees, which is obviously more correct in this case."
|
||
msgstr "Użycie dwóch argumentów zamiast jednego ma na celu wykorzystanie informacji o znakach obu wartości wejściowych w celu ustalenia ćwiartki, w której znajduje się wyliczony kąt, co nie jest możliwe przy podaniu tyko jednego argumentu.<c/>Funkcja <a cbot|atan>atan();</a><n/>. Przykładowo, rozważmy punkt <code>(-1, -1)</code>: <c/>atan(-1/-1);<n/> zwróci wartość <code>45.00</code> stopni, podczas gdy <c/>atan2(-1, -1);<n/>: <code>-135.00</code> stopni, co jest zdecydowanie poprawniejsze w tej sytuacji."
|
||
|
||
#. type: \t; header
|
||
#: ../E/atan2.txt:10 ../E/pow.txt:5
|
||
#, no-wrap
|
||
msgid "x: <code><a cbot|float>float</a></code>"
|
||
msgstr "x: <code><a cbot|float>float</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/atan2.txt:14
|
||
#, no-wrap
|
||
msgid "Arcus tangent (in degrees) of <code>y/x</code>."
|
||
msgstr "Arcus tangens (w kątach) z <code>y/x</code>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/build.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>build</code>"
|
||
msgstr "Instrukcja <code>build</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/build.txt:2
|
||
#, no-wrap
|
||
msgid "The instruction <c/>build();<n/> instructs the bot to build a building of the given <a cbot|category>category</a>. Currently works for <a object|botgc>Grabbers</a>, <a object|human>Me</a> and <a object|tech>Tech</a>."
|
||
msgstr "Instrukcja <c/>build();<n/> rozkazuje robotowi zbudowanie budynku o danej <a cbot|category>kategorii</a>. Aktualnie budować mogą <a object|botgc>transportery</a>, <a object|human>astronauta</a> i <a object|tech>technicy</a>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/build.txt:5
|
||
#, no-wrap
|
||
msgid "This command is mostly useful in an attempt to build a fully automatised base, where an <a object|human>astronaut</a> does not need to do anything except starting a program and watching bots working. What is more, it makes beating the game by using only programming a possible task (however, it is a challenge rather for experienced gamers, who beat the whole game at least once)."
|
||
msgstr "Komenda ta jest użytecznie głównie w sytuacji, gdy gracz próbuje stworzyć w pełni zautomatyzowaną bazę, w której <a object|human>astronauta</a> nie musi robić nic poza uruchomieniem programu i obserwowaniem pracy robotów. Co więcej, teoretycznie pozwala ona również na ukończenie gry z wykorzystaniem tylko programowania (jest to jednak wyzwanie skierowane raczej do doświadczonych graczy, którzy ukończyli grę przynajmniej raz)."
|
||
|
||
#. type: Plain text
|
||
#: ../E/build.txt:7
|
||
#, no-wrap
|
||
msgid "Here is an example of a program that looks for the nearest <a object|titan>titanium cube</a>, goes to the position and builds a <a object|factory>bot factory</a>."
|
||
msgstr "Poniżej znajduje się przykład programu, który szuka najbliższej <a object|titan>kostki tytanu</a>, idzie do niej i buduje <a object|factory>fabrykę robotów</a>."
|
||
|
||
#. type: Source code
|
||
#: ../E/build.txt:9
|
||
#, no-wrap
|
||
msgid ""
|
||
" <a cbot|object>object</a> item = <a cbot|radar>radar</a>(<a object|titan>Titanium</a>);\n"
|
||
" <a cbot|goto>goto</a>(item.position);\n"
|
||
" build(<a object|factory>BotFactory</a>);"
|
||
msgstr ""
|
||
" <a cbot|object>object</a> item = <a cbot|radar>radar</a>(<a object|titan>Titanium</a>);\n"
|
||
" <a cbot|goto>goto</a>(item.position);\n"
|
||
" build(<a object|factory>BotFactory</a>);"
|
||
|
||
#. type: Source code
|
||
#: ../E/build.txt:15
|
||
#, no-wrap
|
||
msgid "<c/>build ( cat );<n/>"
|
||
msgstr "<c/>build ( kategoria );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/build.txt:17
|
||
#, no-wrap
|
||
msgid "Tells the robot to build a building using a titanium cube placed on a flat ground nearby."
|
||
msgstr "Rozkazuje robotowi zbudować budynek z użyciem kostki tytanu, która znajduje się na płaskim gruncie blisko robota."
|
||
|
||
#. type: \t; header
|
||
#: ../E/build.txt:19 ../E/buildingenabled.txt:16 ../E/canbuild.txt:16 ../E/detect.txt:11 ../E/factory.txt:10 ../E/radar.txt:22
|
||
#, no-wrap
|
||
msgid "cat: <code><a cbot|int>int</a></code>"
|
||
msgstr "kategoria: <code><a cbot|int>int</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/build.txt:20 ../E/buildingenabled.txt:17 ../E/canbuild.txt:17
|
||
#, no-wrap
|
||
msgid "<a cbot|category>Category</a> of a building."
|
||
msgstr "<a cbot|category>Kategoria</a> budynku."
|
||
|
||
#. type: Plain text
|
||
#: ../E/build.txt:23
|
||
#, no-wrap
|
||
msgid ""
|
||
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <code>build()</code>.\n"
|
||
"<code>== 0 </code>Successfully built\n"
|
||
"<code>!= 0 </code>Impossible to build (for example, the nearest titanium cube is too far away or the specified building is not available in the mission)"
|
||
msgstr ""
|
||
"Z reguły po wywołaniu błędu program zatrzymuje się. Możesz temu zapobiec, wykorzystując instrukcję <code><a cbot|errmode>errmode</a>(0)</code>. Jeśli wystąpi błąd, funkcja <code>build()</code> zwróci wartość różną od zera.\n"
|
||
"<code>== 0 </code>Wybudowano pomyślnie\n"
|
||
"<code>!= 0 </code>Nie można wybudować (przykładowo: najbliższa kostka tytanu jest za daleko albo wybrany budynek nie jest dostępny w tej misji) "
|
||
|
||
#. type: Plain text
|
||
#: ../E/build.txt:28
|
||
#, no-wrap
|
||
msgid "<a cbot|canbuild>canbuild</a>, <a cbot|buildingenabled>buildingenabled</a>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr "<a cbot|canbuild>canbuild</a>, <a cbot|buildingenabled>buildingenabled</a>, <a cbot>programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/buildingenabled.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>buildingenabled</code>"
|
||
msgstr "Instrukcja <code>buildingenabled</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/buildingenabled.txt:2
|
||
#, no-wrap
|
||
msgid "The instruction <c/>buildingenabled();<n/> lets you know if a building of the given <a cbot|category>category</a> can be built in the level."
|
||
msgstr "Instrukcja <c/>buildingenabled();<n/> pozwala dowiedzieć się, czy na aktualnym poziomie można zbudować budynek danej <a cbot|category>kategorii</a>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/buildingenabled.txt:5
|
||
#, no-wrap
|
||
msgid "It is similar to the <c/><a cbot|canbuild>canbuild();</a><n/> instruction. However, it does not check if a required research has been done."
|
||
msgstr "Jest podobna do instrukcji <c/><a cbot|canbuild>canbuild();</a><n/>. W przeciwieństwie do niej nie sprawdza jednak, czy odkryto wymaganą technologię."
|
||
|
||
#. type: Source code
|
||
#: ../E/buildingenabled.txt:7
|
||
#, no-wrap
|
||
msgid ""
|
||
" <a cbot|if>if</a> (buildingenabled(<a object|factory>BotFactory</a>))\n"
|
||
" {\n"
|
||
" \tbuild(<a object|factory>BotFactory</a>);\n"
|
||
" }"
|
||
msgstr ""
|
||
" <a cbot|if>if</a> (buildingenabled(<a object|factory>BotFactory</a>))\n"
|
||
" {\n"
|
||
" \tbuild(<a object|factory>BotFactory</a>);\n"
|
||
" }"
|
||
|
||
#. type: Source code
|
||
#: ../E/buildingenabled.txt:14
|
||
#, no-wrap
|
||
msgid "<c/>buildingenabled ( cat );<n/>"
|
||
msgstr "<c/>buildingenabled ( kategoria );<n/>"
|
||
|
||
#. type: \t; header
|
||
#: ../E/buildingenabled.txt:19 ../E/busy.txt:10 ../E/canbuild.txt:19 ../E/canresearch.txt:10 ../E/detect.txt:23 ../E/researched.txt:10
|
||
#, no-wrap
|
||
msgid "Return value: <code><a cbot|bool>bool</a></code>"
|
||
msgstr "Typ wyniku: <code><a cbot|bool>bool</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/buildingenabled.txt:20
|
||
#, no-wrap
|
||
msgid "<code>true</code> if the building can be built in the level even if required research has not been done, <code>false</code> otherwise."
|
||
msgstr "<code>true</code>, jeśli budynek może być zbudowany na aktualnym poziomie, niezależnie od tego, czy została odkryta wymagana technologia, w przeciwnym razie <code>false</code>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/buildingenabled.txt:23
|
||
#, no-wrap
|
||
msgid "<a cbot|build>build</a>, <a cbot|canbuild>canbuild</a>, <a object|research>ResearchCenter</a>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr "<a cbot|build>build</a>, <a cbot|canbuild>canbuild</a>, <a object|research>ResearchCenter</a>, <a cbot>programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/busy.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>busy</code>"
|
||
msgstr "Instrukcja <code>busy</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/busy.txt:3
|
||
#, no-wrap
|
||
msgid "<c/><a cbot|object>object</a>.busy ( );<n/>"
|
||
msgstr "<c/><a cbot|object>obiekt</a>.busy ( );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/busy.txt:5
|
||
#, no-wrap
|
||
msgid "Checks if the object is busy."
|
||
msgstr "Sprawdza, czy dany obiekt jest zajęty."
|
||
|
||
#. type: \t; header
|
||
#: ../E/busy.txt:7 ../E/destroy.txt:7 ../E/factory.txt:7 ../E/research.txt:7 ../E/takeoff.txt:7
|
||
#, no-wrap
|
||
msgid "<a cbot|object>object</a>"
|
||
msgstr "<a cbot|object>obiekt</a>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/busy.txt:8
|
||
#, no-wrap
|
||
msgid "Any building which can take some action (e.g. <a cbot|convert>Converter</a>)."
|
||
msgstr "Dowolny budynek, który wykonuje jakieś czynności (np. <a cbot|convert>Huta</a>)."
|
||
|
||
#. type: Plain text
|
||
#: ../E/busy.txt:11
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><format const>true</format></code> if the object is doing something (e.g. converting)\n"
|
||
"<code><format const>false</format></code> if the object is not doing anything"
|
||
msgstr ""
|
||
"Zwraca wartość <code><format const>true</format></code>, jeśli obiekt jest zajęty pewną czynnością (np. przetapianiem)\n"
|
||
"<code><format const>false</format></code>, jeśli obiekt nic nie robi."
|
||
|
||
#. type: \b; header
|
||
#: ../E/canbuild.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>canbuild</code>"
|
||
msgstr "Instrukcja <code>canbuild</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/canbuild.txt:2
|
||
#, no-wrap
|
||
msgid "The instruction <c/>canbuild();<n/> lets you know if <a object|botgc>Grabbers</a>, <a object|human>Me</a> or <a object|human>Tech</a> can build a building of the given <a cbot|category>category</a>. "
|
||
msgstr "Instrukcja <c/>canbuild();<n/> pozwala sprawdzić, czy <a object|botgc>transporter</a>, <a object|human>astronauta</a> lub <a object|human>technik</a> może zbudować budynek danej <a cbot|category>kategorii</a>. "
|
||
|
||
#. type: Plain text
|
||
#: ../E/canbuild.txt:5
|
||
#, no-wrap
|
||
msgid "It helps to prevent errors in programs using the <c/><a cbot|build>build();</a><n/> instruction. Here is an example:"
|
||
msgstr "Użycie jej pozwala uniknąć błędów w programach, które wykorzystują instrukcję <c/><a cbot|build>build();</a><n/>. Przykładowo:"
|
||
|
||
#. type: Source code
|
||
#: ../E/canbuild.txt:7
|
||
#, no-wrap
|
||
msgid ""
|
||
" <a cbot|if>if</a> (canbuild(<a object|factory>BotFactory</a>))\n"
|
||
" {\n"
|
||
" \tbuild(<a object|factory>BotFactory</a>);\n"
|
||
" }"
|
||
msgstr ""
|
||
" <a cbot|if>if</a> (canbuild(<a object|factory>BotFactory</a>))\n"
|
||
" {\n"
|
||
" \tbuild(<a object|factory>BotFactory</a>);\n"
|
||
" }"
|
||
|
||
#. type: Source code
|
||
#: ../E/canbuild.txt:14
|
||
#, no-wrap
|
||
msgid "<c/>canbuild ( cat );<n/>"
|
||
msgstr "<c/>canbuild ( cat );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/canbuild.txt:20
|
||
#, no-wrap
|
||
msgid "<code>true</code> if the building can be built, <code>false</code> otherwise."
|
||
msgstr "Zwraca wartość <code>true</code>, jeśli można wybudować budynek, w przeciwnym razie <code>false</code>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/canbuild.txt:23
|
||
#, no-wrap
|
||
msgid "<a cbot|build>build</a>, <a cbot|buildingenabled>buildingenabled</a>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr "<a cbot|build>build</a>, <a cbot|buildingenabled>buildingenabled</a>, <a cbot>programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/canresearch.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>canresearch</code>"
|
||
msgstr "Instruction <code>canresearch</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/canresearch.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>canresearch ( research );<n/>"
|
||
msgstr "<c/>canresearch ( technologia );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/canresearch.txt:5
|
||
#, no-wrap
|
||
msgid "Checks if the <a cbot|researches>research</a> can be done in the level."
|
||
msgstr "Sprawdza, czy na tym poziomie można odkryć daną <a cbot|researches>research</a>."
|
||
|
||
#. type: \t; header
|
||
#: ../E/canresearch.txt:7 ../E/researched.txt:7
|
||
#, no-wrap
|
||
msgid "research: <code><a cbot|int>int</a></code>"
|
||
msgstr "technologia: <code><a cbot|int>int</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/canresearch.txt:8 ../E/research.txt:11 ../E/researched.txt:8
|
||
#, no-wrap
|
||
msgid "<a cbot|researches>Research name</a>."
|
||
msgstr "<a cbot|researches>Nazwa technologii</a>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/canresearch.txt:11
|
||
#, no-wrap
|
||
msgid ""
|
||
"<format const>true</format> if the research can be done (even if it is already done, to check that, use the <a cbot|researched>researched</a> instruction)\n"
|
||
"<format const>false</format> if the research cannot be done"
|
||
msgstr ""
|
||
"Zwraca wartość <format const>true</format>, jeśli technologię można odkryć (nie sprawdza jednak, czy nie została już odkryta; do tego służy instrukcja <a cbot|researched>researched</a>)\n"
|
||
"<format const>false</format>, jeśli technologii nie można odkryć"
|
||
|
||
#. type: Plain text
|
||
#: ../E/canresearch.txt:15
|
||
#, no-wrap
|
||
msgid "<a cbot|researches>Research names</a>, <a cbot|research>research</a>, <a cbot|researched>researched</a>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr "<a cbot|researches>Nazwy technologii</a>, <a cbot|research>research</a>, <a cbot|researched>researched</a>, <a cbot>programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/category.txt:6
|
||
#, no-wrap
|
||
msgid "Below are the different categories available:"
|
||
msgstr "Poniżej podano dostępne kategorie:"
|
||
|
||
#. type: \t; header
|
||
#: ../E/category.txt:8
|
||
#, no-wrap
|
||
msgid "Buildings:"
|
||
msgstr "Budynki:"
|
||
|
||
#. type: \t; header
|
||
#: ../E/category.txt:32
|
||
#, no-wrap
|
||
msgid "Portable Objects:"
|
||
msgstr "Obiekty przenośne:"
|
||
|
||
#. type: \t; header
|
||
#: ../E/category.txt:45
|
||
#, no-wrap
|
||
msgid "Robots:"
|
||
msgstr "Roboty:"
|
||
|
||
#. type: \t; header
|
||
#: ../E/category.txt:82
|
||
#, no-wrap
|
||
msgid "Enemies:"
|
||
msgstr "Przeciwnicy:"
|
||
|
||
#. type: \t; header
|
||
#: ../E/category.txt:92
|
||
#, no-wrap
|
||
msgid "Miscellaneous:"
|
||
msgstr "Różne:"
|
||
|
||
#. type: \t; header
|
||
#: ../E/category.txt:101
|
||
#, no-wrap
|
||
msgid "Flags and Other Indicators:"
|
||
msgstr "Flagi i inne wskaźniki:"
|
||
|
||
#. type: \b; header
|
||
#: ../E/ceil.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>ceil</code>"
|
||
msgstr "Instrukcja <code>ceil</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/ceil.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>ceil ( value );<n/>"
|
||
msgstr "<c/>ceil ( wartosc );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/ceil.txt:4
|
||
#, no-wrap
|
||
msgid "Rounds up a number."
|
||
msgstr "Zaokrągla liczbę."
|
||
|
||
#. type: Plain text
|
||
#: ../E/ceil.txt:10
|
||
#, no-wrap
|
||
msgid "Ceiling of the value, i.e. the smallest integer not less than <code>value</code>. For example, <code>ceil(2.1)</code> is <code>3.0</code>."
|
||
msgstr "Zaokrąglona wartość, tzn. najmniejsza liczba całkowita nie mniejsza od <code>wartosc</code>. Dla przykładu, <code>ceil(2.1)</code> da w wyniku <code>3.0</code>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/ceil.txt:13 ../E/floor.txt:13 ../E/trunc.txt:13
|
||
#, no-wrap
|
||
msgid "<a cbot|round>round</a>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|expr>expressions</a>."
|
||
msgstr "<a cbot|round>round</a>, <a cbot>programowanie</a>, <a cbot|type>typy</a> i <a cbot|expr>wyrażenia</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/colors.txt:1
|
||
#, no-wrap
|
||
msgid "Value <code>Colors</code>"
|
||
msgstr "Wartości <code>kolorów</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/colors.txt:2
|
||
#, no-wrap
|
||
msgid "Color names are used to define a specific color to use. They can be passed to functions like <a cbot|pendown>pendown</a> or <a cbot|pencolor>pencolor</a>."
|
||
msgstr "Nazwy kolorów określają kolor, który ma być użyty. Mogą być przekazane do takich funkcji jak <a cbot|pendown>pendown</a> czy <a cbot|pencolor>pencolor</a>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/colors.txt:4
|
||
#, no-wrap
|
||
msgid "In a program, colors are always displayed on a <format const>red background</format>. If a color isn't highlighted in red, it is misspelled. Caps and lower cases should be kept as is."
|
||
msgstr "W edytorze programów kolory są zawsze pokazywane na <format const>czerwonym tle</format>. Jeśli kolor nie ma takiego tła, do jego nazwy wkradła się literówka. Nie należy zmieniać wielkości liter."
|
||
|
||
#. type: Plain text
|
||
#: ../E/colors.txt:6
|
||
#, no-wrap
|
||
msgid "Below are the different colors available:"
|
||
msgstr "Poniżej opisano dostępne kolory:"
|
||
|
||
#. type: Plain text
|
||
#: ../E/colors.txt:8
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><format const>White</format></code>\n"
|
||
"<code><format const>Black</format></code>\n"
|
||
"<code><format const>Gray</format></code>\n"
|
||
"<code><format const>LightGray</format></code>\n"
|
||
"<code><format const>Red</format></code>\n"
|
||
"<code><format const>Pink</format></code>\n"
|
||
"<code><format const>Purple</format></code>\n"
|
||
"<code><format const>Orange</format></code>\n"
|
||
"<code><format const>Yellow</format></code>\n"
|
||
"<code><format const>Beige</format></code>\n"
|
||
"<code><format const>Brown</format></code>\n"
|
||
"<code><format const>Skin</format></code>\n"
|
||
"<code><format const>Green</format></code>\n"
|
||
"<code><format const>LightGreen</format></code>\n"
|
||
"<code><format const>Blue</format></code>\n"
|
||
"<code><format const>LightBlue</format></code>"
|
||
msgstr ""
|
||
"<code><format const>White</format></code>\n"
|
||
"<code><format const>Black</format></code>\n"
|
||
"<code><format const>Gray</format></code>\n"
|
||
"<code><format const>LightGray</format></code>\n"
|
||
"<code><format const>Red</format></code>\n"
|
||
"<code><format const>Pink</format></code>\n"
|
||
"<code><format const>Purple</format></code>\n"
|
||
"<code><format const>Orange</format></code>\n"
|
||
"<code><format const>Yellow</format></code>\n"
|
||
"<code><format const>Beige</format></code>\n"
|
||
"<code><format const>Brown</format></code>\n"
|
||
"<code><format const>Skin</format></code> (biały)\n"
|
||
"<code><format const>Green</format></code> (zielony)\n"
|
||
"<code><format const>LightGreen</format></code> (jasnozielony)\n"
|
||
"<code><format const>Blue</format></code> (niebieski)\n"
|
||
"<code><format const>LightBlue</format></code> (jasnoniebieski)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/colors.txt:25
|
||
#, no-wrap
|
||
msgid "You can also draw colored symbols:"
|
||
msgstr "Można też rysować kolorowe symbole:"
|
||
|
||
#. type: Plain text
|
||
#: ../E/colors.txt:27
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><format const>BlackArrow</format></code>\n"
|
||
"<code><format const>RedArrow</format></code>"
|
||
msgstr ""
|
||
"<code><format const>BlackArrow</format></code> (czarna strzałka)\n"
|
||
"<code><format const>RedArrow</format></code> (czerwona strzałka)"
|
||
|
||
#. type: \b; header
|
||
#: ../E/cos.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>cos</code>"
|
||
msgstr "Instrukcja <code>cos</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/cos.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>cos ( angle );<n/>"
|
||
msgstr "<c/>cos ( kat );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/cos.txt:6 ../E/sin.txt:6
|
||
#, no-wrap
|
||
msgid "Angle in degrees."
|
||
msgstr "Miara kąta w stopniach."
|
||
|
||
#. type: Plain text
|
||
#: ../E/cos.txt:9
|
||
#, no-wrap
|
||
msgid "Cosine of the angle."
|
||
msgstr "Cosinus danego kąta."
|
||
|
||
#. type: \b; header
|
||
#: ../E/destroy.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>destroy</code>"
|
||
msgstr "Instrukcja <code>destroy</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/destroy.txt:3
|
||
#, no-wrap
|
||
msgid "<c/><a cbot|object>object</a>.destroy ( );<n/>"
|
||
msgstr "<c/><a cbot|object>object</a>.destroy ( );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/destroy.txt:5
|
||
#, no-wrap
|
||
msgid "Destroys an object."
|
||
msgstr "Niszczy obiekt."
|
||
|
||
#. type: Plain text
|
||
#: ../E/destroy.txt:8
|
||
#, no-wrap
|
||
msgid "<a object|destroy>Destroyer</a>."
|
||
msgstr "<a object|destroy>Niszczarka</a>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/destroy.txt:11
|
||
#, no-wrap
|
||
msgid ""
|
||
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <code>destroy()</code>.\n"
|
||
"<code>== 0 </code>The operation of destroying of an object was started\n"
|
||
"<code>!= 0 </code>The instruction could not be done (e.g. nothing to destroy)"
|
||
msgstr ""
|
||
"Z reguły po wywołaniu błędu program zatrzymuje się. Możesz temu zapobiec, wykorzystując instrukcję <code><a cbot|errmode>errmode</a>(0)</code>. Jeśli wystąpi błąd, funkcja <code>destroy()</code> zwróci wartość różną od zera.\n"
|
||
"<code>== 0 </code>Rozpoczęto operację niszczenia\n"
|
||
"<code>!= 0 </code>Nie udało się wykonać instrukcji (np. nie ma nic do zniszczenia)"
|
||
|
||
#. type: \b; header
|
||
#: ../E/detect.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>detect</code>"
|
||
msgstr "Instrukcja <code>detect</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/detect.txt:2
|
||
#, no-wrap
|
||
msgid "With the instruction <c/>detect();<n/>, you can look for objects like <a object|mother>enemies</a>, bots, buildings or raw materials, which are in front of the bot. It is a simpler version of <c/><a cbot|radar>radar</a>();<n/>."
|
||
msgstr "Korzystają z instrukcji <c/>detect();<n/>, można szukać <a object|mother>przeciwników</a>, robotów, budynków oraz nieprzetworzonych materiałów, które znajdują się z przodu robota. Jest to uproszczona wersja instrukcji <c/><a cbot|radar>radar</a>();<n/>."
|
||
|
||
#. type: Source code
|
||
#: ../E/detect.txt:6
|
||
#, no-wrap
|
||
msgid "<c/>detect ( cat );<n/>"
|
||
msgstr "<c/>detect ( kategoria );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/detect.txt:8
|
||
#, no-wrap
|
||
msgid "Detects the nearest object of the specified <a cbot|category>category</a> being in front of the bot. It is similar to the following instruction:"
|
||
msgstr "Wykrywa najbliższy obiekt podanej <a cbot|category>kategorii</a> znajdujący się z przodu robota. Jest podobna do następującej instrukcji:"
|
||
|
||
#. type: Source code
|
||
#: ../E/detect.txt:9
|
||
#, no-wrap
|
||
msgid "<c/>radar(cat, 0, 45, 0, 20);<n/>"
|
||
msgstr "<c/>radar(cat, 0, 45, 0, 20);<n/>"
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/detect.txt:12 ../E/radar.txt:23
|
||
#, no-wrap
|
||
msgid "<a cbot|category>Category</a> of the objects that should be detected. For example, when you are looking for an ant, write <code>radar(AlienAnt)</code>. "
|
||
msgstr "<a cbot|category>Kategoria</a> obiektórw, które powinny być wykryte. Na przykład, gdy szukasz mrówki, napisz <code>radar(AlienAnt)</code>. "
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/detect.txt:13
|
||
#, no-wrap
|
||
msgid "<a cbot|array>Array</a> of categories of the objects that should be detected. For example, when you are looking only for grabbers:<c/>"
|
||
msgstr "<a cbot|array>Tablica</a> kategorii obiektów, które powinny zostać wykryte. Na przykład, gdy szukasz tylko transporterów:<c/>"
|
||
|
||
#. type: Source code
|
||
#: ../E/detect.txt:14
|
||
#, no-wrap
|
||
msgid ""
|
||
"int bots[4];\n"
|
||
"bots[0] = WheeledGrabber;\n"
|
||
"bots[1] = TrackedGrabber;\n"
|
||
"bots[2] = WingedGrabber;\n"
|
||
"bots[3] = LeggedGrabber;\n"
|
||
"object nearestGrabber = radar(bots);"
|
||
msgstr ""
|
||
"int bots[4];\n"
|
||
"bots[0] = WheeledGrabber;\n"
|
||
"bots[1] = TrackedGrabber;\n"
|
||
"bots[2] = WingedGrabber;\n"
|
||
"bots[3] = LeggedGrabber;\n"
|
||
"object nearestGrabber = radar(bots);"
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/detect.txt:21 ../E/search.txt:17
|
||
#, no-wrap
|
||
msgid "Keyword <format const>Any</format> if you are looking for any object (including even plants and so on)."
|
||
msgstr "Użyj słowa <format const>Any</format>, jeśli szukasz dowolnego obiektu (wliczając w to rośliny itp.)."
|
||
|
||
#. type: Plain text
|
||
#: ../E/detect.txt:24
|
||
#, no-wrap
|
||
msgid ""
|
||
"<format const>true</format> if the object was found\n"
|
||
"<format const>false</format> if the object was not found"
|
||
msgstr ""
|
||
"<format const>true</format> jeśli obiekt został znaleziony\n"
|
||
"<format const>false</format> jeżeli obiektu nie znaleziono"
|
||
|
||
#. type: \b; header
|
||
#: ../E/factory.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>factory</code>"
|
||
msgstr "Instrukcja <code>factory</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/factory.txt:3
|
||
#, no-wrap
|
||
msgid "<c/><a cbot|object>object</a>.factory ( cat, program );<n/>"
|
||
msgstr "<c/><a cbot|object>object</a>.factory ( kategoria, program );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/factory.txt:5
|
||
#, no-wrap
|
||
msgid "Starts a construction of a bot of the given <a cbot|category>category</a> and runs the specified program on it after the construction is finished."
|
||
msgstr "Rozpoczyna konstrukcję robota podanej <a cbot|category>kategorii</a> i uruchamia na nim podany program po jej zakończeniu."
|
||
|
||
#. type: Plain text
|
||
#: ../E/factory.txt:8
|
||
#, no-wrap
|
||
msgid "<a object|factory>BotFactory</a>"
|
||
msgstr "<a object|factory>BotFactory</a>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/factory.txt:11
|
||
#, no-wrap
|
||
msgid "<a cbot|category>Category</a> of the robot to construct."
|
||
msgstr "<a cbot|category>Kategoria</a> robota, który ma zostać skonstruowany."
|
||
|
||
#. type: \t; header
|
||
#: ../E/factory.txt:13
|
||
#, no-wrap
|
||
msgid "program: <code><a cbot|string>string</a></code> (default value: <code>\"\"</code>)"
|
||
msgstr "program: <code><a cbot|string>string</a></code> (domyślnie przyjmuje: <code>\"\"</code>)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/factory.txt:14
|
||
#, no-wrap
|
||
msgid "Program that will be run on the bot after factory finishes the construction. This can be either a <a cbot|public>public</a> <a cbot|function>function</a>, a <a cbot|file>filename</a> or just a raw source code."
|
||
msgstr "Program, który zostanie uruchomiony na robocie po zakończeniu konstrukcji. Może być to albo <a cbot|function>funkcja</a> <a cbot|public>publiczna</a>, <a cbot|file>nazwa pliku</a> albo po prostu podany kod."
|
||
|
||
#. type: Plain text
|
||
#: ../E/factory.txt:17
|
||
#, no-wrap
|
||
msgid ""
|
||
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <code>factory()</code>.\n"
|
||
"<code>== 0 </code>The construction successfully started\n"
|
||
"<code>!= 0 </code>The construction could not be started (e.g. no <a object|titan>Titanium</a> in the factory, the bot is not researched)"
|
||
msgstr ""
|
||
"Z reguły po wywołaniu błędu program zatrzymuje się. Możesz temu zapobiec, wykorzystując instrukcję <code><a cbot|errmode>errmode</a>(0)</code>. Jeśli wystąpi błąd, funkcja <code>factory()</code> zwróci wartość różną od zera.\n"
|
||
"<code>== 0 </code>Rozpoczęto konstrukcję\n"
|
||
"<code>!= 0 </code>Nie udało się rozpocząć konstrukcji (np. w fabryce nie ma <a object|titan>kostki tytanu</a>, robot nie został odkryty)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/factory.txt:22
|
||
#, no-wrap
|
||
msgid "<a cbot|researched>researched</a>, <a cbot|>wait</a>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr "<a cbot|researched>researched</a>, <a cbot|>wait</a>, <a cbot>programowanie</a>, <a cbot|type>typy</a> i <a cbot|category>kategorie</a>."
|
||
|
||
#. type: \b; header
|
||
#: ../E/flatspace.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>flatspace</code>"
|
||
msgstr "Instrukcja <code>flatspace</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/flatspace.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>flatspace ( center, flatmin, rmin, rmax, dist );<n/>"
|
||
msgstr "<c/>flatspace ( center, flatmin, rmin, rmax, dist );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/flatspace.txt:5
|
||
#, no-wrap
|
||
msgid "Determines the position of the nearest free space with at least <code>flatmin</code> of flat ground around a given position. Works similar to <c/><a cbot|space>space();</a><n/>. Useful for finding a place for a <a cbot|category>building</a>."
|
||
msgstr "Określa pozycję najbliższego pustego miejsca, wokół którego jest przynajmniej <code>flatmin</code> płaskiego terenu. Działa podobnie do instrukcji <c/><a cbot|space>space();</a><n/>. Przydatna podczas szukania miejsca na <a cbot|category>budynek</a>."
|
||
|
||
#. type: \t; header
|
||
#: ../E/flatspace.txt:10
|
||
#, no-wrap
|
||
msgid "flatmin: <code><a cbot|float>float</a></code>"
|
||
msgstr "flatmin: <code><a cbot|float>float</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/flatspace.txt:11
|
||
#, no-wrap
|
||
msgid "Minimum radius of flat ground around the desired position."
|
||
msgstr "Najmniejszy promień płaskiego gruntu wokół żądanej pozycji."
|
||
|
||
#. type: \b; header
|
||
#: ../E/floor.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>floor</code>"
|
||
msgstr "Instrukcja <code>floor</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/floor.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>floor ( value );<n/>"
|
||
msgstr "<c/>floor ( wartosc );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/floor.txt:4
|
||
#, no-wrap
|
||
msgid "Rounds down a number."
|
||
msgstr "Zaokrągla numer w dół."
|
||
|
||
#. type: Plain text
|
||
#: ../E/floor.txt:10
|
||
#, no-wrap
|
||
msgid "Floor of the value, i.e. the largest integer not greater than <code>value</code>. For example, <code>floor(2.9)</code> is <code>2.00</code>."
|
||
msgstr "Zaokrąglona wartość, tzn. największa liczba całkowita nie większa od <code>wartosc</code>. Na przykład, <code>floor(2.9)</code> da w wyniku <code>2.00</code>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/for.txt:19
|
||
#, no-wrap
|
||
msgid ""
|
||
"Example: count from 1 to 4\n"
|
||
"<c/><s/><c/>for ( i = 1 ; i <= 4 ; i++ )"
|
||
msgstr ""
|
||
"Przykład: liczenie od 1 do 4\n"
|
||
"<c/><s/><c/>for ( i = 1 ; i <= 4 ; i++ )"
|
||
|
||
#. type: Plain text
|
||
#: ../E/function.txt:2
|
||
#, no-wrap
|
||
msgid "Function, simply put, is an instruction created by you."
|
||
msgstr "Funkcja to, mówiąc najprościej, instrukcja stworzona przez ciebie."
|
||
|
||
#. type: \b; header
|
||
#: ../E/function.txt:4
|
||
#, no-wrap
|
||
msgid "Main function"
|
||
msgstr "Funkcja główna"
|
||
|
||
#. type: Plain text
|
||
#: ../E/function.txt:5
|
||
#, no-wrap
|
||
msgid "You probably already know how to create a function. Every program in CBOT must have a main function, which looks like this:"
|
||
msgstr "Pewnie już wiesz, jak się tworzy funkcje. Każdy program napisany w CBOT musi mieć funkcję główną, która wygląda tak:"
|
||
|
||
#. type: Source code
|
||
#: ../E/function.txt:7
|
||
#, no-wrap
|
||
msgid ""
|
||
"extern void object::ProgramName()\n"
|
||
"{\n"
|
||
"\t\n"
|
||
"\t// instructions\n"
|
||
"\t\n"
|
||
"}"
|
||
msgstr ""
|
||
"extern void object::NazwaProgramu()\n"
|
||
"{\n"
|
||
"\t\n"
|
||
"\t// instrukcje\n"
|
||
"\t\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/function.txt:17
|
||
#, no-wrap
|
||
msgid "With functions you can divide your program into several parts. Each of them will execute a specific task. For example, see the following program:"
|
||
msgstr "Funkcje pozwalają na podzielenie programu na kilka części. Każda z nich wykonuje określone zadanie. Poniższy program jest przykładem takiego zastosowania:"
|
||
|
||
#. type: Source code
|
||
#: ../E/function.txt:19
|
||
#, no-wrap
|
||
msgid ""
|
||
"extern void object::Remote()\n"
|
||
"{\n"
|
||
"\tsend(\"order\", 1, 100);\n"
|
||
"\twait(5);\n"
|
||
"\tsend(\"order\", 3, 100);\n"
|
||
"\twait(5);\n"
|
||
"\tsend(\"order\", 2, 100);\n"
|
||
"\twait(5);\n"
|
||
"\tsend(\"order\", 4, 100);\n"
|
||
"\twait(5);\n"
|
||
"}"
|
||
msgstr ""
|
||
"extern void object::Remote()\n"
|
||
"{\n"
|
||
"\tsend(\"order\", 1, 100);\n"
|
||
"\twait(5);\n"
|
||
"\tsend(\"order\", 3, 100);\n"
|
||
"\twait(5);\n"
|
||
"\tsend(\"order\", 2, 100);\n"
|
||
"\twait(5);\n"
|
||
"\tsend(\"order\", 4, 100);\n"
|
||
"\twait(5);\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/function.txt:31
|
||
#, no-wrap
|
||
msgid "<code><a cbot|send>send</a></code> and <code><a cbot|wait>wait</a></code> are repeated several times. So it would be a good thing if we created a function that executes these two instructions:"
|
||
msgstr "Instrukcje <code><a cbot|send>send</a></code> i <code><a cbot|wait>wait</a></code> są powtarzane po kilka razy. Byłoby więc dobrze stworzyć funkcję, która wykonuje obie te instrukcje:"
|
||
|
||
#. type: Source code
|
||
#: ../E/function.txt:33
|
||
#, no-wrap
|
||
msgid ""
|
||
"void SendToPost(float op)\n"
|
||
"{\n"
|
||
"\tsend(\"order\", op, 100);\n"
|
||
"\twait(5);\n"
|
||
"}\n"
|
||
"\n"
|
||
"extern void object::Remote()\n"
|
||
"{\n"
|
||
"\tSendToPost(1);\n"
|
||
"\tSendToPost(3);\n"
|
||
"\tSendToPost(2);\n"
|
||
"\tSendToPost(4);\n"
|
||
"}"
|
||
msgstr ""
|
||
"void SendToPost(float op)\n"
|
||
"{\n"
|
||
"\tsend(\"order\", op, 100);\n"
|
||
"\twait(5);\n"
|
||
"}\n"
|
||
"\n"
|
||
"extern void object::Remote()\n"
|
||
"{\n"
|
||
"\tSendToPost(1);\n"
|
||
"\tSendToPost(3);\n"
|
||
"\tSendToPost(2);\n"
|
||
"\tSendToPost(4);\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/function.txt:47
|
||
#, no-wrap
|
||
msgid "Now the program is much easier to read. It is a good practice to split the program into several functions with self-describing names."
|
||
msgstr "Program jest teraz zdecydowanie czytelniejszy. Dzielenie program na kilka funkcji o nazwach, które je opisują, jest dobrą praktyką."
|
||
|
||
#. type: \b; header
|
||
#: ../E/function.txt:49
|
||
#, no-wrap
|
||
msgid "Syntax"
|
||
msgstr "Składnia"
|
||
|
||
#. type: Source code
|
||
#: ../E/function.txt:51
|
||
#, no-wrap
|
||
msgid ""
|
||
"result_type FunctionName(optional_parameters)\n"
|
||
"{\n"
|
||
"\tbody\n"
|
||
"}"
|
||
msgstr ""
|
||
"typ Nazwa funkcji(opcjonalne_parametry)\n"
|
||
"{\n"
|
||
"\tciało funkcji\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/function.txt:56
|
||
#, no-wrap
|
||
msgid "Result <a cbot|type>type</a> should be <a cbot/void>void</a> if the function does not give any. Body is just a set of instructions. Function name must be created with the exact same rules applied to <a cbot|var>variables</a>."
|
||
msgstr "Jeśli funkcja nie ma zwracać żadnych danych, <a cbot|type>typem</a> powinien być <a cbot/void>void</a>. Ciało funkcji stanowią instrukcje. Nazwa funkcji musi być stworzona w oparciu o reguły tworzenia nazw <a cbot|var>zmiennych</a>."
|
||
|
||
#. type: \t; header
|
||
#: ../E/function.txt:58
|
||
#, no-wrap
|
||
msgid "Parameters"
|
||
msgstr "Parametry"
|
||
|
||
#. type: Plain text
|
||
#: ../E/function.txt:59
|
||
#, no-wrap
|
||
msgid "A function can have parameters:"
|
||
msgstr "Funkcja może mieć parametry:"
|
||
|
||
#. type: Source code
|
||
#: ../E/function.txt:61
|
||
#, no-wrap
|
||
msgid ""
|
||
"void Example(int a, float x, string s)\n"
|
||
"{\n"
|
||
"\tmessage(a);\n"
|
||
"\tmessage(x);\n"
|
||
"\tmessage(s);\n"
|
||
"}"
|
||
msgstr ""
|
||
"void Przyklad(int a, float x, string s)\n"
|
||
"{\n"
|
||
"\tmessage(a);\n"
|
||
"\tmessage(x);\n"
|
||
"\tmessage(s);\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/function.txt:68
|
||
#, no-wrap
|
||
msgid "The <code>Example</code> function will receive an <a cbot|int>integer</a> <code>a</code>, a <a cbot|float>floating point number</a> <code>x</code> and a <a cbot|string>string</a> <code>s</code>. Parameters are \"passed by value\", that is the values of parameter variables in a function are copies of the values the caller specified as variables. If you pass an <code><a cbot|int>int</a></code> to a function, its parameter is a copy of whatever value was being passed as the argument, and the function can change its parameter value without affecting values in the code that invoked the function."
|
||
msgstr "Funkcja <code>Przyklad</code> otrzyma <a cbot|int>liczbę całkowitą</a> <code>a</code>, <a cbot|float>liczbę zmiennoprzecinkową</a> <code>x</code> i <a cbot|string>łańcuch znaków</a> <code>s</code>. Parametry są \"przekazywane wartościami\", tzn. wartości zmiennych parametrów w funkcji są kopiami wartości, które zostały do niej przekazane. Jeśli przekażesz funkcji wartość typu <code><a cbot|int>int</a></code>, wartość ta zostanie skopiowana do parametru i funkcja będzie mogła na niej operować, nie zmieniając jednocześnie wartości w kodzie, który ją wywołał."
|
||
|
||
#. type: Plain text
|
||
#: ../E/function.txt:70
|
||
#, no-wrap
|
||
msgid "If you pass a <a cbot|class>class</a> instance or an <a cbot|array>array</a> as parameter to a function, the function only receives a <a cbot|pointer>reference</a> to the instance or the array. That means if you modify the instance or the array in the function, the instance or the array that has been specified by the caller will be actually modified."
|
||
msgstr "Jeśli przekażesz jako parametr funkcji instancję <a cbot|class>klasy</a> lub <a cbot|array>tablicę</a>, funkcja otrzyma tylko <a cbot|pointer>odniesienie</a> do instancji lub tablicy. Oznacza to, że jeśli zmieniona w funkcji tę instancję lub tablicę, oryginalna instancja lub tablica zostanie również zmieniona."
|
||
|
||
#. type: \t; header
|
||
#: ../E/function.txt:72
|
||
#, no-wrap
|
||
msgid "Result"
|
||
msgstr "Wynik"
|
||
|
||
#. type: Plain text
|
||
#: ../E/function.txt:73
|
||
#, no-wrap
|
||
msgid "A function can also return a result with the <code><a cbot|return>return</a></code> instruction. Therefore the function must be declared no longer as <code><a cbot|void>void</a></code> but as an other <a cbot|type>type</a>:"
|
||
msgstr "Funkcja może też zwrócić wynik, korzystając z instrukcji <code><a cbot|return>return</a></code>. W takiej sytuacji <a cbot|type>typem</a> funkcji nie może być <code><a cbot|void>void</a></code>:"
|
||
|
||
#. type: Source code
|
||
#: ../E/function.txt:75
|
||
#, no-wrap
|
||
msgid ""
|
||
"float Average(float a, float b)\n"
|
||
"{\n"
|
||
"\treturn (a+b)/2;\n"
|
||
"}\n"
|
||
"\n"
|
||
"extern void object::Test( )\n"
|
||
"{\n"
|
||
"\tfloat value;\n"
|
||
"\tvalue = Average(2, 6);\n"
|
||
"\tmessage(value); // will display 4\n"
|
||
"}"
|
||
msgstr ""
|
||
"float Srednia(float a, float b)\n"
|
||
"{\n"
|
||
"\treturn (a+b)/2;\n"
|
||
"}\n"
|
||
"\n"
|
||
"extern void object::Test( )\n"
|
||
"{\n"
|
||
"\tfloat value;\n"
|
||
"\tvalue = Srednia(2, 6);\n"
|
||
"\tmessage(value); // zwroci 4\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/function.txt:87
|
||
#, no-wrap
|
||
msgid "Some other examples:"
|
||
msgstr "Inne przykłady:"
|
||
|
||
#. type: Source code
|
||
#: ../E/function.txt:89
|
||
#, no-wrap
|
||
msgid ""
|
||
"float Pi()\n"
|
||
"{\n"
|
||
"\treturn 3.1415;\n"
|
||
"}\n"
|
||
"\n"
|
||
"string Sign(float a)\n"
|
||
"{\n"
|
||
"\tif (a > 0) return \"positive\";\n"
|
||
"\tif (a < 0) return \"negative\";\n"
|
||
"\treturn \"null\";\n"
|
||
"}"
|
||
msgstr ""
|
||
"float Pi()\n"
|
||
"{\n"
|
||
"\treturn 3.1415;\n"
|
||
"}\n"
|
||
"\n"
|
||
"string Sign(float a)\n"
|
||
"{\n"
|
||
"\tif (a > 0) return \"dodatnia\";\n"
|
||
"\tif (a < 0) return \"ujemna\";\n"
|
||
"\treturn \"null\";\n"
|
||
"}"
|
||
|
||
#. type: \b; header
|
||
#: ../E/function.txt:102
|
||
#, no-wrap
|
||
msgid "Overloading"
|
||
msgstr "Przeciążanie funkcji"
|
||
|
||
#. type: Plain text
|
||
#: ../E/function.txt:103
|
||
#, no-wrap
|
||
msgid "You can declare several functions with the same name but different parameters:"
|
||
msgstr "Możesz zadeklarować kilka funkcji o tej samej nazwie, ale innych parametrach: "
|
||
|
||
#. type: Source code
|
||
#: ../E/function.txt:105
|
||
#, no-wrap
|
||
msgid ""
|
||
"float Pythagoras(float a, float b)\n"
|
||
"{\n"
|
||
"\treturn sqrt((a*a)+(b*b));\n"
|
||
"}\n"
|
||
"\n"
|
||
"float Pythagoras(float a, float b, float c)\n"
|
||
"{\n"
|
||
"\treturn sqrt((a*a)+(b*b)+(c*c));\n"
|
||
"}"
|
||
msgstr ""
|
||
"float Pitagoras(float a, float b)\n"
|
||
"{\n"
|
||
"\treturn sqrt((a*a)+(b*b));\n"
|
||
"}\n"
|
||
"\n"
|
||
"float Pitagoras(float a, float b, float c)\n"
|
||
"{\n"
|
||
"\treturn sqrt((a*a)+(b*b)+(c*c));\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/function.txt:115
|
||
#, no-wrap
|
||
msgid "CBOT will call either the one or the other function depending on the parameters passed. They must be distinguishable, i.e. you can't declare two functions with the same name and parameter types in the exact same order, e.g. declaring <code>int Pythagoras(float b, float a)</code> will result in error. Note that result type does not matter."
|
||
msgstr "CBOT wywoła jedną z funkcji w zależności od przekazanych parametrów. Funkcje muszą być odróżnialne, tzn. nie możesz zadeklarować dwóch funkcji o takiej samej nazwie i typach parametrów w tej samej kolejności. Odnosząc się do przykładu: zadeklarowanie funkcji <code>int Pythagoras(float b, float a)</code> wywoła błąd. Zwróć uwagę, że typ wyniku, jaki zwraca funkcja, nie ma znaczenia."
|
||
|
||
#. type: \b; header
|
||
#: ../E/function.txt:120
|
||
#, no-wrap
|
||
msgid "object::"
|
||
msgstr "object::"
|
||
|
||
#. type: Plain text
|
||
#: ../E/function.txt:121
|
||
#, no-wrap
|
||
msgid "Declaring a function as a part of the <a cbot|object>object</a> namespace gives it access to <code><a cbot|this>this</a></code> <a cbot|pointer>pointer</a>, in other words, to all available properties of the robot which the program is run on."
|
||
msgstr "Deklaracja funkcji w przestrzeni nazw <a cbot|object>object</a> daje jej dostęp do <a cbot|pointer>wskaźnika</a> <code><a cbot|this>this</a></code>. Innymi słowy, funkcja ma wtedy dostęp do wszystkich właściwości robota, na którym jest uruchomiona."
|
||
|
||
#. type: Source code
|
||
#: ../E/function.txt:123
|
||
#, no-wrap
|
||
msgid ""
|
||
"void object::Example()\n"
|
||
"{\n"
|
||
"\tmessage(this.category);\n"
|
||
"}"
|
||
msgstr ""
|
||
"void object::Przyklad()\n"
|
||
"{\n"
|
||
"\tmessage(this.category);\n"
|
||
"}"
|
||
|
||
#. type: Plain text
|
||
#: ../E/object.txt:2
|
||
#, no-wrap
|
||
msgid "Use this type for variables that contain the characteristics of an object, be it a bot, a building, some raw material, an enemy, etc. Here are all properties of an object: "
|
||
msgstr "Użyj tego typu dla zmiennych, które zawierają informacje o obiekcie, niezależnie od tego, czy jest to robot, budynek, materiał, przeciwnik itp. Obiekty mają następujące właściwości:"
|
||
|
||
#. type: Plain text
|
||
#: ../E/object.txt:4
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|int>int</a> object.category </code><a cbot|category>Category</a> of the object\n"
|
||
"<code><a cbot|point>point</a> object.position </code>Position of the object (x,y,z)\n"
|
||
"<code><a cbot|float>float</a> object.orientation </code>Orientation of the object (0..360)\n"
|
||
"<code><a cbot|float>float</a> object.pitch </code>Forward/backward angle of the object\n"
|
||
"<code><a cbot|float>float</a> object.roll </code>Right/left angle of the object \n"
|
||
"<code><a cbot|float>float</a> object.energyLevel </code>Energy level (0..1)\n"
|
||
"<code><a cbot|float>float</a> object.shieldLevel </code>Shield level (0..1)\n"
|
||
"<code><a cbot|float>float</a> object.temperature </code>Jet temperature (0..1)\n"
|
||
"<code><a cbot|float>float</a> object.altitude </code>Altitude above ground\n"
|
||
"<code><a cbot|float>float</a> object.lifeTime </code>Lifetime of the object\n"
|
||
"<code>object object.energyCell </code>Power cell on the bot\n"
|
||
"<code>object object.load </code>Object carried by the bot\n"
|
||
"<code><a cbot|int>int</a> object.team </code>The object's team (see <a battles>code battles</a>)\n"
|
||
"<code><a cbot|point>point</a> object.velocity </code>Velocity of the object"
|
||
msgstr ""
|
||
"<code><a cbot|int>int</a> object.category </code><a cbot|category>Kategoria</a> obiektu\n"
|
||
"<code><a cbot|point>point</a> object.position </code>Współrzędne obiektu (x,y,z)\n"
|
||
"<code><a cbot|float>float</a> object.orientation </code>Kierunek obiektu (0..360)\n"
|
||
"<code><a cbot|float>float</a> object.pitch </code>Pochylenie obiektu w przód lub w tył\n"
|
||
"<code><a cbot|float>float</a> object.roll </code>Pochylenie obiektu w lewo lub w prawo\n"
|
||
"<code><a cbot|float>float</a> object.energyLevel </code>Poziom energii (0..1)\n"
|
||
"<code><a cbot|float>float</a> object.shieldLevel </code>Poziom osłony (0..1)\n"
|
||
"<code><a cbot|float>float</a> object.temperature </code>Temperatura silnika (0..1)\n"
|
||
"<code><a cbot|float>float</a> object.altitude </code>Wysokość nad poziomem gruntu\n"
|
||
"<code><a cbot|float>float</a> object.lifeTime </code>Czas istnienia obiektu\n"
|
||
"<code>object object.energyCell </code>Ogniwo elektryczne robota\n"
|
||
"<code>object object.load </code>Obiekt trzymany przez robota\n"
|
||
"<code><a cbot|int>int</a> object.team </code>Drużyna, do której należy obiekt (zobacz <a battles>programobitwy</a>)\n"
|
||
"<code><a cbot|point>point</a> object.velocity </code>Prędkość obiektu"
|
||
|
||
#. type: Plain text
|
||
#: ../E/object.txt:19
|
||
#, no-wrap
|
||
msgid "Also, some objects have additional methods (instructions). See them in <a cbot>the main list</a> in the <c/>\"Instructions specific for some objects\" section."
|
||
msgstr "Niektóre obiekty mają dodatkowe metody (instrukcje). Możesz je sprawdzić w sekcji <c/>\"Instrukcje charakterystyczne dla pewnych obiektów\" <a cbot>główne listy obiektów</a> "
|
||
|
||
#. type: Plain text
|
||
#: ../E/object.txt:22
|
||
#, no-wrap
|
||
msgid "The <n/><a cbot|category>category</a> of an object allows you to know what it is, f. ex. what kind of bot, building, enemy, etc."
|
||
msgstr "<n/><a cbot|category>Kategoria</a> obiektu pozwala się się dowiedzieć, czym on jest, tzn. jaki to rodzaj robota, budynku, przeciwnika, itp."
|
||
|
||
#. type: Source code
|
||
#: ../E/object.txt:60
|
||
#, no-wrap
|
||
msgid "<code>team</code>"
|
||
msgstr "<code>team</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/object.txt:61
|
||
#, no-wrap
|
||
msgid "The bot's team. Used in <a battles>code battles</a>. If the object has no team assigned (e.g. in no team-based levels, the object being a resource), this is equal to <code>0</code>."
|
||
msgstr "Drużyna robota. Ma zastosowanie w <a battles>programobitwach</a>. Jeśli obiekt nie należy do żadnej drużyny (np. gdy obiektem jest surowiec lub gdy obecny poziom nie jest programobitwą), wartość ta jest równa <code>0</code>."
|
||
|
||
#. type: Source code
|
||
#: ../E/object.txt:63
|
||
#, no-wrap
|
||
msgid "<code>velocity</code>"
|
||
msgstr "<code>velocity</code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/object.txt:64
|
||
#, no-wrap
|
||
msgid "Current velocity of the object. Should be treated as a three-dimensional vector."
|
||
msgstr "Aktualna prędkość obiektu. Powinna być traktowana jako wektor w przestrzeni trójwymiarowej."
|
||
|
||
#. type: \b; header
|
||
#: ../E/pencolor.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>pencolor</code>"
|
||
msgstr "Instrukcja <code>pencolor</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/pencolor.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>pencolor ( color );<n/>"
|
||
msgstr "<c/>pencolor ( color );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/pencolor.txt:4
|
||
#, no-wrap
|
||
msgid "The instruction <c/>pencolor();<n/> instructs the bot to change the color of the pencil."
|
||
msgstr "Instrukcja <c/>pencolor();<n/> rozkazuje robotowi zmianę koloru pisaka."
|
||
|
||
#. type: \t; header
|
||
#: ../E/pencolor.txt:6 ../E/pendown.txt:6
|
||
#, no-wrap
|
||
msgid "color: <code><a cbot|int>int</a></code> (default value: <code>Black</code>)"
|
||
msgstr "kolor: <code><a cbot|int>int</a></code> (domyślna wartość: <code>Black</code> (czarny))"
|
||
|
||
#. type: Plain text
|
||
#: ../E/pencolor.txt:7 ../E/pendown.txt:7
|
||
#, no-wrap
|
||
msgid "<a cbot|colors>Color name</a>."
|
||
msgstr "<a cbot|colors>Nazwa koloru</a>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/pencolor.txt:10
|
||
#, no-wrap
|
||
msgid ""
|
||
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <c/>pencolor();<n/>.\n"
|
||
"<code>== 0 </code>The color was changed\n"
|
||
"<code>!= 0 </code>The instruction did not work"
|
||
msgstr ""
|
||
"Z reguły po wywołaniu błędu program zatrzymuje się. Możesz temu zapobiec, wykorzystując instrukcję <code><a cbot|errmode>errmode</a>(0)</code>. Jeśli wystąpi błąd, funkcja <code>pencolor()</code> zwróci wartość różną od zera.\n"
|
||
"<code>== 0 </code>Kolor został zmieniony\n"
|
||
"<code>!= 0 </code>Nie udało się wykonać instrukcji"
|
||
|
||
#. type: \b; header
|
||
#: ../E/pendown.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>pendown</code>"
|
||
msgstr "Instrukcja <code>pendown</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/pendown.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>pendown ( color, width );<n/>"
|
||
msgstr "<c/>pendown ( kolor, grubosc );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/pendown.txt:4
|
||
#, no-wrap
|
||
msgid "The instruction <c/>pendown();<n/> instructs the bot to have the pen down, so it starts drawing."
|
||
msgstr "Instrukcja <c/>pendown();<n/> rozkazuje robotowi opuścić pisak, aby mógł rysować."
|
||
|
||
#. type: \t; header
|
||
#: ../E/pendown.txt:9
|
||
#, no-wrap
|
||
msgid "width: <code><a cbot|float>float</a></code> (default value: <code>0.5</code>)"
|
||
msgstr "grubosc: <code><a cbot|float>float</a></code> (domyślna wartość: <code>0.5</code>)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/pendown.txt:10 ../E/penwidth.txt:7
|
||
#, no-wrap
|
||
msgid "Width of the pen. The width cannot be higher than <code>1.0</code> and cannot be lower than <code>0.0</code>. Passing a higher value will result in the width being the highest possible and passing a lower value will result in the width being the lowest possible."
|
||
msgstr "Grubość pisaka. Nie może być większa od <code>1.0</code> i mniejsza od <code>0.0</code>. Przekazanie większej wartości spowoduje, że pisak będzie najgrubszy, a mniejszej - że będzie najcieńszy. "
|
||
|
||
#. type: Plain text
|
||
#: ../E/pendown.txt:13
|
||
#, no-wrap
|
||
msgid ""
|
||
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <c/>pendown();<n/>.\n"
|
||
"<code>== 0 </code>The pen is now down\n"
|
||
"<code>!= 0 </code>The instruction did not work"
|
||
msgstr ""
|
||
"Z reguły po wywołaniu błędu program zatrzymuje się. Możesz temu zapobiec, wykorzystując instrukcję <code><a cbot|errmode>errmode</a>(0)</code>. Jeśli wystąpi błąd, funkcja <code>pendown()</code> zwróci wartość różną od zera.\n"
|
||
"<code>== 0 </code>Pisak został opuszczony\n"
|
||
"<code>!= 0 </code>Nie udało się wykonać instrukcji"
|
||
|
||
#. type: \b; header
|
||
#: ../E/penup.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>penup</code>"
|
||
msgstr "instrukcja <code>penup</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/penup.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>penup ( );<n/>"
|
||
msgstr "<c/>penup ( );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/penup.txt:4
|
||
#, no-wrap
|
||
msgid "The instruction <c/>penup();<n/> instructs the bot to have the pen up, so it stops drawing. The pen is up by default, so it should be used only after using <code><a cbot|pendown>pendown</a></code>."
|
||
msgstr "Instrukcja <c/>penup();<n/> rozkazuje robotowi podniesienie pisaka, aby już nie rysował. Pisak jest domyślnie podniesiony, więc instrukcja ta powinna być używana tylko po wcześniejszym wywołaniu instrukcji <code><a cbot|pendown>pendown</a></code>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/penup.txt:7
|
||
#, no-wrap
|
||
msgid ""
|
||
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <c/>penup();<n/>.\n"
|
||
"<code>== 0 </code>The pen is now up\n"
|
||
"<code>!= 0 </code>The instruction did not work"
|
||
msgstr ""
|
||
"Z reguły po wywołaniu błędu program zatrzymuje się. Możesz temu zapobiec, wykorzystując instrukcję <code><a cbot|errmode>errmode</a>(0)</code>. Jeśli wystąpi błąd, funkcja <code>penup()</code> zwróci wartość różną od zera.\n"
|
||
"<code>== 0 </code>Pisak jest podniesiony\n"
|
||
"<code>!= 0 </code>Instrukcja nie została wykonana"
|
||
|
||
#. type: \b; header
|
||
#: ../E/penwidth.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>penwidth</code>"
|
||
msgstr "Instrukcja <code>penwidth</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/penwidth.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>penwidth ( color );<n/>"
|
||
msgstr "<c/>penwidth ( kolor );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/penwidth.txt:4
|
||
#, no-wrap
|
||
msgid "The instruction <c/>penwidth();<n/> instructs the bot to change the width of the pencil."
|
||
msgstr "Instrukcja <c/>penwidth();<n/> rozkazuje robotowi zmianę grubości pisaka."
|
||
|
||
#. type: \t; header
|
||
#: ../E/penwidth.txt:6
|
||
#, no-wrap
|
||
msgid "width: <code><a cbot|float>float</a></code>"
|
||
msgstr "width: <code><a cbot|float>float</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/penwidth.txt:10
|
||
#, no-wrap
|
||
msgid ""
|
||
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <c/>penwidth();<n/>.\n"
|
||
"<code>== 0 </code>The width was changed\n"
|
||
"<code>!= 0 </code>The instruction did not work"
|
||
msgstr ""
|
||
"Z reguły po wywołaniu błędu program zatrzymuje się. Możesz temu zapobiec, wykorzystując instrukcję <code><a cbot|errmode>errmode</a>(0)</code>. Jeśli wystąpi błąd, funkcja <code>penwidth()</code> zwróci wartość różną od zera.\n"
|
||
"<code>== 0 </code>Zmieniono grubość\n"
|
||
"<code>!= 0 </code>Nie udało się wykonać instrukcji"
|
||
|
||
#. type: \b; header
|
||
#: ../E/pow.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>pow</code>"
|
||
msgstr "Instrukcja <code>pow</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/pow.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>pow ( x, y );<n/>"
|
||
msgstr "<c/>pow ( x, y );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/pow.txt:6
|
||
#, no-wrap
|
||
msgid "Base."
|
||
msgstr "Podstawa."
|
||
|
||
#. type: Plain text
|
||
#: ../E/pow.txt:9
|
||
#, no-wrap
|
||
msgid "Exponent."
|
||
msgstr "Wykładnik."
|
||
|
||
#. type: Plain text
|
||
#: ../E/pow.txt:12
|
||
#, no-wrap
|
||
msgid "x to the y (x raised to the yth power)."
|
||
msgstr "x do y-tej (x podniesione do potęgi y)"
|
||
|
||
#. type: Source code
|
||
#: ../E/radar.txt:15
|
||
#, no-wrap
|
||
msgid "<c/>radar ( cat, angle, focus, min, max, sens, filter );<n/>"
|
||
msgstr "<c/>radar ( kategoria, kat, focus, min, max, sens, filtr );<n/>"
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/radar.txt:24
|
||
#, no-wrap
|
||
msgid "<a cbot|array>Array</a> of categories of the objects that should be detected. For example, when you are looking only for grabbers:"
|
||
msgstr "<a cbot|array>Tablica</a> kategorii obiektów, które mają być wykryte. Na przykład, jeśli szukasz tylko transporterów:"
|
||
|
||
#. type: Plain text
|
||
#: ../E/radar.txt:25 ../E/search.txt:10
|
||
#, no-wrap
|
||
msgid "<c/><s/>int bots[4];"
|
||
msgstr "<c/><s/>int bots[4];"
|
||
|
||
#. type: Source code
|
||
#: ../E/radar.txt:26
|
||
#, no-wrap
|
||
msgid ""
|
||
"bots[0] = WheeledGrabber;\n"
|
||
"bots[1] = TrackedGrabber;\n"
|
||
"bots[2] = WingedGrabber;\n"
|
||
"bots[3] = LeggedGrabber;\n"
|
||
"object nearestGrabber = radar(bots);<n/>"
|
||
msgstr ""
|
||
"bots[0] = WheeledGrabber;\n"
|
||
"bots[1] = TrackedGrabber;\n"
|
||
"bots[2] = WingedGrabber;\n"
|
||
"bots[3] = LeggedGrabber;\n"
|
||
"object nearestGrabber = radar(bots);<n/>"
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/radar.txt:31
|
||
#, no-wrap
|
||
msgid "Keyword <format const>Any</format> if you are looking for any object (including even plants and so on). Filters may be useful to use with this keyword."
|
||
msgstr "Użyj słowa <format const>Any</format>, jeśli szukasz dowolnego obiektu (wliczając w to rośliny itp.). Może się to przydać przy tworzeniu filtrów."
|
||
|
||
#. type: \t; header
|
||
#: ../E/radar.txt:33
|
||
#, no-wrap
|
||
msgid "angle: <code><a cbot|float>float</a></code> (default value: <code>0</code>)"
|
||
msgstr "kat: <code><a cbot|float>float</a></code> (domyślna wartość: <code>0</code>)"
|
||
|
||
#. type: \t; header
|
||
#: ../E/radar.txt:39
|
||
#, no-wrap
|
||
msgid "focus: <code><a cbot|float>float</a></code> (default value: <code>360</code>)"
|
||
msgstr "focus: <code><a cbot|float>float</a></code> (domyślna wartość: <code>360</code>)"
|
||
|
||
#. type: \t; header
|
||
#: ../E/radar.txt:42
|
||
#, no-wrap
|
||
msgid "min: <code><a cbot|float>float</a></code> (default value: <code>0</code>)"
|
||
msgstr "min: <code><a cbot|float>float</a></code> (default value: <code>0</code>)"
|
||
|
||
#. type: \t; header
|
||
#: ../E/radar.txt:45
|
||
#, no-wrap
|
||
msgid "max: <code><a cbot|float>float</a></code> (default value: <code>1000</code>)"
|
||
msgstr "max: <code><a cbot|float>float</a></code> (domyślna wartość: <code>1000</code>)"
|
||
|
||
#. type: \t; header
|
||
#: ../E/radar.txt:48
|
||
#, no-wrap
|
||
msgid "sens: <code><a cbot|float>float</a></code> (default value: <code>1</code>)"
|
||
msgstr "sens: <code><a cbot|float>float</a></code> (domyślna wartość: <code>1</code>)"
|
||
|
||
#. type: \t; header
|
||
#: ../E/radar.txt:51
|
||
#, no-wrap
|
||
msgid "filter: <code><a cbot|int>int</a></code> (default value: <code><format const>FilterNone</format></code>)"
|
||
msgstr "filtr: <code><a cbot|int>int</a></code> (domyślna wartość: <code><format const>FilterNone</format></code>)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/radar.txt:52
|
||
#, no-wrap
|
||
msgid "Determines which type of objects should be detected. Especially useful in use with an <a cbot|array>array</a> or <format const>Any</format>. The following filters are available:"
|
||
msgstr "Określa, które typy obiektów powinny być wykrywalne. Szczególnie użyteczne przy używaniu razem z <a cbot|array>tablicami</a> lub słowem <format const>Any</format>. Dostępne są następujące filtry:"
|
||
|
||
#. type: Plain text
|
||
#: ../E/radar.txt:54
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><format const>FilterNone</format> </code>Detects everything (default)\n"
|
||
"<code><format const>FilterOnlyLanding</format> </code>Detects only objects being on the ground\n"
|
||
"<code><format const>FilterOnlyFlying</format> </code>Detects only objects not being on the ground\n"
|
||
"<code><format const>FilterFriendly</format> </code>Detects only allies (objects in the same team)\n"
|
||
"<code><format const>FilterEnemy</format> </code>Detects only enemies (objects in an other team except neutral)\n"
|
||
"<code><format const>FilterNeutral</format> </code>Detects only neutral objects (e.g. resources)"
|
||
msgstr ""
|
||
"<code><format const>FilterNone</format> </code>Wykrywa wszystko (domyślna wartość)\n"
|
||
"<code><format const>FilterOnlyLanding</format> </code>Wykrywa tylko obiekty znajdujące się na ziemi\n"
|
||
"<code><format const>FilterOnlyFlying</format> </code>Wykrywa tylko obiekty nieznajdujące się na ziemi\n"
|
||
"<code><format const>FilterFriendly</format> </code>Wykrywa tylko sojuszników (obiekty z tej samej drużyny)\n"
|
||
"<code><format const>FilterEnemy</format> </code>Wykrywa tylko przeciwników (obiekty z innej drużyny, bez obiektów neutralnych)\n"
|
||
"<code><format const>FilterNeutral</format> </code>Wykrywa tylko obiekty neutralne (np. surowce)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/radar.txt:61
|
||
#, no-wrap
|
||
msgid "The last three are mainly useful in <a battles>code battles</a>. You can also pass a team ID to search only for objects from a specific team. Attention: you should use <format const>FilterNeutral</format> instead of <code>0</code> or else it will not work."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/radar.txt:63
|
||
#, no-wrap
|
||
msgid "Filters and IDs can be mixed using bitwise OR operator <code>|</code>, for example <c/>radar(Any, 0, 360, 0, 1000, 1, 2 | FilterOnlyLanding);<n/> will only detect an object from team <code>2</code> that is on the ground. Attention: you can specify only one team ID at once, but you can specify several filters at once."
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/rand.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>rand</code>"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/rand.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>rand ( );<n/>"
|
||
msgstr "<c/>rand ( );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/rand.txt:6
|
||
#, no-wrap
|
||
msgid "Pseudorandom number between 0 and 1 (including 0, but excluding 1)."
|
||
msgstr "Pseudolosowa liczba od 0 do 1 (włączając w to 0, ale bez 1)."
|
||
|
||
#. type: \b; header
|
||
#: ../E/research.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>research</code>"
|
||
msgstr "Instrukcja <code>research</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/research.txt:3
|
||
#, no-wrap
|
||
msgid "<c/><a cbot|object>object</a>.research ( type );<n/>"
|
||
msgstr "<c/><a cbot|object>object</a>.research ( typ );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/research.txt:5
|
||
#, no-wrap
|
||
msgid "Starts a <a cbot|researches>research</a> of the given type."
|
||
msgstr "Rozpoczyna <a cbot|researches>badanie</a> danego typu."
|
||
|
||
#. type: Plain text
|
||
#: ../E/research.txt:8
|
||
#, no-wrap
|
||
msgid "<a object|research>ResearchCenter</a> or <a object|labo>AutoLab</a>."
|
||
msgstr "<a object|research>Centrum badawcze</a> lub <a object|labo>laboratorium</a>."
|
||
|
||
#. type: \t; header
|
||
#: ../E/research.txt:10
|
||
#, no-wrap
|
||
msgid "type: <code><a cbot|int>int</a></code>"
|
||
msgstr "typ: <code><a cbot|int>int</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/research.txt:14
|
||
#, no-wrap
|
||
msgid ""
|
||
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <code>research()</code>.\n"
|
||
"<code>== 0 </code>The research successfully started\n"
|
||
"<code>!= 0 </code>The research could not be started (e.g. the research is disabled in the level, no power cell)"
|
||
msgstr ""
|
||
"Z reguły po wywołaniu błędu program zatrzymuje się. Możesz temu zapobiec, wykorzystując instrukcję <code><a cbot|errmode>errmode</a>(0)</code>. Jeśli wystąpi błąd, funkcja <code>research()</code> zwróci wartość różną od zera.\n"
|
||
"<code>== 0 </code>Prace badawcze zostały pomyślnie rozpoczęte\n"
|
||
"<code>!= 0 </code>Nie udało się rozpocząć prac badawczych (np. wybrana technologia jest zablokowana na tym poziomie, nie ma ogniwa elektrycznego)"
|
||
|
||
#. type: Plain text
|
||
#: ../E/research.txt:19
|
||
#, no-wrap
|
||
msgid "<a cbot|researches>Research names</a>, <a cbot|canresearch>canresearch</a>, <a cbot|researched>researched</a>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/researched.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>researched</code>"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/researched.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>researched ( research );<n/>"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/researched.txt:5
|
||
#, no-wrap
|
||
msgid "Checks if the <a cbot|researches>research</a> was done in the level."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/researched.txt:11
|
||
#, no-wrap
|
||
msgid ""
|
||
"<format const>true</format> if the research was done\n"
|
||
"<format const>false</format> if the research was not done"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/researched.txt:15
|
||
#, no-wrap
|
||
msgid "<a cbot|researches>Research names</a>, <a cbot|research>research</a>, <a cbot|canresearch>canresearch</a>, <a cbot|canbuild>canbuild</a> <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/researches.txt:1
|
||
#, no-wrap
|
||
msgid "Value <code>Research names</code>"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/researches.txt:2
|
||
#, no-wrap
|
||
msgid "Research names represent the types of available researches in the CBOT language. You can use them to control <a object|research>ResearchCenter</a> by passing them to appropriate instructions (e.g. <a cbot|research>research</a>, <a cbot|canresearch>canresearch</a>, <a cbot|researched>researched</a>)."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/researches.txt:4
|
||
#, no-wrap
|
||
msgid "In a program, research names are always displayed on a <format const>red background</format>. If a research name is not highlighted in red, it is misspelled. Caps and lower cases should be kept as is."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/researches.txt:6
|
||
#, no-wrap
|
||
msgid "Below are the different research names available."
|
||
msgstr ""
|
||
|
||
#. type: \t; header
|
||
#: ../E/researches.txt:8
|
||
#, no-wrap
|
||
msgid "Done by <a object|research>ResearchCenter</a>:"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/researches.txt:9
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><format const>ResearchTracked</format> </code>Tracked bots (e.g. <a object|botgc>tracked grabber</a>)\n"
|
||
"<code><format const>ResearchWinged</format> </code>Winged bots (e.g. <a object|botgj>winged grabber</a>)\n"
|
||
"<code><format const>ResearchShooter</format> </code>Bots with cannon (e.g. <a object|botfc>tracked shooter</a>)\n"
|
||
"<code><format const>ResearchPhazerShooter</format> </code><a object|botphaz>Phazer shooter</a>\n"
|
||
"<code><format const>ResearchThumper</format> </code><a object|bottump>Thumper</a>\n"
|
||
"<code><format const>ResearchShielder</format> </code><a object|botshld>Shielder</a>\n"
|
||
"<code><format const>ResearchDefenseTower</format> </code><a object|tower>Defense tower</a>\n"
|
||
"<code><format const>ResearchNuclearPlant</format> </code><a object|nuclear>Nuclear plant</a>"
|
||
msgstr ""
|
||
|
||
#. type: \t; header
|
||
#: ../E/researches.txt:18
|
||
#, no-wrap
|
||
msgid "Done by <a object|labo>AutoLab</a>:"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/researches.txt:19
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><format const>ResearchLegged</format> </code>Legged bots (e.g. <a object|botgs>legged grabber</a>)\n"
|
||
"<code><format const>ResearchOrgaShooter</format> </code>Bots with orgaball cannon (e.g. <a object|botoc>tracked orga shooter</a>)"
|
||
msgstr ""
|
||
|
||
#. type: \t; header
|
||
#: ../E/researches.txt:22
|
||
#, no-wrap
|
||
msgid "Impossible to research:"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/researches.txt:23
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><format const>ResearchSniffer</format> </code>Sniffers (e.g. <a object|botsc>tracked sniffer</a>)\n"
|
||
"<code><format const>ResearchSubber</format> </code><a object|botsub>Subber</a>\n"
|
||
"<code><format const>ResearchRecycler</format> </code><a object|botrecy>Recycler</a>"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/researches.txt:28
|
||
#, no-wrap
|
||
msgid "<a cbot>CBOT Language</a>, <a cbot|type>variables</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/round.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>round</code>"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/round.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>round ( value );<n/>"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/round.txt:4
|
||
#, no-wrap
|
||
msgid "Rounds a number."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/round.txt:10
|
||
#, no-wrap
|
||
msgid "Rounded <code>value</code>. For example, <code>round(2.5)</code> is <code>3.0</code>, whereas <code>round(2.4)</code> is <code>2.0</code>."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/round.txt:13
|
||
#, no-wrap
|
||
msgid "<a cbot|trunc>trunc</a>, <a cbot|floor>floor</a>, <a cbot|ceil>ceil</a>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|expr>expressions</a>."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/search.txt:5
|
||
#, no-wrap
|
||
msgid "Detects the object of the given category that is closest to the given position. Similar to <c/><a cbot|radar>radar();</a><n/>, but can search starting from the specific point instead of the actual bot's position."
|
||
msgstr ""
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/search.txt:8
|
||
#, no-wrap
|
||
msgid "<a cbot|category>Category</a> of the objects that should be detected. For example, when you are looking for an ant, write <code>search(AlienAnt)</code>. "
|
||
msgstr ""
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/search.txt:9
|
||
#, no-wrap
|
||
msgid "<a cbot|array>Array</a> of categories of the objects that should be detected. For example, when you are looking only for grabbers, starting from a certain point in the level:"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/search.txt:11
|
||
#, no-wrap
|
||
msgid ""
|
||
"bots[0] = WheeledGrabber;\n"
|
||
"bots[1] = TrackedGrabber;\n"
|
||
"bots[2] = WingedGrabber;\n"
|
||
"bots[3] = LeggedGrabber;\n"
|
||
"point p(50, 24, 0);\n"
|
||
"object grabberNearestThePoint = search(bots, p);<n/>"
|
||
msgstr ""
|
||
|
||
#. type: \t; header
|
||
#: ../E/search.txt:19
|
||
#, no-wrap
|
||
msgid "position: <code><a cbot|point>point</a></code> (default value: <code><a cbot|this>this</a>.<a cbot|object>position</a></code>)"
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/sin.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>sin</code>"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/sin.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>sin ( angle );<n/>"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/sin.txt:9
|
||
#, no-wrap
|
||
msgid "Sine of the angle."
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/sqrt.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>sqrt</code>"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/sqrt.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>sqrt ( value );<n/>"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/sqrt.txt:6
|
||
#, no-wrap
|
||
msgid "Non-negative number."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/sqrt.txt:9
|
||
#, no-wrap
|
||
msgid "Square root of the value."
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/switch.txt:1
|
||
#, no-wrap
|
||
msgid "Instructions <code>switch</code>, <code>case</code> and <code>default</code>"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/switch.txt:2
|
||
#, no-wrap
|
||
msgid "With the instruction <code>switch() {}</code> you can execute a proper set of instructions (a case) basing on some value."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/switch.txt:5
|
||
#, no-wrap
|
||
msgid "Note: the <a cbot|busy>busy</a> instruction might be much better to use in this scenario."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/switch.txt:7
|
||
#, no-wrap
|
||
msgid "See the following <a cbot|function>function</a>: the bot will be <a cbot|wait>waiting</a> a proper amount of time for a certain task to be completed:"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/switch.txt:9
|
||
#, no-wrap
|
||
msgid ""
|
||
"public void WaitForTaskCompleted(object building)\n"
|
||
"{\n"
|
||
"\tint cat = building.category;\n"
|
||
"\t<a cbot|if>if</a> (cat == Converter) wait(15);\n"
|
||
"\telse if (cat == BotFactory) wait(15);\n"
|
||
"\telse if (cat == PowerPlant) wait(12);\n"
|
||
"\telse message(\"Undefined wait time\", DisplayError);\n"
|
||
"}"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/switch.txt:18
|
||
#, no-wrap
|
||
msgid "This function can be also written using the <code>switch() {}</code> instruction:"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/switch.txt:20
|
||
#, no-wrap
|
||
msgid ""
|
||
"public void WaitForTaskCompleted(object building)\n"
|
||
"{\n"
|
||
"\tswitch (building.category)\n"
|
||
"\t{\n"
|
||
"\t\tcase Converter: wait(15); break;\n"
|
||
"\t\tcase BotFactory: wait(15); break;\n"
|
||
"\t\tcase PowerPlant: wait(12); break;\n"
|
||
"\t\tdefault: message(\"Undefined wait time\", DisplayError);\n"
|
||
"\t}\n"
|
||
"}"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/switch.txt:31
|
||
#, no-wrap
|
||
msgid "Which way to write this kind of choice structures, is a matter of taste."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/switch.txt:33
|
||
#, no-wrap
|
||
msgid "You can also make cases like this:"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/switch.txt:35
|
||
#, no-wrap
|
||
msgid ""
|
||
"switch (building.category)\n"
|
||
"{\n"
|
||
"\tcase Converter:\n"
|
||
"\tcase BotFactory:\n"
|
||
"\t\twait(15); break;\n"
|
||
"\tcase PowerPlant: wait(12); break;\n"
|
||
"\tdefault: message(\"Undefined wait time\", DisplayError);\n"
|
||
"}"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/switch.txt:44
|
||
#, no-wrap
|
||
msgid "<a object|convert>Converter</a> and <a object|factory>bot factory</a> have the same waiting time, so in order to not write the same instructions twice, we made multiple cases run the same code. In fact, all code after the highest case used will be executed if we do not <code><a cbot|break>break</a></code> it."
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/switch.txt:48
|
||
#, no-wrap
|
||
msgid ""
|
||
"<c/>switch ( value )\n"
|
||
"{\n"
|
||
"\tcase value1: instructions1\n"
|
||
"\tcase value2: instructions2\n"
|
||
"\t...\n"
|
||
"\tcase valueN: instructionsN\n"
|
||
"\tdefault: instructionsDefault\n"
|
||
"}"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/switch.txt:57
|
||
#, no-wrap
|
||
msgid "With this conditional structure you can execute <code>instructions1</code> or <code>instructions2</code> ... or <code>instructionsN</code> or <code>instructionsDefault</code> depending on the <code>value</code>."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/switch.txt:59
|
||
#, no-wrap
|
||
msgid ""
|
||
"If the <code>value</code> is equal to <code>value1</code>, <code>instructions1</code> to <code>N</code> (including <code>instructionsDefault</code>) are executed.\n"
|
||
"If the <code>value</code> is equal to <code>value2</code>, <code>instructions2</code> to <code>N</code> (including <code>instructionsDefault</code>) are executed.\n"
|
||
"And so on.\n"
|
||
"If the <code>value</code> is equal to <code>valueN</code>, <code>instructionsN</code> and <code>instructionsDefault</code> are executed.\n"
|
||
"If the <code>value</code> is not equal to any value in the given cases, <code>instructionsDefault</code> are executed."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/switch.txt:65
|
||
#, no-wrap
|
||
msgid "You can exit from the the <code>switch() {}</code> instruction using <code><a cbot|break>break</a></code>."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/switch.txt:68
|
||
#, no-wrap
|
||
msgid "Do not put a <a cbot|term>semicolon</a> at the end of the <code>switch ( ) { }</code> instruction."
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/takeoff.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>takeoff</code>"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/takeoff.txt:3
|
||
#, no-wrap
|
||
msgid "<c/><a cbot|object>object</a>.takeoff ( );<n/>"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/takeoff.txt:5
|
||
#, no-wrap
|
||
msgid "Takes off the spaceship."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/takeoff.txt:8
|
||
#, no-wrap
|
||
msgid "<a object|base>SpaceShip</a>"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/takeoff.txt:11
|
||
#, no-wrap
|
||
msgid ""
|
||
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <code>takeoff()</code>.\n"
|
||
"<code>== 0 </code>Spaceship takes off\n"
|
||
"<code>!= 0 </code>Spaceship could not take off (e.g. mission is not finished yet)"
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/tan.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>tan</code>"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/tan.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>tan ( angle );<n/>"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/tan.txt:6
|
||
#, no-wrap
|
||
msgid "Angle in degrees (except multiples of 90)."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/tan.txt:9
|
||
#, no-wrap
|
||
msgid "Tangent of the angle."
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/trunc.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>trunc</code>"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/trunc.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>trunc ( value );<n/>"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/trunc.txt:4
|
||
#, no-wrap
|
||
msgid "Truncation is a method of approximating a decimal number by dropping all decimal places past a certain point without rounding. For positive numbers, it works like the <c/><a cbot|floor>floor();</a><n/> function, and for negative numbers, it works like the <c/><a cbot|ceil>ceil();</a><n/> function. It can be said that it rounds towards zero."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/trunc.txt:10
|
||
#, no-wrap
|
||
msgid "Truncated <code>value</code>. For example, <code>trunc(-2.5)</code> is <code>-2.00</code>."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/category.txt:4
|
||
#, no-wrap
|
||
msgid "In a program, categories are always displayed like that: <format const>category</format>. If a category isn't highlighted, it is misspelled. Caps and lower cases should be kept as is."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/type.txt:9
|
||
#, no-wrap
|
||
msgid "In a program, the name of a type is always displayed like that: <format type>type</format>. If the name of a type is not highlighted, this means that the name is misspelled. Type names are always written with lower case characters. Here is a list of the different types: "
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/produce.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>produce</code>"
|
||
msgstr "Instrukcja <code>produce</code>"
|
||
|
||
#. type: Source code
|
||
#: ../E/produce.txt:3
|
||
#, no-wrap
|
||
msgid "<c/>produce ( position, orientation, category, program, power );<n/>"
|
||
msgstr "<c/>produce ( pozycja, kierunek, kategoria, program, moc );<n/>"
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/produce.txt:4
|
||
#, no-wrap
|
||
msgid "r"
|
||
msgstr "r"
|
||
|
||
#. type: Source code
|
||
#: ../E/produce.txt:5
|
||
#, no-wrap
|
||
msgid "<c/>produce ( category, power );<n/>"
|
||
msgstr "<c/>produce ( kategoria, moc );<n/>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/produce.txt:7
|
||
#, no-wrap
|
||
msgid "Immediately creates an <a cbot|category>object</a>."
|
||
msgstr "Natychmiastowo tworzy <a cbot|category>obiekt</a>."
|
||
|
||
#. type: \t; header
|
||
#: ../E/produce.txt:12
|
||
#, no-wrap
|
||
msgid "orientation: <code><a cbot|float>float</a></code>"
|
||
msgstr "kierunek: <code><a cbot|float>float</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/produce.txt:13
|
||
#, no-wrap
|
||
msgid "Orientation (angle) of the object."
|
||
msgstr "Kierunek (wyrażony kątem) ustawienia obiektu."
|
||
|
||
#. type: Plain text
|
||
#: ../E/produce.txt:16
|
||
#, no-wrap
|
||
msgid "<a cbot|category>Category</a> of the object."
|
||
msgstr "<a cbot|category>Kategoria</a> obiektu."
|
||
|
||
#. type: \t; header
|
||
#: ../E/produce.txt:18
|
||
#, no-wrap
|
||
msgid "program: <code><a cbot|string>string</a></code>"
|
||
msgstr "program: <code><a cbot|string>string</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/produce.txt:22
|
||
#, no-wrap
|
||
msgid "Energy level."
|
||
msgstr "Poziom energii."
|
||
|
||
#. type: \t; header
|
||
#: ../E/produce.txt:24
|
||
#, no-wrap
|
||
msgid "Return: <code><a cbot|void>void</a></code>"
|
||
msgstr "Zwraca: <code><a cbot|void>void</a></code>"
|
||
|
||
#. type: Plain text
|
||
#: ../E/produce.txt:25
|
||
#, no-wrap
|
||
msgid "Nothing."
|
||
msgstr "Nic."
|
||
|
||
#. type: \b; header
|
||
#: ../E/produce.txt:27
|
||
#, no-wrap
|
||
msgid "Example usage"
|
||
msgstr "Przykładowe użycie: "
|
||
|
||
#. type: Plain text
|
||
#: ../E/produce.txt:28
|
||
#, no-wrap
|
||
msgid "It is used by <a object|mother>AlienQueen</a> to produce <a object|egg>AlienEggs</a>."
|
||
msgstr "Jest używane przez <a object|mother>królową</a> do produkowania <a object|egg>jaj obcych</a>."
|
||
|
||
#. type: Plain text
|
||
#: ../E/produce.txt:10
|
||
#, no-wrap
|
||
msgid "Where object will be created. The second syntax creates the object at the current bot's position."
|
||
msgstr "Gdzie obiekt ma zostać stworzony. Druga sposób zapisu tworzy go w miejscu robota."
|
||
|
||
#. type: Plain text
|
||
#: ../E/produce.txt:19
|
||
#, no-wrap
|
||
msgid "Program for the object. Will have effect only for programmable objects like robots or aliens."
|
||
msgstr "Program dla obiektu. Ma zastosowanie tylko przy obiektach, które można zaprogramować, tzn. robotach i obcych."
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:2
|
||
#, no-wrap
|
||
msgid "Expressions are used for various calculations with many different variables, which return the desired result. What distinguishes them from standard instructions are operators, which are described below."
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/expr.txt:8
|
||
#, no-wrap
|
||
msgid "Binary operations"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:9
|
||
#, no-wrap
|
||
msgid "Assuming that <code>a</code>, <code>b</code> can be values of declared and initialized variables of types <code>t1</code> and <code>t2</code>, the binary operations can be described as follows:"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/expr.txt:10
|
||
#, no-wrap
|
||
msgid "<code>r = a op b</code>"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:11
|
||
#, no-wrap
|
||
msgid "Where <code>r</code> is the result of the operation and <code>op</code> is a binary operator which works with values of types <code>t1</code> and <code>t2</code>."
|
||
msgstr ""
|
||
|
||
#. type: \t; header
|
||
#: ../E/expr.txt:13
|
||
#, no-wrap
|
||
msgid "Order of operations"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:14
|
||
#, no-wrap
|
||
msgid "Let <code>a op1 b op2 c</code> be a legal expression, then the following rules apply:"
|
||
msgstr ""
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/expr.txt:15
|
||
#, no-wrap
|
||
msgid "If <code>op1 == op2</code> or <code>op1</code> is as strong as <code>op2</code> or <code>op1</code> is stronger than <code>op2</code>, first calculate <code>a op1 b</code> and store its result in a temporary variable <code>r</code>, then calculate <code>r op2 c</code>, which is the final result of the expression."
|
||
msgstr ""
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/expr.txt:16
|
||
#, no-wrap
|
||
msgid "If <code>op1</code> is weaker than <code>op2</code>, first calculate <code>b op2 c</code> and store its result in a temporary variable <code>r</code>, then calculate <code>a op1 r</code>, which is the final result of the expression."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:18
|
||
#, no-wrap
|
||
msgid "Note: an operation can be made stronger by surrounding it in brackets, so for example assuming that <code>op1</code> is weaker than <code>op2</code>, in an expression <code>(a op1 b) op2 c</code> the <code>a op1 b</code> operation will be executed first."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:20
|
||
#, no-wrap
|
||
msgid "Tip: always use brackets if you are not sure about the order of operations, do not try to remember how strong are each of the operators. Generally it should be fairly obvious."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:22
|
||
#, no-wrap
|
||
msgid ""
|
||
"Here is a complicated example, which uses arithemtic operations described below, showing how expressions are calculated:\n"
|
||
"<c/>Assume a, b, c, d, x, y, z, e are all initialized variables of type float or int. Then the following expression should be calculated the following way:\n"
|
||
" a * b + c - d / x % (y * z) - e =\n"
|
||
"= r1 + c - d / x % (y * z) - e = , r1 = a * b\n"
|
||
"= r2 - d / x % (y * z) - e = , r2 = r1 + c\n"
|
||
"= r2 - r3 % (y * z) - e = , r3 = d / x\n"
|
||
"= r2 - r3 % r4 - e = , r4 = y * z\n"
|
||
"= r2 - r5 - e = , r5 = r3 % r4\n"
|
||
"= r6 - e = , r6 = r2 - r5\n"
|
||
"= r7 , r7 = r6 - e\n"
|
||
"r7 is the final result of this expression."
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/expr.txt:35
|
||
#, no-wrap
|
||
msgid "Assignment operator"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:36
|
||
#, no-wrap
|
||
msgid "<code>=</code> is the assignment operator. It is used to store the result of an expression in a variable."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:38
|
||
#, no-wrap
|
||
msgid "On the left side of this operator there must be so called l-value and on the right side - r-value. L-values are just <a cbot|var>variables</a><n/>, r-values are expressions or just usual values. This makes the assignment operator kind of special, because what is l-value is pretty restrictive (it cannot be an expression, constant and so on, only single variable). Also, the type of l-value must match the type of r-value (unless a conversion is possible, for example assigning a <code><a cbot|float>float</a></code> to <code><a cbot|int>int</a></code>)."
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/expr.txt:42
|
||
#, no-wrap
|
||
msgid ""
|
||
" float a;\n"
|
||
" float b = 2.0 * (a = 4.0); // b == 8.0"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:45
|
||
#, no-wrap
|
||
msgid "This example is actually really confusing, but this property is actually useful, because it lets doing something like this:"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/expr.txt:47
|
||
#, no-wrap
|
||
msgid ""
|
||
" float a, b, c, d, e;\n"
|
||
" a = b = c = d = e = 1.0; // a == b == c == d == e == 1.0"
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/expr.txt:50
|
||
#, no-wrap
|
||
msgid "Basic arithmetic operations"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:51
|
||
#, no-wrap
|
||
msgid "Binary operators below are working with fundamental number types (<code><a cbot|int>int</a></code>, <code><a cbot|float>float</a></code>)."
|
||
msgstr ""
|
||
|
||
#. type: \t; header
|
||
#: ../E/expr.txt:53 ../E/expr.txt:89 ../E/expr.txt:115 ../E/expr.txt:140 ../E/expr.txt:163
|
||
#, no-wrap
|
||
msgid "List"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:54
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code>+</code> addition\n"
|
||
"<code>-</code> subtraction\n"
|
||
"<code>*</code> multiplication\n"
|
||
"<code>/</code> division\n"
|
||
"<code>%</code> remainder of the division (only for the type <code><a cbot|int>int</a></code>)"
|
||
msgstr ""
|
||
|
||
#. type: \t; header
|
||
#: ../E/expr.txt:60
|
||
#, no-wrap
|
||
msgid "Notes"
|
||
msgstr ""
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/expr.txt:61
|
||
#, no-wrap
|
||
msgid "The <code>*</code>, <code>/</code>, <code>%</code> are all stronger than <code>+</code> and <code>-</code>."
|
||
msgstr ""
|
||
|
||
#. type: Bullet: 'o'
|
||
#: ../E/expr.txt:62
|
||
#, no-wrap
|
||
msgid "The result <a cbot|type>type</a> is always <code><a cbot|float>float</a></code>. If <code>a</code> or <code>b</code> are of type <code><a cbot|int>int</a></code>, they are automatically converted to <code><a cbot|float>float</a></code>. Note: this means that results of intermediate calculations tends to be as precise as possible, the precision is lost only during converting the final (<code><a cbot|float>float</a></code>) result to <code><a cbot|int>int</a></code>, for example by the assignment <code>=</code> operator."
|
||
msgstr ""
|
||
|
||
#. type: \t; header
|
||
#: ../E/expr.txt:64
|
||
#, no-wrap
|
||
msgid "Real life examples"
|
||
msgstr ""
|
||
|
||
#. type: \t; header
|
||
#: ../E/expr.txt:81
|
||
#, no-wrap
|
||
msgid "Compound assignment operators"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:82
|
||
#, no-wrap
|
||
msgid "Besides the <code>=</code> operator for variable assignment there are several compound-assignment operators."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:84
|
||
#, no-wrap
|
||
msgid "The compound-assignment operators combine the <code>=</code> assignment operator with another binary operator such as <code>+</code> or <code>-</code>. Compound-assignment operators perform the operation specified by the additional operator and then assign the result to the left operand. For example, a compound-assignment expression such as"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/expr.txt:85
|
||
#, no-wrap
|
||
msgid "<code>lvalue += expression</code>"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/expr.txt:87
|
||
#, no-wrap
|
||
msgid "<code>lvalue = lvalue + expression</code>"
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/expr.txt:96
|
||
#, no-wrap
|
||
msgid "String concatenation"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:97
|
||
#, no-wrap
|
||
msgid "If at least one of the values used with the <code>+</code> operator is a <a cbot|string>string</a>, then the operation of concatenation is performed. The result of the operator is then a string, which is created by joining end-to-end the string and the other value. If the other value is not a string, then it is converted to string beforehand."
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/expr.txt:101
|
||
#, no-wrap
|
||
msgid ""
|
||
"\tstring s = \"a\" + \"bc\"; // returns \"abc\"\n"
|
||
"\tstring s = 1 + \"bc\"; // returns \"1bc\"\n"
|
||
"\tstring s = 2.5 + \"bc\"; // returns \"2.5bc\"\n"
|
||
"\tstring s = \"a\" + true; // returns \"atrue\""
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:106
|
||
#, no-wrap
|
||
msgid "Tip: the properties of the concatenation <code>+</code> operator is useful with the <a cbot|message>message();</a> function, because it does not work with other types than string. An empty string can be used together with a value in order to create a string, which actually can be passed to the <a cbot|message>message();</a> function:"
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/expr.txt:177
|
||
#, no-wrap
|
||
msgid "Prefix and postfix increment- and decrement operators"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:180
|
||
#, no-wrap
|
||
msgid "For example to increment the variable <code>a</code> you can write"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/expr.txt:181
|
||
#, no-wrap
|
||
msgid "<c/>a++;<n/>"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:182
|
||
#, no-wrap
|
||
msgid "instead of"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/expr.txt:183
|
||
#, no-wrap
|
||
msgid "<c/>a = a + 1;<n/>"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:185
|
||
#, no-wrap
|
||
msgid "The result of the operation <code>a++</code> is the value of the variable <code>a</code> *before* the increment. If you use the prefix operator <code>++a</code> the result of the operation is the value of the variable <code>a</code> *after* the increment. The same holds for the <code>--</code> decrement operator."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:4
|
||
#, no-wrap
|
||
msgid "Specifically speaking, an expression is an ordered series of operations which yield a result. Operations consist of operators, which are special <a cbot|function>functions</a> <code>T f(t1 x1, t2 x2, ..., tn xn)</code>, where <code>xi</code> is a value of type <code>ti</code>, and <code>T</code> is the result type. For example, <code>float +(float a, float b)</code> returns a sum of values <code>a</code> and <code>b</code>. Note: Operators are a part of the CBOT language and they cannot be defined in program. Also, the operators cannot be used as usual <a cbot|function>functions</a>, they need to be written using a special notation depending on the operator, for example <code>a+b</code>."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:6
|
||
#, no-wrap
|
||
msgid "In nearly all operations, <a cbot>constants</a>, <a cbot|var>variables</a>, <a cbot|function>functions</a> returning non-<a cbot|void>void</a> type and also other operations can be used as values."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:40
|
||
#, no-wrap
|
||
msgid "Note: it may be not obvious at first, but notice that <code>=</code> is an *operator* not an instruction. This mean that it can be used in the middle of an other expression! The result of <code>=</code> is the value which was assigned to the l-value - the result of the expression on the right. Example:"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/expr.txt:66
|
||
#, no-wrap
|
||
msgid ""
|
||
" int i = 12 + 3; // i == 15\n"
|
||
" int i = 2 - 5; // i == -3\n"
|
||
" \n"
|
||
" float f = 3.01 * 10; // f == 30.1\n"
|
||
" \n"
|
||
" int i = 5 / 3; // i == 1 (automatic conversion to int)\n"
|
||
" float f = 5 / 3; // f == 1.67\n"
|
||
" float f = 5 / 0; // returns an error (division by zero)\n"
|
||
" \n"
|
||
" int i = 13 % 5; // i == 3\n"
|
||
" int i = -8 % 3; // i == -2\n"
|
||
" \n"
|
||
" float f = sin(90) * i; // f == -2.0\n"
|
||
" "
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/expr.txt:108
|
||
#, no-wrap
|
||
msgid ""
|
||
" float pi = 3.14;\n"
|
||
" // message(pi); // does not work\n"
|
||
" message(\"\"+pi);"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/expr.txt:189
|
||
#, no-wrap
|
||
msgid ""
|
||
" a = 2;\n"
|
||
" b = a++;\n"
|
||
" // now b contains 2 and a contains 3"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/expr.txt:193
|
||
#, no-wrap
|
||
msgid ""
|
||
" a = 2;\n"
|
||
" b = ++a;\n"
|
||
" // now b contains 3 and a contains 3"
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/expr.txt:137
|
||
#, no-wrap
|
||
msgid "Logical operators"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:138
|
||
#, no-wrap
|
||
msgid "Logical operators work with values of type <a cbot|bool>bool</a> and they always return a <a cbot|bool>bool</a>. They are mainly used in <a cbot|cond>conditions</a>."
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/expr.txt:150
|
||
#, no-wrap
|
||
msgid "Ternary operator"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:151
|
||
#, no-wrap
|
||
msgid ""
|
||
"The ternary operator is nothing more than a syntax sugar. It is also known as \"inline if\". It might be confusing at first, because its syntax is a little more complicated than other operators. It can be described as follows:\n"
|
||
"<code>(condition) ? (result when true) : (result when false)</code>\n"
|
||
"Brackets are not needed."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:155
|
||
#, no-wrap
|
||
msgid "Firstly, the condition is valued and then the first result is returned if the condition is true, otherwise the second result is returned."
|
||
msgstr ""
|
||
|
||
#. type: \t; header
|
||
#: ../E/expr.txt:157 ../E/extends.txt:4 ../E/extends.txt:65 ../E/private.txt:4 ../E/protected.txt:4 ../E/super.txt:4
|
||
#, no-wrap
|
||
msgid "Example"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/expr.txt:158
|
||
#, no-wrap
|
||
msgid "<c/>float c = ((3.0 > 2.0) ? 10.0 : -10.0); // c == 10.0<n/>"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/cond.txt:2
|
||
#, no-wrap
|
||
msgid "A condition is a special <a cbot|expr>expression</a> that returns a <a cbot|bool>boolean</a> value, that can only be either <code><a cbot|true>true</a></code> or <code><a cbot|false>false</a></code>. With a condition, you can choose f. ex. if the instructions in a <code><a cbot|while>while</a></code> loop must be repeated again, or if the instruction in a <code><a cbot|if>if</a></code> bloc must be executed."
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/expr.txt:112
|
||
#, no-wrap
|
||
msgid "Comparison operators"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:113
|
||
#, no-wrap
|
||
msgid "Comparison operators work with values of type <a cbot|bool>float</a> and they always return a <a cbot|bool>bool</a>. They are mainly used in <a cbot|cond>conditions</a>."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:141
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code>!a </code>not <code>a</code>\n"
|
||
"<code>a && b </code><code>a</code> and <code>b</code>\n"
|
||
"<code>a || b </code><code>a</code> or <code>b</code>"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:146
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code>!false </code>returns true\n"
|
||
"<code>true && false </code>returns false \n"
|
||
"<code>true || false </code>returns true"
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/expr.txt:160
|
||
#, no-wrap
|
||
msgid "Bitwise operators"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:161
|
||
#, no-wrap
|
||
msgid "Bitwise operators are similar to the logical operator, because they are operating on bits (which can be only 0 or 1, conditions can have a value only of false or true). So in theory, they should be working with basically any type of variable, because each value in the computer must be stored as a sequence of bits."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:164
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code>a & b </code><code>a</code> AND <code>b</code>\n"
|
||
"<code>a | b </code><code>a</code> OR <code>b</code>\n"
|
||
"<code>a ^ b </code><code>a</code> XOR <code>b</code>\n"
|
||
"<code>a >> b </code>shift bits of <code>a</code> to the right <code>b</code> times\n"
|
||
"<code>a << b </code>shift bits of <code>a</code> to the left <code>b</code> times"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/expr.txt:171
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code>2 & 1 </code>returns 0\n"
|
||
"<code>2 | 1 </code>returns 3\n"
|
||
"<code>2 ^ 2 </code>returns 0\n"
|
||
"<code>2 >> 1 </code>returns 1\n"
|
||
"<code>2 << 1 </code>returns 4"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/array.txt:4
|
||
#, no-wrap
|
||
msgid ""
|
||
"int [ ] a; // an array of int\n"
|
||
"int a [12]; // an array of int limited to 12 elements\n"
|
||
"string s[3]; // an array of 3 strings\n"
|
||
"float xy[][]; // a 2 dimensionnal array of floats"
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/array.txt:30
|
||
#, no-wrap
|
||
msgid "Initialization syntax"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/array.txt:31
|
||
#, no-wrap
|
||
msgid "You can initialize a new array using the following syntax:"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/array.txt:33
|
||
#, no-wrap
|
||
msgid "type arrayName[] = { value0, value1, value2, ..., valueN };"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/array.txt:37
|
||
#, no-wrap
|
||
msgid ""
|
||
"int numbers[] = { 10, 20, 30 };\n"
|
||
"MyClass objects[] = { new MyClass(1), new MyClass(2) };"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/radar.txt:2
|
||
#, no-wrap
|
||
msgid "With the instruction <c/>radar();<n/>, you can look for objects like <a object|mother>enemies</a>, bots, buildings or raw materials."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/radar.txt:81
|
||
#, no-wrap
|
||
msgid "<c/><a cbot|radarall>radarall</a>();<n/>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/radarall.txt:1
|
||
#, no-wrap
|
||
msgid "Instruction <code>radarall</code>"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/radarall.txt:2
|
||
#, no-wrap
|
||
msgid "<c/>radarall();<n/> is an enhancement of the <c/><a cbot|radar>radar</a>();<n/> function -- it detects all objects matching the given criteria."
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/radarall.txt:4
|
||
#, no-wrap
|
||
msgid "Example<c/>"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/radarall.txt:13
|
||
#, no-wrap
|
||
msgid "<c/>radarall ( cat, angle, focus, min, max, sens, filter );<n/>"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/radarall.txt:15
|
||
#, no-wrap
|
||
msgid "The function works generally the same as the <c/><a cbot|radar>radar</a>();<n/> function with the only difference being that it returns an <a cbot|array>array</a> of <a cbot|object>objects</a> instead of one object. If no object is found, <code><a cbot|null>null</a></code> is returned."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/radarall.txt:17
|
||
#, no-wrap
|
||
msgid "The order of objects in the returned array is sorted by distance and depends on the <code>sens</code> parameter. The first object in the array is the object which would be returned by the <c/>radar();<n/> function called with the exactly same parameters."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/radarall.txt:20
|
||
#, no-wrap
|
||
msgid "<c/><a cbot|radar>radar</a>();<n/>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/for.txt:11
|
||
#, no-wrap
|
||
msgid "This set of instructions is executed before the first loop instance."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/for.txt:17
|
||
#, no-wrap
|
||
msgid "This set of instructions is executed at the end of every instance of the loop. "
|
||
msgstr ""
|
||
|
||
#. type: \t; header
|
||
#: ../E/for.txt:38
|
||
#, no-wrap
|
||
msgid "Executing more instructions"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/for.txt:39
|
||
#, no-wrap
|
||
msgid "In the <code>before</code> and <code>end</code> part of a <code>for</code> loop you can specify more than one instruction by using comma. Example:"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/for.txt:41
|
||
#, no-wrap
|
||
msgid ""
|
||
"int i = 0;\n"
|
||
"int j;\n"
|
||
"for (i++, j = 2; i < 3 && j > 0; i++, j--)\n"
|
||
"{\n"
|
||
" message(i);\n"
|
||
" message(j);\n"
|
||
"}"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/for.txt:49
|
||
#, no-wrap
|
||
msgid "The output of the above code is <code>1 2 2 1</code>."
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/radarall.txt:5
|
||
#, no-wrap
|
||
msgid ""
|
||
"object[] items = radarall(PowerCell);\n"
|
||
"for (int i = 0; i < sizeof(items); ++i)\n"
|
||
"{\n"
|
||
" message(items[i].id);\n"
|
||
"}"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/category.txt:103
|
||
#, no-wrap
|
||
msgid ""
|
||
" <code><a object|flag>BlueFlag</a> </code>Blue Flag\n"
|
||
" <code><a object|flag>RedFlag</a> </code>Red Flag\n"
|
||
" <code><a object|flag>GreenFlag</a> </code>Green Flag\n"
|
||
" <code><a object|flag>YellowFlag</a> </code>Yellow Flag\n"
|
||
" <code><a object|flag>VioletFlag</a> </code>Violet Flag\n"
|
||
" <code><a object|waypoint>WayPoint</a> </code>Checkpoint\n"
|
||
" <code><a object|target2>Target2</a> </code>Flying checkpoint\n"
|
||
" <code><a object|enerspot>PowerSpot</a> </code>Underground Energy Deposit\n"
|
||
" <code><a object|stonspot>TitaniumSpot</a> </code>Underground Titanium Deposit\n"
|
||
" <code><a object|uranspot>UraniumSpot</a> </code>Underground Uranium Deposit"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/category.txt:10
|
||
#, no-wrap
|
||
msgid ""
|
||
"<button 176/> <code><a object|huston>Houston</a> </code>Mission Control\n"
|
||
"<button 171/> <code><a object|base>SpaceShip</a> </code>Spaceship\n"
|
||
"<button 160/> <code><a object|factory>BotFactory</a> </code>Robot Factory\n"
|
||
"<button 163/> <code><a object|research>ResearchCenter</a> </code>Research Center\n"
|
||
"<button 168/> <code><a object|radar>RadarStation</a> </code>Radar\n"
|
||
"<button 172/> <code><a object|exchange>ExchangePost</a> </code>Information Exchange Post\n"
|
||
"<button 169/> <code><a object|repair>RepairCenter</a> </code>Repair Center\n"
|
||
"<button 165/> <code><a object|tower>DefenseTower</a> </code>Defense Tower\n"
|
||
"<button 166/> <code><a object|labo>AutoLab</a> </code>Organic Matter Analyzer \n"
|
||
"<button 164/> <code><a object|station>PowerStation</a> </code>Power Station\n"
|
||
"<button 167/> <code><a object|energy>PowerPlant</a> </code>Power Cell Factory\n"
|
||
"<button 170/> <code><a object|nuclear>NuclearPlant</a> </code>Nuclear Plant\n"
|
||
"<button 162/> <code><a object|convert>Converter</a> </code>Titanium Converter\n"
|
||
"<button 161/> <code><a object|derrick>Derrick</a> </code>Derrick\n"
|
||
"<button 174/> <code><a object|captor>PowerCaptor</a> </code>Parabolic Lightning Conductor\n"
|
||
"<button 175/> <code><a object|safe>Vault</a> </code>Vault\n"
|
||
" <code><a object|start>StartArea</a> </code>Starting Pad\n"
|
||
" <code><a object|goal>GoalArea</a> </code>Finishing Pad\n"
|
||
" <code><a object|target1>Target1</a> </code>Flying target\n"
|
||
" <code><a object|nest>AlienNest</a> </code>Alien Nest"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/class.txt:10
|
||
#, no-wrap
|
||
msgid "Classes can be only <a cbot|public>public</a>. This means that they can be used by all bots in a mission."
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/class.txt:12
|
||
#, no-wrap
|
||
msgid "Class Members"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/class.txt:13
|
||
#, no-wrap
|
||
msgid "Class members are fields (<a cbot|var>variables</a>) and methods (<a cbot|function>functions</a>)."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/class.txt:15
|
||
#, no-wrap
|
||
msgid "For example, the following class dubbed <code>MyClass</code> contains 4 fields (<code>a</code>, <code>b</code>, <code>x</code> and <code>s</code>) and one method (<code>MyFunction</code>)."
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/class.txt:17
|
||
#, no-wrap
|
||
msgid ""
|
||
"public class MyClass\n"
|
||
"{\n"
|
||
"\tint a, b;\n"
|
||
"\tfloat x = 3.33;\n"
|
||
"\tstring s = \"hello\";\n"
|
||
"\tfloat MyFunction(float value)\n"
|
||
"\t{\n"
|
||
"\t\treturn (value * x) - 1;\n"
|
||
"\t}\n"
|
||
"}"
|
||
msgstr ""
|
||
|
||
#. type: \t; header
|
||
#: ../E/class.txt:55
|
||
#, no-wrap
|
||
msgid "Member Initialization"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/class.txt:60
|
||
#, no-wrap
|
||
msgid "Example:<c/>"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/class.txt:61
|
||
#, no-wrap
|
||
msgid ""
|
||
"public class MyClass\n"
|
||
"{\n"
|
||
"\tint a, b;\n"
|
||
"\tvoid MyClass()\n"
|
||
"\t{\n"
|
||
"\t\ta = 2; b = 3;\n"
|
||
"\t}\n"
|
||
"\tvoid MyClass(int a, int b)\n"
|
||
"\t{\n"
|
||
"\t\tthis.a = a; this.b = b;\n"
|
||
"\t}\n"
|
||
"}"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/class.txt:76
|
||
#, no-wrap
|
||
msgid "As the names of the parameters of the second constructor are the same as the names of the two members <code>a</code> and <code>b</code>, we must use the <code><a cbot|this>this</a></code> <a cbot|pointer>reference</a> to avoid confusion with the parameters' names."
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/class.txt:78
|
||
#, no-wrap
|
||
msgid "Object Creation"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/class.txt:79
|
||
#, no-wrap
|
||
msgid "You can create objects of type <code>YourClass</code> using the <code><a cbot|new>new</a></code> keyword. Example:"
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/class.txt:90
|
||
#, no-wrap
|
||
msgid "Object Destruction"
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/class.txt:114
|
||
#, no-wrap
|
||
msgid "Passing Objects to Functions"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/class.txt:115
|
||
#, no-wrap
|
||
msgid "Objects in CBOT are passed by <a cbot|pointer>reference</a>. This means that when an object is passed to a <a cbot|function>function</a>, the function receives a copy of a pointer to the instance, not a copy of the object, so any modifications on the object will be visible outside of the function."
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/class.txt:117
|
||
#, no-wrap
|
||
msgid "Inheritance"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/class.txt:118
|
||
#, no-wrap
|
||
msgid "A class can inherit public and protected members of another class by using the <code><a cbot|extends>extends</a></code> keyword."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/class.txt:2
|
||
#, no-wrap
|
||
msgid "This keyword allows you to create a class definition by using the following syntax:"
|
||
msgstr ""
|
||
|
||
#. type: \t; header
|
||
#: ../E/class.txt:9
|
||
#, no-wrap
|
||
msgid "All Classes Are Public"
|
||
msgstr ""
|
||
|
||
#. type: \t; header
|
||
#: ../E/class.txt:52
|
||
#, no-wrap
|
||
msgid "Class Members Modifiers"
|
||
msgstr ""
|
||
|
||
#. type: \t; header
|
||
#: ../E/class.txt:75
|
||
#, no-wrap
|
||
msgid "Using <code><a cbot|this>this</a></code>"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/class.txt:81
|
||
#, no-wrap
|
||
msgid ""
|
||
"extern void object::Test()\n"
|
||
"{\n"
|
||
"\tMyClass object1(); // Call default constructor (without parameters)\n"
|
||
"\tMyClass object2(4, 5); // Call constructor with two int parameters\n"
|
||
"\tMyClass object3; // No constructor called, object3 == null\n"
|
||
"\tobject3 = new MyClass(); // We call constructor now, object3 != null\n"
|
||
"}"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/class.txt:91
|
||
#, no-wrap
|
||
msgid "You can also define a destructor. This must be a <code><a cbot|void>void</a></code> fonction without parameters, which has the same name as the class but prefixed with the <code>~</code> character. The destructor is called automatically as soon as the class instance is no more referenced by anyone. Example:"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/class.txt:93
|
||
#, no-wrap
|
||
msgid ""
|
||
"public class MyClass\n"
|
||
"{\n"
|
||
"\tstatic private int counter = 0; // instance counter\n"
|
||
"\tvoid MyClass( )\n"
|
||
"\t{\n"
|
||
"\t\tcounter++; // one instance more\n"
|
||
"\t}\n"
|
||
"\tvoid ~MyClass( )\n"
|
||
"\t{\n"
|
||
"\t\tcounter--; // one instance less\n"
|
||
"\t}\n"
|
||
"}\n"
|
||
"extern void object::Test()\n"
|
||
"{\n"
|
||
"\t // counter == 0\n"
|
||
"\tMyClass item1( ); // counter == 1\n"
|
||
"\tMyClass item2( ); // counter == 2\n"
|
||
"\titem1 = null; // counter == 1\n"
|
||
"}\n"
|
||
"// counter == 0"
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/class.txt:28
|
||
#, no-wrap
|
||
msgid "Accessing Class Members"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/class.txt:29
|
||
#, no-wrap
|
||
msgid "Class members can be accessed outside of the class definition by using the <code>.</code> operator. Example:"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/class.txt:50
|
||
#, no-wrap
|
||
msgid "Class members are <a cbot|public>public</a> by default, which means that they are accessible outside of the class definition. They can also be declared as <code><a cbot|private>private</a></code> or <code><a cbot|protected>protected</a></code>. Such members can only be accessed inside of the class definition."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/class.txt:53
|
||
#, no-wrap
|
||
msgid "Fields and methods can also be declared as <code><a cbot|static>static</a></code>. Methods can be additionaly declared as <code><a cbot|synchro>synchronized</a></code>."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/class.txt:58
|
||
#, no-wrap
|
||
msgid "Another way of initiliazing fields is by defining a constructor which is a special method having the same name as the class. This method will be called automatically at <a cbot|new>creation</a> time of a class instance. Constructors can be <a cbot|function>overloaded</a>."
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/class.txt:31
|
||
#, no-wrap
|
||
msgid ""
|
||
"public class MyClass\n"
|
||
"{\n"
|
||
"\tint myField = 0;\n"
|
||
"\tint MyFunction()\n"
|
||
"\t{\n"
|
||
"\t\treturn myField * 2;\n"
|
||
"\t}\n"
|
||
"}\n"
|
||
"\n"
|
||
"extern void object::Test()\n"
|
||
"{\n"
|
||
"\tMyClass myObject();\n"
|
||
"\tmyObject.myField = 10;\n"
|
||
"\tmessage(myObject.MyFunction()); // 20\n"
|
||
"\tMyClass mySecondObject();\n"
|
||
"\tmySecondObject.myField = myObject.myField - 2;\n"
|
||
"\tmessage(mySecondObject.MyFunction()); // 16\n"
|
||
"}"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/class.txt:121
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|public>public</a></code>, <code><a cbot|private>private</a></code>, <code><a cbot|protected>protected</a></code>, <code><a cbot|static>static</a></code>, <code><a cbot|synchro>synchronized</a></code>, <code><a cbot|new>new</a></code>, <code><a cbot|pointer>reference</a></code>, <code><a cbot|this>this</a></code>, <code><a cbot|super>super</a></code>, <code><a cbot|extends>extends</a></code>\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/protected.txt:1
|
||
#, no-wrap
|
||
msgid "Keyword <code>protected</code>"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/protected.txt:2
|
||
#, no-wrap
|
||
msgid "This is an access modifier for <a cbot|class>class</a> members. Protected class members can be accessed in a child class, but they can't be accessed outside of classes definitions being part of the same inheritance tree (see the <code><a cbot|extends>extends</a></code> keyword)."
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/protected.txt:6
|
||
#, no-wrap
|
||
msgid ""
|
||
"public class Parent\n"
|
||
"{\n"
|
||
"\tprotected int field = 0;\n"
|
||
"}\n"
|
||
"\n"
|
||
"public class Child extends Parent\n"
|
||
"{\n"
|
||
"\tvoid Print()\n"
|
||
"\t{\n"
|
||
"\t\tmessage(field);\n"
|
||
"\t}\n"
|
||
"}\n"
|
||
"\n"
|
||
"extern void object::Test()\n"
|
||
"{\n"
|
||
"\tChild child();\n"
|
||
"\tchild.Print(); // 0\n"
|
||
"\t//child.field = 1; // Error!\n"
|
||
"}"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/private.txt:2
|
||
#, no-wrap
|
||
msgid "This is an access modifier for <a cbot|class>class</a> members. Private members are not accessible outside of the class definition."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/private.txt:20
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|class>class</a></code>, <code><a cbot|public>public</a></code>, <code><a cbot|protected>protected</a></code>\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/public.txt:34
|
||
#, no-wrap
|
||
msgid "<code>public</code> is also an access modifier for <a cbot|class>class</a> members, which is the default one. Public members can be accessed from outside of the class definition."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/public.txt:50
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|class>class</a></code>, <code><a cbot|private>private</a></code>, <code><a cbot|protected>protected</a></code>, <code><a cbot|function>functions</a></code>\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/protected.txt:27
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|class>class</a></code>, <code><a cbot|public>public</a></code>, <code><a cbot|private>private</a></code>, <code><a cbot|extends>extends</a></code>\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/super.txt:1
|
||
#, no-wrap
|
||
msgid "Keyword <code>super</code>"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/super.txt:46
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|class>class</a></code>, <code><a cbot|this>this</a></code>\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/this.txt:53
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|class>class</a></code>, <code><a cbot|super>super</a></code>\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/extends.txt:1
|
||
#, no-wrap
|
||
msgid "Keyword <code>extends</code>"
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/extends.txt:30
|
||
#, no-wrap
|
||
msgid "Inherited Members"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/extends.txt:31
|
||
#, no-wrap
|
||
msgid "Only <code><a cbot|public>public</a></code> and <code><a cbot|protected>protected</a></code> members are inherited. <code><a cbot|private>private</a></code> members are directly inaccessible even for a child, although they can be accessed indirectly through inherited methods."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/extends.txt:33
|
||
#, no-wrap
|
||
msgid "Constructors and destructors are not inherited, however, they can be overriden."
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/extends.txt:35
|
||
#, no-wrap
|
||
msgid "Method Overriding"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/extends.txt:36
|
||
#, no-wrap
|
||
msgid "Inherited methods can be overriden (redefined) in the child class definition. Example:"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/extends.txt:38
|
||
#, no-wrap
|
||
msgid ""
|
||
"public class Parent\n"
|
||
"{\n"
|
||
"\tvoid foo()\n"
|
||
"\t{\n"
|
||
"\t\tmessage(\"foo\");\n"
|
||
"\t}\n"
|
||
"}\n"
|
||
"\n"
|
||
"public class Child extends Parent\n"
|
||
"{\n"
|
||
"\tvoid foo()\n"
|
||
"\t{\n"
|
||
"\t\tmessage(\"bar\");\n"
|
||
"\t}\n"
|
||
"}\n"
|
||
"\n"
|
||
"extern void object::Test()\n"
|
||
"{\n"
|
||
"\tChild child();\n"
|
||
"\tchild.foo(); // Will show \"bar\"\n"
|
||
"}"
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/extends.txt:62
|
||
#, no-wrap
|
||
msgid "Polymorphism"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/extends.txt:63
|
||
#, no-wrap
|
||
msgid "<code><a cbot|pointer>Reference</a></code> of type Parent can point to an object of type Child. However, such a pointer can't be used to access a child member. In order to access a child member, it must be assured that the Parent reference really points to a Child object. If that's the case, it can be safely copied to a pointer of type Child, which has access to the child members."
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/extends.txt:67
|
||
#, no-wrap
|
||
msgid ""
|
||
"public class Parent\n"
|
||
"{\n"
|
||
"\tvoid foo()\n"
|
||
"\t{\n"
|
||
"\t\tmessage(\"foo\");\n"
|
||
"\t}\n"
|
||
"}\n"
|
||
"\n"
|
||
"public class Child extends Parent\n"
|
||
"{\n"
|
||
"\tvoid foo()\n"
|
||
"\t{\n"
|
||
"\t\tmessage(\"bar\");\n"
|
||
"\t}\n"
|
||
"\tvoid bar()\n"
|
||
"\t{\n"
|
||
"\t\tmessage(\"foo bar\");\n"
|
||
"\t}\n"
|
||
"}\n"
|
||
"\n"
|
||
"extern void object::Test()\n"
|
||
"{\n"
|
||
"\tParent people[2];\n"
|
||
"\tpeople[0] = new Parent();\n"
|
||
"\tpeople[1] = new Child();\n"
|
||
"\tfor (int i = 0; i < 2; ++i)\n"
|
||
"\t{\n"
|
||
"\t\tpeople[i].foo();\n"
|
||
"\t}\n"
|
||
"\t//people[1].bar(); // Error\n"
|
||
"\tChild child = people[1];\n"
|
||
"\tchild.bar(); // OK\n"
|
||
"}"
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/extends.txt:102
|
||
#, no-wrap
|
||
msgid "Multiple Inheritance"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/extends.txt:103
|
||
#, no-wrap
|
||
msgid "A child cannot have multiple parents, however, a parent can have many children."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/extends.txt:106
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code><a cbot|class>class</a></code>, <code><a cbot|public>public</a></code>, <code><a cbot|private>private</a></code>, <code><a cbot|protected>protected</a></code>, <code><a cbot|new>new</a></code>, <code><a cbot|pointer>reference</a></code>, <code><a cbot|this>this</a></code>, <code><a cbot|super>super</a></code>\n"
|
||
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/super.txt:2
|
||
#, no-wrap
|
||
msgid "This keyword is similar to <code><a cbot|this>this</a></code>, however, it grants access to methods from the parent class (see the <code><a cbot|extends>extends</a></code> keyword), which is especially useful for method overriding."
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/super.txt:6
|
||
#, no-wrap
|
||
msgid ""
|
||
"public class Parent\n"
|
||
"{\n"
|
||
"\tprotected int field;\n"
|
||
"\t\n"
|
||
"\tvoid Parent()\n"
|
||
"\t{\n"
|
||
"\t\tfield = 0;\n"
|
||
"\t}\n"
|
||
"\t\n"
|
||
"\tvoid Print()\n"
|
||
"\t{\n"
|
||
"\t\tmessage(\"Parent's field: \" + field);\n"
|
||
"\t}\n"
|
||
"}\n"
|
||
"\n"
|
||
"public class Child extends Parent\n"
|
||
"{\n"
|
||
"\tprivate int childsField;\n"
|
||
"\t\n"
|
||
"\tvoid Child()\n"
|
||
"\t{\n"
|
||
"\t\tsuper.Parent();\n"
|
||
"\t\tchildsField = field + 1;\n"
|
||
"\t}\n"
|
||
"\t\n"
|
||
"\tvoid Print()\n"
|
||
"\t{\n"
|
||
"\t\tsuper.Print();\n"
|
||
"\t\tmessage(\"Child's field: \" + childsField);\n"
|
||
"\t}\n"
|
||
"}\n"
|
||
"\n"
|
||
"extern void object::Test()\n"
|
||
"{\n"
|
||
"\tChild child();\n"
|
||
"\tchild.Print(); // Will show both 0 and 1\n"
|
||
"}"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/extends.txt:2
|
||
#, no-wrap
|
||
msgid "This keyword is used in a <code><a cbot|class>class</a></code> definition when we want the class to inherit members from another class. The class which is extended we usually call a parent or base, the extending class we call a child."
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/extends.txt:6
|
||
#, no-wrap
|
||
msgid ""
|
||
"public class Parent\n"
|
||
"{\n"
|
||
"\tvoid foo()\n"
|
||
"\t{\n"
|
||
"\t\tmessage(\"foo\");\n"
|
||
"\t}\n"
|
||
"}\n"
|
||
"\n"
|
||
"public class Child extends Parent\n"
|
||
"{\n"
|
||
"\tvoid bar()\n"
|
||
"\t{\n"
|
||
"\t\tmessage(\"bar\");\n"
|
||
"\t}\n"
|
||
"}\n"
|
||
"\n"
|
||
"extern void object::Test()\n"
|
||
"{\n"
|
||
"\tChild child();\n"
|
||
"\tchild.foo(); // Will show \"foo\"\n"
|
||
"\tchild.bar(); // Will show \"bar\"\n"
|
||
"}"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/extends.txt:60
|
||
#, no-wrap
|
||
msgid "A parent's method can be called inside an overriden method by using the <code><a cbot|super>super</a></code> keyword."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/class.txt:56
|
||
#, no-wrap
|
||
msgid "As shown in the previous example, the class members can be initialized in the class definition (<c/>int x = 3.33;<n/>)."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/open.txt:13
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code>\"r\"</code> mode: open for reading.\n"
|
||
"<code>\"w\"</code> mode: open for writing.\n"
|
||
"<code>\"a\"</code> mode: open for appending."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/openfile.txt:2
|
||
#, no-wrap
|
||
msgid "<c/>openfile();<n/> opens an text file in the files/ folder. This is not a method of the <code><a cbot|file>file</a></code> class but openfile returns a <a cbot|pointer>reference</a> to a new instance of the file class. You must supply two parameters, the filename and the opening mode."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/openfile.txt:6
|
||
#, no-wrap
|
||
msgid ""
|
||
"<code>\"r\"</code> mode: open for reading.\n"
|
||
"<code>\"w\"</code> mode: open for writing.\n"
|
||
"<code>\"w\"</code> mode: open for appending."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/function.txt:14
|
||
#, no-wrap
|
||
msgid "Nothing but a name can be changed in the main function. The keyword <code><a cbot|extern>extern</a></code> distinguishes the main function from others."
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/function.txt:117
|
||
#, no-wrap
|
||
msgid "Public Functions"
|
||
msgstr ""
|
||
|
||
#. type: \b; header
|
||
#: ../E/function.txt:129
|
||
#, no-wrap
|
||
msgid "Default Parameters"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/function.txt:130
|
||
#, no-wrap
|
||
msgid "Last function parameters can have default values that can be omitted when calling."
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/function.txt:132
|
||
#, no-wrap
|
||
msgid ""
|
||
"float Add(float a = 0.0, float b = 0.0)\n"
|
||
"{\n"
|
||
"\treturn a + b;\n"
|
||
"}\n"
|
||
"\n"
|
||
"// Somewhere in the main program...\n"
|
||
"Add(); // Will return 0.0\n"
|
||
"Add(2.0); // Will return 2.0\n"
|
||
"Add(2.0, 3.0); // Will return 5.0\n"
|
||
"// ..."
|
||
msgstr ""
|
||
|
||
#. type: \t; header
|
||
#: ../E/function.txt:144
|
||
#, no-wrap
|
||
msgid "Default Parameters and Overloading"
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/function.txt:145
|
||
#, no-wrap
|
||
msgid "Functions with default parameters still can be overloaded, one must only ensure that function calls are not ambiguous. For example, consider the following code:"
|
||
msgstr ""
|
||
|
||
#. type: Source code
|
||
#: ../E/function.txt:147
|
||
#, no-wrap
|
||
msgid ""
|
||
"float Add(float a = 0.0, float b = 0.0)\n"
|
||
"{\n"
|
||
"\treturn a + b;\n"
|
||
"}\n"
|
||
"\n"
|
||
"string Add(string a = \"\", string b = \"\")\n"
|
||
"{\n"
|
||
"\treturn a + b;\n"
|
||
"}\n"
|
||
"\n"
|
||
"// Somewhere in the main program...\n"
|
||
"Add(); // Compilation error: ambiguous call\n"
|
||
"Add(\"\"); // Ok\n"
|
||
"Add(0.0); // Ok\n"
|
||
"// ..."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/function.txt:163
|
||
#, no-wrap
|
||
msgid "Note that in the above example overloading causes the first default parameter to be useless as caller needs to pass it anyway in order to distinguish the two functions."
|
||
msgstr ""
|
||
|
||
#. type: Plain text
|
||
#: ../E/category.txt:70
|
||
#, no-wrap
|
||
msgid ""
|
||
"<button 192/> <code><a object|botbr>WheeledBuilder</a> </code>Wheeled Builder\n"
|
||
"<button 193/> <code><a object|botbc>TrackedBuilder</a> </code>Tracked Builder\n"
|
||
"<button 194/> <code><a object|botbj>WingedBuilder</a> </code>Winged Builder\n"
|
||
"<button 195/> <code><a object|botbs>LeggedBuilder</a> </code>Legged Builder"
|
||
msgstr ""
|