colobot-data/help/cbot/po/ru.po

# 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: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2014-07-02 12:51+0200\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"Language: ru\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Translate Toolkit 1.11.0\n"

#. type: Plain text
#: cbot.languagecode:1
msgid "E"
msgstr ""

#. type: \b; header
#: cbot-help/abstime.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>abstime</code>"
msgstr "Инструкция <code>aim</code>"

#. type: Plain text
#: cbot-help/abstime.txt:3 cbot-help/deletef.txt:7 cbot-help/delinfo.txt:3 cbot-help/errmode.txt:6 cbot-help/flatgrnd.txt:3 cbot-help/readln.txt:9 cbot-help/send.txt:3 cbot-help/strfind.txt:5 cbot-help/strleft.txt:5 cbot-help/strlen.txt:5 cbot-help/strlower.txt:5 cbot-help/strmid.txt:5 cbot-help/strright.txt:5 cbot-help/strupper.txt:5 cbot-help/strval.txt:9 cbot-help/testinfo.txt:3 cbot-help/writeln.txt:9
#, no-wrap
#, fuzzy, no-wrap
msgid "Syntax¦:"
msgstr "Синтаксис¦:"

#. type: \s; block (usually verbatim code)
#: cbot-help/abstime.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>abstime ( );<n/>"
msgstr "<c/>thump ( );<n/>"

#. type: Plain text
#: cbot-help/abstime.txt:6
#, no-wrap
msgid "Return the time in seconds elapsed since the beginning of the mission."
msgstr ""

#. type: \t; header
#: cbot-help/abstime.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid "Return: <code><a cbot|float>float</a></code>"
msgstr "Возвращаемое значение: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: cbot-help/abstime.txt:9
#, no-wrap
msgid "Time in seconds."
msgstr ""

#. type: \t; header
#: cbot-help/abstime.txt:10 cbot-help/aim.txt:20 cbot-help/array.txt:30 cbot-help/bloc.txt:48 cbot-help/bool.txt:4 cbot-help/break.txt:24 cbot-help/category.txt:107 cbot-help/class.txt:70 cbot-help/close.txt:6 cbot-help/cond.txt:27 cbot-help/continue.txt:24 cbot-help/deletef.txt:9 cbot-help/delinfo.txt:13 cbot-help/direct.txt:13 cbot-help/dist2d.txt:13 cbot-help/dist.txt:29 cbot-help/do.txt:27 cbot-help/drop.txt:28 cbot-help/eof.txt:13 cbot-help/errmode.txt:32 cbot-help/expr.txt:87 cbot-help/extern.txt:29 cbot-help/false.txt:4 cbot-help/file.txt:16 cbot-help/fire.txt:30 cbot-help/flatgrnd.txt:16 cbot-help/float.txt:24 cbot-help/for.txt:38 cbot-help/function.txt:84 cbot-help/goto.txt:34 cbot-help/grab.txt:28 cbot-help/if.txt:39 cbot-help/int.txt:18 cbot-help/jet.txt:14 cbot-help/message.txt:24 cbot-help/motor.txt:38 cbot-help/move.txt:21 cbot-help/nan.txt:14 cbot-help/new.txt:20 cbot-help/null.txt:4 cbot-help/object.txt:68 cbot-help/openfile.txt:10 cbot-help/open.txt:18 cbot-help/pointer.txt:51 cbot-help/point.txt:35 cbot-help/private.txt:17 cbot-help/public.txt:49 cbot-help/radar.txt:58 cbot-help/readln.txt:18 cbot-help/receive.txt:16 cbot-help/recycle.txt:12 cbot-help/retobj.txt:13 cbot-help/return.txt:29 cbot-help/search.txt:16 cbot-help/send.txt:17 cbot-help/shield.txt:18 cbot-help/sizeof.txt:21 cbot-help/sniff.txt:16 cbot-help/space.txt:22 cbot-help/static.txt:20 cbot-help/strfind.txt:18 cbot-help/string.txt:32 cbot-help/strleft.txt:14 cbot-help/strlen.txt:12 cbot-help/strlower.txt:10 cbot-help/strmid.txt:18 cbot-help/strright.txt:14 cbot-help/strupper.txt:10 cbot-help/strval.txt:17 cbot-help/synchro.txt:23 cbot-help/term.txt:30 cbot-help/testinfo.txt:16 cbot-help/this.txt:52 cbot-help/thump.txt:12 cbot-help/topo.txt:13 cbot-help/true.txt:4 cbot-help/turn.txt:32 cbot-help/type.txt:32 cbot-help/var.txt:66 cbot-help/void.txt:10 cbot-help/wait.txt:21 cbot-help/while.txt:46 cbot-help/writeln.txt:19
#, no-wrap
#, fuzzy, no-wrap
msgid "See also"
msgstr "См. также"

#. type: Plain text
#: cbot-help/abstime.txt:11 cbot-help/aim.txt:21 cbot-help/array.txt:31 cbot-help/bool.txt:5 cbot-help/break.txt:25 cbot-help/cond.txt:29 cbot-help/continue.txt:25 cbot-help/deletef.txt:10 cbot-help/direct.txt:15 cbot-help/dist2d.txt:14 cbot-help/dist.txt:30 cbot-help/drop.txt:29 cbot-help/errmode.txt:33 cbot-help/expr.txt:88 cbot-help/extern.txt:30 cbot-help/false.txt:6 cbot-help/fire.txt:31 cbot-help/flatgrnd.txt:17 cbot-help/float.txt:25 cbot-help/for.txt:40 cbot-help/function.txt:85 cbot-help/goto.txt:35 cbot-help/grab.txt:29 cbot-help/if.txt:40 cbot-help/int.txt:20 cbot-help/jet.txt:16 cbot-help/message.txt:25 cbot-help/move.txt:22 cbot-help/nan.txt:16 cbot-help/object.txt:70 cbot-help/openfile.txt:11 cbot-help/point.txt:36 cbot-help/radar.txt:60 cbot-help/recycle.txt:14 cbot-help/retobj.txt:15 cbot-help/return.txt:31 cbot-help/search.txt:18 cbot-help/shield.txt:19 cbot-help/sizeof.txt:22 cbot-help/sniff.txt:17 cbot-help/space.txt:23 cbot-help/string.txt:33 cbot-help/term.txt:31 cbot-help/thump.txt:13 cbot-help/topo.txt:14 cbot-help/true.txt:5 cbot-help/turn.txt:33 cbot-help/type.txt:33 cbot-help/var.txt:67 cbot-help/void.txt:11 cbot-help/wait.txt:22
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a "
"cbot|category>categories</a>."
msgstr ""
"<a cbot>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/aim.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>aim</code>"
msgstr "Инструкция <code>aim</code>"

#. type: Plain text
#: cbot-help/aim.txt:3 cbot-help/break.txt:3 cbot-help/continue.txt:3 cbot-help/direct.txt:3 cbot-help/motor.txt:16 cbot-help/space.txt:3 cbot-help/while.txt:21
#, no-wrap
#, fuzzy, no-wrap
msgid "Syntax :"
msgstr "Синтаксис :"

#. type: \s; block (usually verbatim code)
#: cbot-help/aim.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>aim ( angle );<n/>"
msgstr "<c/>aim ( угол );<n/>"

#. type: Plain text
#: cbot-help/aim.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"This instruction sets the vertical angle of the cannon. The following robots "
"are equipped with a cannon: \n"
msgstr ""
"Эта инструкция устанавливает вертикальны угол пушки. Пушкой снабжаются "
"следующи роботы:\n"

#. type: Bullet: 'o'
#: cbot-help/aim.txt:6 cbot-help/fire.txt:14
#, no-wrap
#, fuzzy, no-wrap
msgid "<a object|botfr>Shooter</a>"
msgstr "<a object|botfr>Стрелок</a>"

#. type: Bullet: 'o'
#: cbot-help/aim.txt:7 cbot-help/fire.txt:15
#, no-wrap
#, fuzzy, no-wrap
msgid "<a object|botor>Orga shooter</a>"
msgstr "<a object|botor>Орга Стрелок</a>"

#. type: Bullet: 'o'
#: cbot-help/aim.txt:8 cbot-help/fire.txt:16
#, no-wrap
#, fuzzy, no-wrap
msgid "<a object|botphaz>Phazer shooter</a>"
msgstr "<a object|botphaz>Фазер Стрелок</a>"

#. type: Plain text
#: cbot-help/aim.txt:11 cbot-help/fire.txt:19
#, no-wrap
#, fuzzy, 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 ""
"Когда вы управляете своим ботом путем программирования, единственный способ "
"повернуть оружие направо или налево - это повернуть весь бот инструкцией "
"<code><a cbot|turn>turn</a></code>."

#. type: \t; header
#: cbot-help/aim.txt:12 cbot-help/turn.txt:24
#, no-wrap
#, fuzzy, no-wrap
msgid "angle: <code><a cbot|float>float</a></code>"
msgstr "угол: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: cbot-help/aim.txt:14
#, no-wrap
#, fuzzy, 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 ""
"Угол оружия относительно робота, в градусах. Положительное значение "
"ориентирует ружье вперед. Для стрелков и орга-стрелков, угол должен быть от "
"<code>-20</code> до <code>+20</code> градусов. Для фазовый стрелок стрелков, "
"угол должен быть в пределах от <code>-20</code> до <code>45</code> градусов."

#. type: \t; header
#: cbot-help/aim.txt:15 cbot-help/drop.txt:23 cbot-help/fire.txt:25 cbot-help/goto.txt:29 cbot-help/grab.txt:23 cbot-help/move.txt:16 cbot-help/recycle.txt:7 cbot-help/sniff.txt:11 cbot-help/thump.txt:7 cbot-help/turn.txt:27
#, no-wrap
#, fuzzy, no-wrap
msgid "Return value: <code><a cbot|int>int</a></code>"
msgstr "Возвращаемое значение: <code><a cbot|int>int</a></code>"

#. type: Plain text
#: cbot-help/aim.txt:19
#, no-wrap
#, fuzzy, 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 ""
"Ноль если все в порядке. Число отличное от нуля, если вращение выполнить не "
"удалось:\n"
"<code>== 0 </code>Оружие получило нужную ориентацию\n"
"<code>!= 0 </code>вращение невозможно"

#. type: \b; header
#: cbot-help/array.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Arrays"
msgstr "Массивы"

#. type: Plain text
#: cbot-help/array.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Массив - это в основном набор переменных того же типа и класса. Вы можете "
"использовать н-ное количество массивов в языке CBOT, однако максимальный "
"размер массива равен 9999 элементов. Вы должны использовать квадратные "
"скобки <code>[]</code> после того, как объявили массив."

#. type: \s; block (usually verbatim code)
#: cbot-help/array.txt:8
#, no-wrap
#, fuzzy, 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[][];  // an 2 dimensionnal array of floats"
msgstr ""
"int    [ ] a;   // целочисленный массив\n"
"int    a [12];  // целочисленный массив, где максимум 12 элементов\n"
"string s[3];    // массив с тремя строчками\n"
"float  xy[][];  // двумерный массив плавающей запятой"

#. type: Plain text
#: cbot-help/array.txt:10
#, no-wrap
#, fuzzy, 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 ""
"На самом деле, когда компилятор CBOT встречает объявление массива, то он "
"просто создает <code><a cbot|null>null</a></code> <a cbot|pointer>ссылку</a>:"

#. type: \s; block (usually verbatim code)
#: cbot-help/array.txt:12
#, no-wrap
#, fuzzy, no-wrap
msgid "int a[5];  // a is now a null reference"
msgstr "int a[5];  // просто пустая ссылка"

#. type: Plain text
#: cbot-help/array.txt:14
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"As soon as you put values into the array, the elements are created and the "
"reference is initialized:"
msgstr ""
"Как только вы поместите значения в массив, элементы создаются и ссылки "
"инициализируются:"

#. type: \s; block (usually verbatim code)
#: cbot-help/array.txt:17
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"a[2] = 213;  // a points to\n"
"             // 3 élements [0], [1] et [2]"
msgstr ""
"a[2] = 213;  // указывает на\n"
"             // три элемента [0], [1] и [2]"

#. type: Plain text
#: cbot-help/array.txt:19
#, no-wrap
#, fuzzy, 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 ""
"После этой операции, <code>a</code> содержит ссылки на элементы массива. "
"Элементы <code>[0]</code> и <code>[1]</code> созданы, однако не "
"инициализированы, т.к. они пусты. Инструкция <code><a "
"cbot|sizeof>sizeof</a></code> позволяет получить число элементов, хранящихся "
"в массиве."

#. type: Plain text
#: cbot-help/array.txt:21
#, no-wrap
#, fuzzy, 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 ""
"Если массив объявлен с максимальным размером, то программа остановится, как "
"только доступ к нему выйдет за его рамки(т.е. кол-во элементов+N). При "
"компиляции ошибки не возникнет, даже если она очевидна:"

#. type: \s; block (usually verbatim code)
#: cbot-help/array.txt:27
#, no-wrap
#, fuzzy, 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;  // нет ошибки при компиляции\n"
"\t             // однако ошибка при выполнении\n"
"}"

#. type: Plain text
#: cbot-help/array.txt:29
#, no-wrap
#, fuzzy, 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 ""
"Если вы передаете <a cbot|function>функции</a> массив в качестве параметра, "
"то функция получает только <a cbot|pointer>ссылку</a> на массив. Это "
"означает, что если вы измение элемент в массиве, то этот элемент будет "
"измененным и в самой функции."

#. type: \b; header
#: cbot-help/bloc.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Blocks"
msgstr "Блоки"

#. type: Plain text
#: cbot-help/bloc.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Можно использовать скобки <code>{ }</code> чтобы сгруппировать несколько "
"инструкций вместе и составить из них целый блок, например:"

#. type: \s; block (usually verbatim code)
#: cbot-help/bloc.txt:10
#, no-wrap
#, fuzzy, 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;  // переключает между a и b\n"
"\t}"

#. type: Plain text
#: cbot-help/bloc.txt:13
#, no-wrap
#, fuzzy, 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 ""
"Каждая инструкци в блоке заканчивается  <a cbot|term>двоеточием</a>, но не "
"сам блок.\n"
"Расмотрим следующий пример с инструкцией <code><a cbot|if>if</a></code> "
"чтобы проиллюстрировать блоки в программах:"

#. type: \s; block (usually verbatim code)
#: cbot-help/bloc.txt:18
#, no-wrap
#, fuzzy, 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/>инструкция 1<c/>;\n"
"\t\t<n/>инструкция 2<c/>;\n"
"\t<n/>инструкция 3<c/>;"

#. type: Plain text
#: cbot-help/bloc.txt:21
#, no-wrap
#, fuzzy, 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 ""
"Если <a cbot|cond>состояние</a> верно, то инструкции 1, 2 и 3 выполняются. "
"Если состояние не верно, не выполняется только инструкция 1, а инструкции 2 "
"и 3 выполняются. Тот факт, что инструкция 2 стоит в одной линии с "
"инструкцией 1 на ход не влияет.\n"
"Если вы хотите выполнить только инструкции 1 и 2, причем условие "
"выполняется, вам нужно выделить их вместе в одном блоке:"

#. type: \s; block (usually verbatim code)
#: cbot-help/bloc.txt:28
#, no-wrap
#, fuzzy, 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/>инструкция 1<c/>;\n"
"\t\t<n/>инструкция 2<c/>;\n"
"\t}\n"
"\t<n/>инструкция 3<c/>;"

#. type: Plain text
#: cbot-help/bloc.txt:31
#, no-wrap
#, fuzzy, 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 ""
"Блоки могут использоваться с инструкциями <code><a cbot|if>if</a></code>, "
"<code><a cbot|while>while</a></code> и <code><a cbot|for>for</a></code>, "
"чтобы сгруппировать отдельные инструкции, которые должны выполняться только "
"если условие выполняется, или повторяется несколько раз.\n"
"Можно включать блоки в другие блоки, на столько уровней насколько нужно. Вот "
"пример включения в скобки на двух уровнях:"

#. type: \s; block (usually verbatim code)
#: cbot-help/bloc.txt:42
#, no-wrap
#, fuzzy, 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
#: cbot-help/bloc.txt:44
#, no-wrap
#, fuzzy, 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 ""
"Было бы целесообразнее выравнивать открытую скобку <code>{</code> по "
"закрытой скобке <code>}</code> в целях улучшения читаемости, но это "
"необязательно. Следующий пример занимает меньше места, но эквивалентен "
"предыдущему примеру, однако писать свои программы в подобном стиле не "
"рекомендуется:"

#. type: \s; block (usually verbatim code)
#: cbot-help/bloc.txt:47
#, no-wrap
#, fuzzy, 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
#: cbot-help/bloc.txt:49 cbot-help/do.txt:28 cbot-help/motor.txt:39 cbot-help/while.txt:47
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"<a cbot>Instructions</a>, <a cbot|type>types</a> and <a "
"cbot|category>categories</a>."
msgstr ""
"<a cbot>Инструкции</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/bool.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Type <code>bool</code>"
msgstr "Тип <code>bool</code>"

#. type: Plain text
#: cbot-help/bool.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Переменной этого типа вы можете присваивать булевое значение, т.е. значение, "
"которое может иметь лишь два состояния: да и нет."

#. type: \b; header
#: cbot-help/break.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>break</code>"
msgstr "Инструкция <code>break</code>"

#. type: \s; block (usually verbatim code)
#: cbot-help/break.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"<c/>while ( condition )\n"
"{\n"
"\tbreak;\n"
"}"
msgstr ""
"<c/>while ( условие )\n"
"{\n"
"\tbreak;\n"
"}"

#. type: Plain text
#: cbot-help/break.txt:9
#, no-wrap
#, fuzzy, 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 ""
"С помощью этой инструкции, вы можете немедленно выйти из цикла функции "
"<code><a cbot|while>while</a></code> или <code><a cbot|for>for</a></code>."

#. type: Plain text
#: cbot-help/break.txt:11 cbot-help/continue.txt:11
#, no-wrap
#, fuzzy, no-wrap
msgid "Here is an example:"
msgstr "вот пример:"

#. type: \s; block (usually verbatim code)
#: cbot-help/break.txt:22
#, no-wrap
#, fuzzy, 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 ( да )\n"
"{\n"
"\t<n/>Инструкции...<c/>\n"
"\ti = i+1;\n"
"\tif ( i >= 10 )\n"
"\t{\n"
"\t\tbreak;\n"
"\t}\n"
"}"

#. type: \b; header
#: cbot-help/category.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Value <code>Categories</code>"
msgstr "Значение <code>Категорий</code>"

#. type: Plain text
#: cbot-help/category.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Категории отображают названия обьектов на языке CBOT. В игре COLOBOT все "
"предеты являются обьектами: роботы, здания, сырье, и т.д., даже сам игрок."

#. type: Plain text
#: cbot-help/category.txt:5
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"In a program, categories are always displayed on a <format const>red "
"background</format>. If a category isn't highlighted in red, it is "
"misspelled. Caps and lower cases should be kept as is."
msgstr ""
"В самой программе, категории всегда отображаются на  <format const>красном "
"фоне</format>. Если категория не выделена красным, она названа не правильно. "
"Заглавные и обычные буквы нужно оставлять как есть."

#. type: Plain text
#: cbot-help/category.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid "Below are the different categories available :"
msgstr "Ниже даются все известные категории:"

#. type: \t; header
#: cbot-help/category.txt:8
#, no-wrap
#, fuzzy, no-wrap
msgid "Buildings :"
msgstr "Здания:"

#. type: Plain text
#: cbot-help/category.txt:29
#, no-wrap
#, fuzzy, 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|nest>AlienNest</a>        </code>Alien Nest"
msgstr ""
"<button 176/>   <code><a object|Huston>Houston</a>          </code>"
"Управление Миссией\n"
"<button 171/>   <code><a object|base>SpaceShip</a>        </code>Корабль\n"
"<button 160/>   <code><a object|factory>BotFactory</a>       </code>Фабрика "
"ботов\n"
"<button 163/>   <code><a object|research>ResearchCenter</a>   </code>"
"Исследовательский Центр\n"
"<button 168/>   <code><a object|radar>RadarStation</a>     </code>Радар\n"
"<button 172/>   <code><a object|exchange>ExchangePost</a>     </code>Пост "
"Обмена Информацией\n"
"<button 169/>   <code><a object|repair>RepairCenter</a>     </code>Ремонтный "
"Центр\n"
"<button 165/>   <code><a object|tower>DefenseTower</a>     </code>Защитная "
"Башня\n"
"<button 166/>   <code><a object|labo>AutoLab</a>          </code>Анализатор "
"Органической Материи\n"
"<button 164/>   <code><a object|station>PowerStation</a>     </code>Силовая "
"Станция\n"
"<button 167/>   <code><a object|energy>PowerPlant</a>       </code>Фабрика "
"батареек\n"
"<button 170/>   <code><a object|nuclear>NuclearPlant</a>     </code>Ядерная "
"фабрика\n"
"<button 162/>   <code><a object|convert>Converter</a>        </code>"
"Титановый Конвертер\n"
"<button 161/>   <code><a object|derrick>Derrick</a>          </code>Буровая "
"Вышка\n"
"<button 174/>   <code><a object|captor>PowerCaptor</a>      </code>"
"Параболический громоотвод\n"
"<button 175/>   <code><a object|safe>Vault</a>            </code>Хранилище\n"
"       <code><a object|start>StartArea</a>        </code>Стартовая площадка\n"
"       <code><a object|goal>FinishArea</a>       </code>Финальная Площадка\n"
"       <code><a object|nest>AlienNest</a>        </code>Гнездо Чужих"

#. type: \t; header
#: cbot-help/category.txt:31
#, no-wrap
#, fuzzy, no-wrap
msgid "Portable Objects :"
msgstr "Переносные обьекты:"

#. type: Plain text
#: cbot-help/category.txt:42
#, no-wrap
#, fuzzy, 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>Титановая "
"Руда\n"
"       <code><a object|uranore>UraniumOre</a>           </code>Урановая "
"Руда\n"
"       <code><a object|titan>Titanium</a>             </code>Куб "
"переработанного титана\n"
"       <code><a object|power>PowerCell</a>            </code>Обычная "
"Батарейка\n"
"       <code><a object|atomic>NuclearPowerCell</a>     </code>Ядерная "
"Батарейка\n"
"       <code><a object|bullet>OrgaMatter</a>           </code>Органическая "
"Материя\n"
"       <code><a object|bbox>BlackBox</a>             </code>Черный Ящик\n"
"       <code><a object|tnt>TNT</a>                  </code>Взрывное "
"устройство\n"
"       <code><a object|key>KeyA..D</a>              </code>Ключи A, B, C and "
"D"

#. type: \t; header
#: cbot-help/category.txt:44
#, no-wrap
#, fuzzy, no-wrap
msgid "Robots :"
msgstr "Роботы:"

#. type: Plain text
#: cbot-help/category.txt:48
#, no-wrap
#, fuzzy, 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>"
"Тренировочный Бот\n"
"<button 173/>   <code><a object|bottarg>TargetBot</a>              </code>"
"Целевой бот"

#. type: Plain text
#: cbot-help/category.txt:53
#, no-wrap
#, fuzzy, 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>"
"Колесный сборщик\n"
"<button 138/>   <code><a object|botgc>TrackedGrabber</a>         </code>"
"Гусеничный сборщик\n"
"<button 139/>   <code><a object|botgj>WingedGrabber</a>          </code>"
"Летающий сборщик\n"
"<button 150/>   <code><a object|botgs>LeggedGrabber</a>          </code>"
"Шагающий сборщик"

#. type: Plain text
#: cbot-help/category.txt:58
#, no-wrap
#, fuzzy, 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>"
"Колесный сниффер\n"
"<button 141/>   <code><a object|botsc>TrackedSniffer</a>         </code>"
"Гусеничный сниффер\n"
"<button 142/>   <code><a object|botsj>WingedSniffer</a>          </code>"
"Летающий сниффер\n"
"<button 152/>   <code><a object|botss>LeggedSniffer</a>          </code>"
"Шагающий сниффер"

#. type: Plain text
#: cbot-help/category.txt:63
#, no-wrap
#, fuzzy, 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>"
"Колесный стрелок\n"
"<button 144/>   <code><a object|botfc>TrackedShooter</a>         </code>"
"Гусеничный стрелок\n"
"<button 145/>   <code><a object|botfj>WingedShooter</a>          </code>"
"Летающий стрелок\n"
"<button 151/>   <code><a object|botfs>LeggedShooter</a>          </code>"
"Шагающий стрелок"

#. type: Plain text
#: cbot-help/category.txt:68
#, no-wrap
#, fuzzy, 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>"
"Колесный орга-стрелок\n"
"<button 154/>   <code><a object|botoc>TrackedOrgaShooter</a>     </code>"
"Гусеничный орга-стрелок\n"
"<button 155/>   <code><a object|botoj>WingedOrgaShooter</a>      </code>"
"Летающий орга-стрелок\n"
"<button 156/>   <code><a object|botos>LeggedOrgaShooter</a>      </code>"
"Шагающий орга-стрелок"

#. type: Plain text
#: cbot-help/category.txt:74
#, no-wrap
#, fuzzy, 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>"
"Саббер\n"
"<button 148/>   <code><a object|botrecy>Recycler</a>               </code>"
"Утилизатор\n"
"<button 157/>   <code><a object|botshld>Shielder</a>               </code>"
"Мобильный щит\n"
"<button 146/>   <code><a object|bottump>Thumper</a>                </code>"
"Ударник\n"
"<button 147/>   <code><a object|botphaz>PhazerShooter</a>          </code>"
"Фазовый стрелок"

#. type: \t; header
#: cbot-help/category.txt:76
#, no-wrap
#, fuzzy, no-wrap
msgid "Enemies :"
msgstr "Враги :"

#. type: Plain text
#: cbot-help/category.txt:84
#, no-wrap
#, fuzzy, 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>Королева Чужих\n"
"       <code><a object|egg>AlienEgg</a>           </code>Яйцо чужого\n"
"       <code><a object|ant>AlienAnt</a>           </code>Муравей\n"
"       <code><a object|spider>AlienSpider</a>        </code>Паук\n"
"       <code><a object|wasp>AlienWasp</a>          </code>Оса\n"
"       <code><a object|worm>AlienWorm</a>          </code>Червь"

#. type: \t; header
#: cbot-help/category.txt:86
#, no-wrap
#, fuzzy, no-wrap
msgid "Miscellaneous :"
msgstr "Разное:"

#. type: Plain text
#: cbot-help/category.txt:93
#, no-wrap
#, fuzzy, 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>Вы!\n"
"       <code><a object|mine>Mine</a>            </code>Мина\n"
"       <code><a object|barrier>Barrier</a>         </code>Барьер\n"
"       <code><a object|wreck>Wreck</a>           </code>Обломки\n"
"       <code><a object|ruin>Ruin</a>            </code>Руины"

#. type: \t; header
#: cbot-help/category.txt:95
#, no-wrap
#, fuzzy, no-wrap
msgid "Flags and Other Indicators :"
msgstr "Флаги и другие индикаторы:"

#. type: Plain text
#: cbot-help/category.txt:106
#, no-wrap
#, fuzzy, 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|enerspot>EnergySite</a>        </code>Underground "
"Energy Deposit\n"
"       <code><a object|stonspot>TitaniumSite</a>      </code>Underground "
"Titanium Deposit\n"
"       <code><a object|uranspot>UraniumSite</a>       </code>Underground "
"Uranium Deposit"
msgstr ""
"       <code><a object|flag>BlueFlag</a>          </code>Синий Флаг\n"
"       <code><a object|flag>RedFlag</a>           </code>Красный Флаг\n"
"       <code><a object|flag>GreenFlag</a>         </code>Зеленый Флаг\n"
"       <code><a object|flag>YellowFlag</a>        </code>Желтый Флаг\n"
"       <code><a object|flag>VioletFlag</a>        </code>Фиолетовый Флаг\n"
"       <code><a object|waypoint>WayPoint</a>          </code>Отметка\n"
"       <code><a object|enerspot>EnergySite</a>        </code>Подземный запас "
"энергии\n"
"       <code><a object|stonspot>TitaniumSite</a>      </code>Подземный запас "
"титана\n"
"       <code><a object|uranspot>UraniumSite</a>       </code>Подземный запас "
"урана"

#. type: Plain text
#: cbot-help/category.txt:108
#, no-wrap
#, fuzzy, no-wrap
msgid "<a cbot>CBOT Language</a> and <a cbot|type>Variables</a>."
msgstr "<a cbot>Язык CBOT</a> и <a cbot|type>Переменные</a>."

#. type: \b; header
#: cbot-help/class.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>class</code>"
msgstr "Инструкция <code>class</code>"

#. type: Plain text
#: cbot-help/class.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid "This allows you to declare a class definition using following syntax:"
msgstr "Синтаксис:"

#. type: \s; block (usually verbatim code)
#: cbot-help/class.txt:8
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"public class ClassName\n"
"{\n"
"\tdeclarations;\n"
"}"
msgstr ""
"public class ClassName\n"
"{\n"
"\tdeclarations;\n"
"}"

#. type: Plain text
#: cbot-help/class.txt:10
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Classes can only be <a cbot|public>public</a>, that is they can be used from "
"all bots in a mission. Class members are also public, that is they are "
"accessible from outside the class. Class members can be fields or functions "
"(also called methods), for example the followin class <code>MyClass</code> "
"contains 4 fields (a, b, x and s) and one method (MyFunction)."
msgstr ""
"Классы должны быть <a cbot|public>общедоступными</a>, таким образом они "
"могут быть исползованы всеми ботами в любой миссии. Члены класса также "
"должны быть общедоступными, тоесть должны быть доступны за пределами класса. "
"Членами класса могут быть ячейки и функции (по-другому методы), например "
"следующий класс <code>MyClass</code> содержит 4 ячейки (a, b, x и s) и один "
"метод (MyFunction)."

#. type: \s; block (usually verbatim code)
#: cbot-help/class.txt:21
#, no-wrap
#, fuzzy, 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 ""
"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"
"}"

#. type: Plain text
#: cbot-help/class.txt:23
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"As shown in this exemple the class members can be initialized "
"(<code>x=3.33</code>). You can also define a constructor which is a special "
"method having the same name as the class name. This method will be called "
"automatically at creation time of a class instance. You can also declare "
"more than one method with the same name but different parameters."
msgstr ""
"ак показано в данном примере члены класса могут быть инициализированы "
"(<code>x=3.33</code>). Вы можете также определить конструктор, который "
"представляет собой специальный метод, имеющий то же имя, как и имя класса. "
"Этот метод будет вызван автоматически в момент создания экземпляра класса. "
"Вы можете также объявить более одного метода с тем же именем, но с разными "
"параметрами."

#. type: \s; block (usually verbatim code)
#: cbot-help/class.txt:36
#, no-wrap
#, fuzzy, 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 ""
"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"
"}"

#. type: Plain text
#: cbot-help/class.txt:38
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"In this example two constructors are declared for <code>MyClass</code>, one "
"without parameters and the other one with two parameters. As the names of "
"the parameters of the second constructor are the same as the names of the "
"two members <code>a</code> et <code>b</code> we must use the <code><a "
"cbot|this>this</a>.a</code> and <code><a cbot|this>this</a>.b</code> to "
"avoid confusion with the parameters. Another more simpler solution would be "
"to give different names to the parameters."
msgstr ""
"В этом примере два конструктора были объявлены как <code>MyClass</code>, "
"один без параметров и второй с двумя параметрами. Поскольку имена параметров "
"второго конструктора такие же, как и имена двух членов <code>a</code> и "
"<code>b</code> мы должны использовать <code><a cbot|this>this</a>.a</code> и "
"<code><a cbot|this>this</a>.b</code> чтобы избежать путаницы с параметрами. "
"Наболее простым решением было бы дать разные имена параметрам."

#. type: \s; block (usually verbatim code)
#: cbot-help/class.txt:46
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"void Test( )\n"
"{\n"
"\tMyClass item1();      // constr. w/o parameters\n"
"\tMyClass item2(4, 5);  // constr. with 2 parameters\n"
"\tMyClass item3;        // no constructor called,\n"
"                          // therefore item3 == null\n"
"}"
msgstr ""
"void Test( )\n"
"{\n"
"\tMyClass item1();      // конструктор без параметров\n"
"\tMyClass item2(4, 5);  // конструктор с двумя параметрами\n"
"\tMyClass item3;        // нет вызова конструктора,\n"
"                          // поэтому item3 == null\n"
"}"

#. type: Plain text
#: cbot-help/class.txt:48
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"You can also define a destructor. This must be a <code>void</code> fonction "
"without parameters that has the same name as the class name but prefixed by "
"the ~ character. The destructor is called automatically as soon as the class "
"instance is no more referenced by anyone."
msgstr ""
"Вы также можете определить деструктор. Это должна быть "
"<code>пустая(void)</code> функция без параметров, имеющая то же имя, что и "
"класс, но с первиксом ~. Деструктор вызывается автоматически, как только "
"класс уже больше никому не понадобится."

#. type: \s; block (usually verbatim code)
#: cbot-help/class.txt:67
#, no-wrap
#, fuzzy, 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"
"void Test()\n"
"{\n"
"\tMyClass item1( );  // counter = 1\n"
"\tMyClass item2( );  // counter = 2\n"
"\titem1 = null;      // counter = 1\n"
"}                      // counter = 0"
msgstr ""
"public class MyClass\n"
"{\n"
"\tstatic private int counter = 0; // инициализируем счетчик\n"
"\tvoid  MyClass( )\n"
"\t{\n"
"\t\tcounter ++;  // увеличиваем\n"
"\t}\n"
"\tvoid ~MyClass( )\n"
"\t{\n"
"\t\tcounter --;  // уменьшаем\n"
"\t}\n"
"}\n"
"void Test()\n"
"{\n"
"\tMyClass item1( );  // счетчик = 1\n"
"\tMyClass item2( );  // счетчик = 2\n"
"\titem1 = null;      // счетчик = 1\n"
"}                      // счетчик = 0"

#. type: Plain text
#: cbot-help/class.txt:69
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"If you pass a class instance as parameter to a <a "
"cbot|function>function</a>, the function only receives a <a "
"cbot|pointer>reference</a> to the instance. That means if you modify the "
"instance in the function, the instance that has been passed to the function "
"will be actuallay modified."
msgstr ""
"If you pass a class instance as parameter to a <a cbot|function>function</a>"
", the function only receives a <a cbot|pointer>reference</a> to the "
"instance. That means if you modify the instance in the function, the "
"instance that has been passed to the function will be actuallay modified."

#. type: Plain text
#: cbot-help/class.txt:72
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"<code><a cbot|public>public</a></code>, <code><a "
"cbot|private>private</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>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a "
"cbot|category>categories</a>."
msgstr ""
"<code><a cbot|public>Общедоступное</a></code>, <code><a "
"cbot|private>приватное</a></code>, <code><a cbot|static>статичное</a></code>"
", <code><a cbot|synchro>синхронизированное</a></code>, <code><a "
"cbot|new>новое</a></code>, <code><a cbot|pointer>ссылка</a></code>, <code><a "
"cbot|this>это</a></code>\n"
"<a cbot>Язык CBOT</a> и <a cbot|type>Переменные</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/close.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>close</code>"
msgstr "Инструкция <code>close</code>"

#. type: Plain text
#: cbot-help/close.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Закрывает файл, открытый ранее функцией<code><a cbot|open>open</a></code>. "
"Это метод класса <code><a cbot|file>file</a></code>; поэтому вы не можете "
"записывать  <code>close()</code>, только <code>handle.close()</code>¦:"

#. type: \s; block (usually verbatim code)
#: cbot-help/close.txt:5
#, no-wrap
#, fuzzy, no-wrap
msgid "\thandle.close();"
msgstr "\thandle.close();"

#. type: Plain text
#: cbot-help/close.txt:8
#, no-wrap
#, fuzzy, 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> and <code><a cbot|eof>eof</a></code>.\n"
"<a cbot>Язык CBOT</a> и <a cbot|type>Переменные</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/cond.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Conditions"
msgstr "Условия"

#. type: Plain text
#: cbot-help/cond.txt:4
#, no-wrap
#, fuzzy, 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.\n"
"Here are some operators that you can use in conditions to compare two values "
":"
msgstr ""
"Условие - это специальное <a cbot|expr>выражение</a> которое возвращает <a "
"cbot|bool>булевое</a> значение, которое может быть либо <code><a "
"cbot|true>true</a></code> либо <code><a cbot|false>false</a></code>. Имея "
"условия, вы можете выбирать Ф. экс. если инструкции в цикле <code><a "
"cbot|while>while</a></code> должын повторяться снова, или если нужно "
"выполнить инструкцию в блоке <code><a cbot|if>if</a></code>.\n"
"Here are some operators that you can use in conditions to compare two values "
":"

#. type: Plain text
#: cbot-help/cond.txt:11
#, no-wrap
#, fuzzy, 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> равняется <code>b</code>\n"
"<code>a != b  </code><code>a</code> отличное от <code>b</code>\n"
"<code>a <  b  </code><code>a</code> меньше чем <code>b</code>\n"
"<code>a <= b  </code><code>a</code> меньше или равно <code>b</code>\n"
"<code>a >  b  </code><code>a</code> больше чем <code>b</code>\n"
"<code>a >= b  </code><code>a</code> больше или равно <code>b</code>"

#. type: Plain text
#: cbot-help/cond.txt:13
#, no-wrap
#, fuzzy, no-wrap
msgid "For example :"
msgstr "Например:"

#. type: Plain text
#: cbot-help/cond.txt:20
#, no-wrap
#, fuzzy, 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>возвращает да\n"
"<code>45 != 47  </code>возвращает да\n"
"<code>99 == 98  </code>возвращает нет\n"
"<code>12 <  -1  </code>возвращает нет\n"
"<code>12 >= 10  </code>возвращает да\n"
"<code>12 >= 12  </code>возвращает да"

#. type: \t; header
#: cbot-help/cond.txt:21
#, no-wrap
#, fuzzy, no-wrap
msgid "Remarque"
msgstr "Примечание"

#. type: Plain text
#: cbot-help/cond.txt:23
#, no-wrap
#, fuzzy, 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 ""
"Будьте внимательны и не путайте сравнение равенства <code>==</code> с "
"присвоением <a cbot|var>переменной</a> <code>=</code>."

#. type: Plain text
#: cbot-help/cond.txt:26
#, no-wrap
#, fuzzy, 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> 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>."

#. type: \b; header
#: cbot-help/continue.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>continue</code>"
msgstr "Инструкция <code>continue</code>"

#. type: \s; block (usually verbatim code)
#: cbot-help/continue.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"<c/>while ( condition )\n"
"{\n"
"\tcontinue;\n"
"}"
msgstr ""
"<c/>while ( условие )\n"
"{\n"
"\tcontinue;\n"
"}"

#. type: Plain text
#: cbot-help/continue.txt:9
#, no-wrap
#, fuzzy, 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 ""
"С помощью этой инструкции, вы можете перепрыгивать через все остальные "
"инструкции в <code><a cbot|bloc>блоке</a></code> цикла <code><a "
"cbot|while>while</a></code> или <code><a cbot|for>for</a></code> : "
"Выполнение продолжится с начала блока, в следующий раз цикл будет повторен."

#. type: \s; block (usually verbatim code)
#: cbot-help/continue.txt:21
#, no-wrap
#, fuzzy, 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/>Инструкции...<c/>\n"
"}"

#. type: Plain text
#: cbot-help/continue.txt:23
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"The instructions will only be executed for the values of <code>i</code> 1, "
"2, 4 and 5."
msgstr ""
"Инструкции будут выполнены только для значение <code>i</code> 1, 2, 4 и 5."

#. type: \b; header
#: cbot-help/deletef.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>deletefile</code>"
msgstr "Инструкция <code>deletefile</code>"

#. type: Plain text
#: cbot-help/deletef.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid "The deletefile instruction deletes an existing file in the files/ folder. "
msgstr "Инструкция deletefile удаляет существующие файлы/папки."

#. type: Plain text
#: cbot-help/deletef.txt:5
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Files can only be deleted in the files/ folder which is located in the "
"folder where Colobot has been installed. You cannot not delete files that "
"are located elsewhere than in the files/ folder."
msgstr ""
"Файлы и папки могут быть удалены только в той дирректории, в которую была "
"установлена COLOBOT. Вы не можете удалять файлы и папки, находящиеся в "
"другом месте."

#. type: \s; block (usually verbatim code)
#: cbot-help/deletef.txt:8
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>deletefile ( filename );<n/>"
msgstr "<c/>deletefile ( filename );<n/>"

#. type: \b; header
#: cbot-help/delinfo.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>deleteinfo</code>"
msgstr "Инструкция <code>deleteinfo</code>"

#. type: \s; block (usually verbatim code)
#: cbot-help/delinfo.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>deleteinfo ( name, power );<n/>"
msgstr "<c/>deleteinfo ( name, power );<n/>"

#. type: Plain text
#: cbot-help/delinfo.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Delete an existing information in the closest <a object|exchange>information "
"exchange post</a>."
msgstr ""
"Удаляет существующую информацию в ближайшем <a object|exchange>посте обмена "
"информацией</a>."

#. type: \t; header
#: cbot-help/delinfo.txt:7 cbot-help/receive.txt:7 cbot-help/send.txt:7 cbot-help/testinfo.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid "name: <code>string</code>"
msgstr "name: <code>string</code>"

#. type: Plain text
#: cbot-help/delinfo.txt:9
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Name of the information to be deleted. This name is a string: it must be "
"written in quotation marks \"¦\"."
msgstr ""
"Имя информации для удаления. Это имя - строка: она должна быть написана в "
"кавычках \"¦\"."

#. type: \t; header
#: cbot-help/delinfo.txt:10 cbot-help/receive.txt:10 cbot-help/send.txt:14 cbot-help/testinfo.txt:10
#, no-wrap
#, fuzzy, no-wrap
msgid "power: <code>float</code>"
msgstr "power: <code>float</code>"

#. type: Plain text
#: cbot-help/delinfo.txt:12
#, no-wrap
#, fuzzy, 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 ""
"Мощность передатчика, определяющая максимальное расстояние до поста. Если "
"пост находится слишком далеко, то информаация не будет удалена. Стандартное "
"значение равно 10 метрам."

#. type: Plain text
#: cbot-help/delinfo.txt:15
#, no-wrap
#, fuzzy, 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> "
"and <code><a cbot|testinfo>testinfo</a></code>.\n"
"<a cbot>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/direct.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>direction</code>"
msgstr "Инструкция <code>direction</code>"

#. type: \s; block (usually verbatim code)
#: cbot-help/direct.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>direction ( pos );<n/>"
msgstr "<c/>direction ( поз );<n/>"

#. type: Plain text
#: cbot-help/direct.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Calculates the rotation that a robot must perform in order to point towards "
"a given position. "
msgstr ""
"Вычисляет вращение, которое необходимо выполнить роботу, чтобы повернуться к "
"данной позиции."

#. type: \t; header
#: cbot-help/direct.txt:7 cbot-help/goto.txt:17
#, no-wrap
#, fuzzy, no-wrap
msgid "pos: <code><a cbot|point>point</a></code>"
msgstr "pos: <code><a cbot|point>point</a></code>"

#. type: Plain text
#: cbot-help/direct.txt:9
#, no-wrap
#, fuzzy, no-wrap
msgid "Position towards which the robot must point."
msgstr "Позиция, к которой робот должен повернуться."

#. type: \t; header
#: cbot-help/direct.txt:10 cbot-help/dist2d.txt:10 cbot-help/dist.txt:26 cbot-help/flatgrnd.txt:13 cbot-help/receive.txt:13 cbot-help/topo.txt:10
#, no-wrap
#, fuzzy, no-wrap
msgid "Return value: <code><a cbot|float>float</a></code>"
msgstr "Возвращаемое значение: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: cbot-help/direct.txt:12
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Angle of the rotation that must be performed. -90 means f. ex. a rotation of "
"90 degrees to the right. "
msgstr ""
"Угол вращения, которое нужно проделать. -90 значит ф. экс. вращение на 90 "
"градусов вправо."

#. type: \b; header
#: cbot-help/dist2d.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>distance2d</code>"
msgstr "Инструкция <code>distance2d</code>"

#. type: Plain text
#: cbot-help/dist2d.txt:3 cbot-help/dist.txt:19 cbot-help/do.txt:3 cbot-help/drop.txt:13 cbot-help/fire.txt:11 cbot-help/for.txt:3 cbot-help/goto.txt:13 cbot-help/grab.txt:13 cbot-help/if.txt:24 cbot-help/jet.txt:3 cbot-help/message.txt:3 cbot-help/move.txt:9 cbot-help/radar.txt:15 cbot-help/receive.txt:3 cbot-help/recycle.txt:3 cbot-help/retobj.txt:3 cbot-help/search.txt:3 cbot-help/shield.txt:3 cbot-help/sniff.txt:3 cbot-help/thump.txt:3 cbot-help/topo.txt:3 cbot-help/turn.txt:20 cbot-help/wait.txt:11
#, no-wrap
#, fuzzy, no-wrap
msgid "Syntax:"
msgstr "Синтаксис:"

#. type: \s; block (usually verbatim code)
#: cbot-help/dist2d.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>distance2d ( pos1, pos2 );<n/>"
msgstr "<c/>distance2d ( pos1, pos2 );<n/>"

#. type: Plain text
#: cbot-help/dist2d.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid "Calculates the distance between two positions (ignores the z coordinate)."
msgstr ""
"Рассчитывает растояние между двумя позициями (пренебрегая координатой z)."

#. type: \t; header
#: cbot-help/dist2d.txt:7 cbot-help/dist.txt:23
#, no-wrap
#, fuzzy, no-wrap
msgid "pos1, pos2: <code><a cbot|point>point</a></code>"
msgstr "pos1, pos2: <code><a cbot|point>point</a></code>"

#. type: Plain text
#: cbot-help/dist2d.txt:9 cbot-help/dist.txt:25
#, no-wrap
#, fuzzy, no-wrap
msgid "Coordinates of the two positions. "
msgstr "Коодинаты двух позиций."

#. type: Plain text
#: cbot-help/dist2d.txt:12 cbot-help/dist.txt:28
#, no-wrap
#, fuzzy, no-wrap
msgid "Distance between the two positions."
msgstr "расстояние между двумя позициями."

#. type: \b; header
#: cbot-help/dist.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>distance</code>"
msgstr "Инструкция <code>distance</code>"

#. type: Plain text
#: cbot-help/dist.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"With the instruction <code>distance( , )</code> you can calculate the "
"distance between two positions."
msgstr ""
"С помощью инструкции <code>distance( , )</code> вы можете подсчитывать "
"расстояние между  двумя позициями."

#. type: \b; header
#: cbot-help/dist.txt:4 cbot-help/drop.txt:4 cbot-help/fire.txt:4 cbot-help/goto.txt:4 cbot-help/grab.txt:4 cbot-help/if.txt:4 cbot-help/motor.txt:4 cbot-help/move.txt:4 cbot-help/radar.txt:4 cbot-help/turn.txt:4 cbot-help/wait.txt:4 cbot-help/while.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid "Basic use"
msgstr "Основное использование"

#. type: Plain text
#: cbot-help/dist.txt:6
#, no-wrap
#, fuzzy, 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 ""
"Если вы напишете только <code>position</code>, то вы получите только позицию "
"бота, который выполняет программу. Если вы напишете имя переменной, а за ней "
"<code>.position</code>, то это даст вам позицию обьекта, который был "
"обозначен вслед за переменной."

#. type: Plain text
#: cbot-help/dist.txt:8
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Here is a program that moves forward, covering exactly the distance between "
"the bot and the closest ant:"
msgstr ""
"Ниже приведена программа для движения вперед, на вличину, в точности равную "
"расстоянию между ботом и ближайшим муравьем:"

#. type: \s; block (usually verbatim code)
#: cbot-help/dist.txt:11
#, no-wrap
#, fuzzy, 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
#: cbot-help/dist.txt:13
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"This is of course pure suicide. Better to stop 40 meters before, in order to "
"be at shooting range:"
msgstr ""
"Разумеется, это чистое самоубийство. Лучше остановиться за 40 метров вдали, "
"чтобы оказаться в радиусе стрельбы:"

#. type: \s; block (usually verbatim code)
#: cbot-help/dist.txt:16
#, no-wrap
#, fuzzy, 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
#: cbot-help/dist.txt:17 cbot-help/drop.txt:11 cbot-help/errmode.txt:4 cbot-help/file.txt:10 cbot-help/fire.txt:9 cbot-help/float.txt:19 cbot-help/goto.txt:11 cbot-help/grab.txt:11 cbot-help/if.txt:22 cbot-help/int.txt:13 cbot-help/motor.txt:14 cbot-help/move.txt:7 cbot-help/radar.txt:13 cbot-help/return.txt:9 cbot-help/turn.txt:18 cbot-help/wait.txt:9 cbot-help/while.txt:19
#, no-wrap
#, fuzzy, no-wrap
msgid "For specialists"
msgstr "Для специалистов"

#. type: \s; block (usually verbatim code)
#: cbot-help/dist.txt:20
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>distance ( pos1, pos2 );<n/>"
msgstr "<c/>distance ( pos1, pos2 );<n/>"

#. type: Plain text
#: cbot-help/dist.txt:22
#, no-wrap
#, fuzzy, no-wrap
msgid "Calculates the distance between two positions. "
msgstr "Рассчитывает растояние между двумя позициями."

#. type: \b; header
#: cbot-help/do.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>do - while</code>"
msgstr "Инструкция <code>do - while</code>"

#. type: \s; block (usually verbatim code)
#: cbot-help/do.txt:8
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"<code>do\n"
"{\n"
"\t</code>Instructions ...<c/>\n"
"}\n"
"while ( condition );"
msgstr ""
"<code>do\n"
"{\n"
"\t</code>Инструкции ...<c/>\n"
"}\n"
"while ( условие );"

#. type: Plain text
#: cbot-help/do.txt:11
#, no-wrap
#, fuzzy, 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 ""
"Эта инструкция позволяет несколько раз выполнять инструкции внутри <a "
"cbot|bloc>блока</a>. Инструкции выполняются как минимум один раз, поскольку "
"условие выполняется только потом.\n"
"Не путайте инструкцию <c/>do { } while ( );<n/> с инструкцией <code><a "
"cbot|while>while</a> ( ) { }</code>; последняя проверяет условие до того как "
"выполняются инструкции внутри блока."

#. type: \t; header
#: cbot-help/do.txt:12 cbot-help/for.txt:13 cbot-help/while.txt:30
#, no-wrap
#, fuzzy, no-wrap
msgid "<code>condition</code>"
msgstr "<code>условие</code>"

#. type: Plain text
#: cbot-help/do.txt:14 cbot-help/while.txt:32
#, no-wrap
#, fuzzy, 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 ""
"Инструкции в блоке будут выполняться снова и снова, пока <a "
"cbot|cond>условие</a> будет выполняться, то есть будет правдивым."

#. type: Plain text
#: cbot-help/do.txt:16 cbot-help/while.txt:34
#, no-wrap
#, fuzzy, no-wrap
msgid "Here is an example :"
msgstr "Вот пример :"

#. type: \s; block (usually verbatim code)
#: cbot-help/do.txt:21
#, no-wrap
#, fuzzy, 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
#: cbot-help/do.txt:22 cbot-help/float.txt:11 cbot-help/for.txt:33 cbot-help/if.txt:36 cbot-help/int.txt:10 cbot-help/while.txt:41
#, no-wrap
#, fuzzy, no-wrap
msgid "Attention"
msgstr "Внимание"

#. type: Plain text
#: cbot-help/do.txt:24
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Always put a <a cbot|term>semicolon</a> at the end of the line <code>while ( "
")</code>."
msgstr ""
"Всегда следует ставить <a cbot|term>двоеточие</a> в конце строки с <code>"
"while ( )</code>."

#. type: Plain text
#: cbot-help/do.txt:26
#, no-wrap
#, fuzzy, 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 ""
"Инструкции <code><a cbot|break>break</a></code> и <code><a "
"cbot|continue>continue</a></code> могут пригодиться внутри блока после "
"инструкции <code>do { }</code>."

#. type: \b; header
#: cbot-help/drop.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>drop</code>"
msgstr "Инструкция <code>drop</code>"

#. type: Plain text
#: cbot-help/drop.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Инструкция <c/>drop();<n/> приказывает боту бросить все, что находися в "
"данный момент в рабочей руке, на землю, на платформу здания, или на "
"расположение энергобатарейки бота."

#. type: Plain text
#: cbot-help/drop.txt:6
#, no-wrap
#, fuzzy, 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 ""
"Инструкция <c/>drop();<n/> написанная таким образом заставит бот бросить "
"обьект прямо перед собой. Ниже приведена короткая программа, в которой бот "
"берет обьект перед собой, и кладет его на землю в пяти метрах от себя:"

#. type: \s; block (usually verbatim code)
#: cbot-help/drop.txt:10
#, no-wrap
#, fuzzy, 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: \s; block (usually verbatim code)
#: cbot-help/drop.txt:14
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>drop ( oper );<n/>"
msgstr "<c/>drop ( oper );<n/>"

#. type: Plain text
#: cbot-help/drop.txt:16
#, no-wrap
#, fuzzy, 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 ""
"Эта инструкция обращается к рабочей руке <a object|botgr>бота носильщика</a>"
", и приказывает ей положить все что она держит."

#. type: \t; header
#: cbot-help/drop.txt:17 cbot-help/grab.txt:17
#, no-wrap
#, fuzzy, 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> (default value<code>InFront</code>)"

#. type: Plain text
#: cbot-help/drop.txt:22
#, no-wrap
#, fuzzy, 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 обозначает, где именно бот должен бросить предмет. Если не обозначить "
"это место, обьект будет положен прямо перед ботом.\n"
"<code>InFront   </code>  Кладет перед ботом (значение по умолчанию).\n"
"<code>Behind    </code>  Кладет позади.\n"
"<code>EnergyPack</code>  Кладет на место расположеня собственной "
"энергобатареи бота."

#. type: Plain text
#: cbot-help/drop.txt:27
#, no-wrap
#, fuzzy, 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 ""
"Обычно в случае ошибки выполнение программы прекращается. Вы можете сделать "
"так, что в случае ошибки программа не будет останавливаться, для чего "
"используется инструкция <code><a cbot|errmode>errmode</a>(0)</code> . В "
"случае ошибки <c/>drop();<n/> возвращает значение отличное от нуля.\n"
"<code>== 0 </code>обьект был брошен\n"
"<code>!= 0 </code>ошибка, обьект не был брошен"

#. type: \b; header
#: cbot-help/eof.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>eof</code>"
msgstr "Инструкция <code>eof</code>"

#. type: Plain text
#: cbot-help/eof.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Проверяет конец открытого файла. Это метод класса <code><a "
"cbot|file>file</a></code>; вы не можете писать  <code>eof()</code>, только "
"<code>handle.eof()</code>¦:"

#. type: \s; block (usually verbatim code)
#: cbot-help/eof.txt:5
#, no-wrap
#, fuzzy, no-wrap
msgid "\tif ( handle.eof() )  "
msgstr "\tif ( handle.eof() )"

#. type: Plain text
#: cbot-help/eof.txt:7 cbot-help/readln.txt:12
#, no-wrap
#, fuzzy, no-wrap
msgid "Example¦:"
msgstr "Пример¦:"

#. type: \s; block (usually verbatim code)
#: cbot-help/eof.txt:12
#, no-wrap
#, fuzzy, 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
#: cbot-help/eof.txt:15
#, no-wrap
#, fuzzy, 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> "
"and <code><a cbot|writeln>writeln</a></code>.\n"
"<a cbot>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/errmode.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>errmode</code>"
msgstr "Инструкция <code>errmode</code>"

#. type: Plain text
#: cbot-help/errmode.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Инструкция <c/>errmode();<n/> позволяет вам определять, будет ли "
"останавливаться программа в случае возникновения ошибки в одной из следующих "
"инструкций: <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."

#. type: \s; block (usually verbatim code)
#: cbot-help/errmode.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>errmode ( mode );<n/>"
msgstr "<c/>errmode ( mode );<n/>"

#. type: Plain text
#: cbot-help/errmode.txt:9
#, no-wrap
#, fuzzy, 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 ""
"Обычно в случае ошибки выполнение программы прекращается. Если вы "
"воспользуетесь инструкцией <c/>errmode(0);<n/> в начале программы, "
"инструкции перечисленныен выше возвращают значение отличное от нуля, если "
"инструкцию было невозможно выполенить."

#. type: \t; header
#: cbot-help/errmode.txt:10
#, no-wrap
#, fuzzy, no-wrap
msgid "mode: <code><a cbot|float>float</a></code> (<code>1</code> per default)"
msgstr ""
"mode: <code><a cbot|float>float</a></code> (<code>1</code> по умолчанию)"

#. type: Plain text
#: cbot-help/errmode.txt:14
#, no-wrap
#, fuzzy, 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 ""
"Ошибка режима обработки.\n"
"<code>0</code> -> продолжает выполнение программы и возвращает значение "
"отличное от нуля\n"
"<code>1</code> -> останавливает программу (поведение по умолчанию)"

#. type: Plain text
#: cbot-help/errmode.txt:16
#, no-wrap
#, fuzzy, no-wrap
msgid "Exemple 1¦:"
msgstr "Пример 1¦:"

#. type: \s; block (usually verbatim code)
#: cbot-help/errmode.txt:21
#, no-wrap
#, fuzzy, 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
#: cbot-help/errmode.txt:23
#, no-wrap
#, fuzzy, no-wrap
msgid "Exemple 2¦:"
msgstr "Пример 2¦:"

#. type: \s; block (usually verbatim code)
#: cbot-help/errmode.txt:31
#, no-wrap
#, fuzzy, 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(pos);\n"
"if ( err != 0 )\n"
"{\n"
"\t<n/>инструкция goto была выполнена некоррректно...<code>\n"
"\t</code>предпримите меры...<c/>\n"
"}"

#. type: \b; header
#: cbot-help/expr.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Expressions"
msgstr "Выражения"

#. type: Plain text
#: cbot-help/expr.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid "Expressions can include the following operators: "
msgstr "Выражения могут включать следующие операторы:"

#. type: Plain text
#: cbot-help/expr.txt:9
#, no-wrap
#, fuzzy, 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>  сложение\n"
"<code>-</code>  вычитание\n"
"<code>*</code>  умножение\n"
"<code>/</code>  деление\n"
"<code>%</code>  остаток деления (только для типа <code><a "
"cbot|int>int</a></code>)"

#. type: Plain text
#: cbot-help/expr.txt:11
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"With the addition operator <code>+</code>, you can not only add numbers, you "
"can also append <a cbot|string>strings</a>."
msgstr ""
"При помощи оператора сложения <code>+</code>, вы можете складывать не только "
"числа, но также можете присоединять <a cbot|string>строки</a>."

#. type: \s; block (usually verbatim code)
#: cbot-help/expr.txt:21
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"\tint    i = 12+3;      // returns 15\n"
"\tstring s = \"a\"+\"bc\";  // returns \"abc\"\n"
"\tint    i = 2-5;       // returns -3\n"
"\tfloat  f = 3.01*10;   // returns 30.1\n"
"\tint    i = 5/3;       // returns 1\n"
"\tfloat  f = 5/3;       // returns 1.67\n"
"\tfloat  f = 5/0;       // returns an error\n"
"\tint    i = 13%5;      // returns 3\n"
"\tint    i = -8%3;      // returns -2"
msgstr ""
"\tint    i = 12+3;      // возвращает 15\n"
"\tstring s = \"a\"+\"bc\";  // возвращает \"abc\"\n"
"\tint    i = 2-5;       // возвращает -3\n"
"\tfloat  f = 3.01*10;   // возвращает 30.1\n"
"\tint    i = 5/3;       // возвращает 1\n"
"\tfloat  f = 5/3;       // возвращает 1.67\n"
"\tfloat  f = 5/0;       // возвращает ошибку\n"
"\tint    i = 13%5;      // возвращает 3\n"
"\tint    i = -8%3;      // возвращает -2"

#. type: Plain text
#: cbot-help/expr.txt:23
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"An expression can include constants or <a cbot|var>variables</a>. For "
"example:"
msgstr ""
"Выражение может содержать постоянные и <a cbot|var>переменные</a>. Например:"

#. type: \s; block (usually verbatim code)
#: cbot-help/expr.txt:25
#, no-wrap
#, fuzzy, no-wrap
msgid "<code>\t12+dist</code>"
msgstr "<code>\t12+dist</code>"

#. type: Plain text
#: cbot-help/expr.txt:27
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Multiplications and divisions are performed before additions and "
"subtractions. In order to be sure that the operations are performed in the "
"right order, use brackets: "
msgstr ""
"Умножение и деление выполняется перед сложением и вычитанием. Чтобы "
"убедиться, что операции выполняются в правильном порядке, используйте скобки:"

#. type: \s; block (usually verbatim code)
#: cbot-help/expr.txt:30
#, no-wrap
msgid ""
"\t12*a+b/c <n/>is equivalent to<c/> (12*a)+(b/c)\n"
"\t2.5*(dist+range)"
msgstr ""

#. type: Plain text
#: cbot-help/expr.txt:32
#, no-wrap
#, fuzzy, no-wrap
msgid "In order to improve readability, you can put as many spaces as you want: "
msgstr "Чтобы улучшить читаемость, можете добавлять сколько угодно пробелов:"

#. type: \s; block (usually verbatim code)
#: cbot-help/expr.txt:35
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"\t12*a + b/c\n"
"\t2.5 * (dist+range)"
msgstr ""
"\t12*a + b/c\n"
"\t2.5 * (расст+рад)"

#. type: Plain text
#: cbot-help/expr.txt:37
#, no-wrap
#, fuzzy, no-wrap
msgid "Here is a list of mathematical functions: "
msgstr "Ниже приведет список математических функций:"

#. type: Plain text
#: cbot-help/expr.txt:47
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"<code>sin(angle)    </code>sinus\n"
"<code>cos(angle)    </code>cosinus\n"
"<code>tan(angle)    </code>tangent\n"
"<code>asin(value)   </code>arc-sinus\n"
"<code>acos(value)   </code>arc-cosinus\n"
"<code>atan(value)   </code>arc-tangente\n"
"<code>sqrt(value)   </code>square root\n"
"<code>pow(x, y)     </code>x power y\n"
"<code>rand()        </code>random value ranging between 0 and 1"
msgstr ""
"<code>sin(angle)    </code>синус\n"
"<code>cos(angle)    </code>косинус\n"
"<code>tan(angle)    </code>тангенс\n"
"<code>asin(value)   </code>арксинус\n"
"<code>acos(value)   </code>арккосинус\n"
"<code>atan(value)   </code>арктангенс\n"
"<code>sqrt(value)   </code>квадратный корень\n"
"<code>pow(x, y)     </code>x в степени y\n"
"<code>rand()        </code>случайное число между 0 и 1"

#. type: Plain text
#: cbot-help/expr.txt:49
#, no-wrap
#, fuzzy, no-wrap
msgid "Angles are in degrees."
msgstr "Углы отображаются в градусах."

#. type: \t; header
#: cbot-help/expr.txt:50
#, no-wrap
msgid "Compound assignment operators (for specialists)"
msgstr ""

#. type: Plain text
#: cbot-help/expr.txt:52
#, no-wrap
msgid ""
"Besides the <code>=</code> operators for variable assignment there are "
"several compound-assignment operators."
msgstr ""

#. type: Plain text
#: cbot-help/expr.txt:54
#, 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: Plain text
#: cbot-help/expr.txt:56
#, no-wrap
msgid "<c/><s/>expression1 += expression2"
msgstr ""

#. type: Plain text
#: cbot-help/expr.txt:58
#, no-wrap
msgid "is equivalent to"
msgstr ""

#. type: Plain text
#: cbot-help/expr.txt:60
#, no-wrap
msgid "<c/><s/>expression1 = expression1 + expression2"
msgstr ""

#. type: Plain text
#: cbot-help/expr.txt:66
#, 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
#: cbot-help/expr.txt:67
#, no-wrap
msgid "Prefix and posfix increment- and decrement operators (for specialists)"
msgstr ""

#. type: Plain text
#: cbot-help/expr.txt:69
#, 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 ""

#. type: Plain text
#: cbot-help/expr.txt:74
#, no-wrap
msgid ""
"For example to increment the variable <code>a</code> you can write\n"
"<c/><s/>\ta++ ;\n"
"<n/>instead of\n"
"<c/><s/>\ta = a + 1 ;"
msgstr ""

#. type: Plain text
#: cbot-help/expr.txt:76
#, no-wrap
msgid ""
"The value of the expression <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 value of the expression 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
#: cbot-help/expr.txt:79
#, no-wrap
msgid ""
"Examples:\n"
"<c/><s/>\ta = 2 ;"
msgstr ""

#. type: \s; block (usually verbatim code)
#: cbot-help/expr.txt:81
#, no-wrap
msgid ""
"\tb = a++ ;\n"
"\t// now b contains 2 and a contains 3"
msgstr ""

#. type: Plain text
#: cbot-help/expr.txt:83
#, no-wrap
msgid "<c/><s/>\ta = 2 ;"
msgstr ""

#. type: \s; block (usually verbatim code)
#: cbot-help/expr.txt:85
#, no-wrap
msgid ""
"\tb = ++a ;\n"
"\t// now b contains 3 and a contains 3"
msgstr ""

#. type: \b; header
#: cbot-help/extern.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>extern</code>"
msgstr "Инструкция <code>extern</code>"

#. type: Plain text
#: cbot-help/extern.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Инструкция <code>extern</code> определяет <a cbot|function>функцию</a>, "
"которая будет основной в программе бота. Имя функции, объявленой с помощью "
"<code>extern</code>. появится в списке ваших программ в левом нижнем углу "
"экрана."

#. type: \s; block (usually verbatim code)
#: cbot-help/extern.txt:12
#, no-wrap
#, fuzzy, 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
#: cbot-help/extern.txt:14
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"If the program contains other functions, only the main function must be "
"preceded by <code>extern</code>."
msgstr ""
"Если программа содержит другие функции, то им должна предшествовать "
"<code>extern</code>."

#. type: \s; block (usually verbatim code)
#: cbot-help/extern.txt:28
#, no-wrap
#, fuzzy, 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
#: cbot-help/false.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Type <code>false</code>"
msgstr "Тип <code>false</code>"

#. type: Plain text
#: cbot-help/false.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Это значение оббозначает, что условие не соблюдается; это одно из двух "
"значений, которые могут принимать <a cbot|bool>булевые</a> <a "
"cbot|var>переменные</a> ."

#. type: \b; header
#: cbot-help/file.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Type <code>file</code>"
msgstr "Тип <code>file</code>"

#. type: Plain text
#: cbot-help/file.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid "This type is used for accessing files in the files/ folder."
msgstr "Этот тип используется для доступа к файлам/папкам."

#. type: \s; block (usually verbatim code)
#: cbot-help/file.txt:5
#, no-wrap
#, fuzzy, no-wrap
msgid "\tfile handle();"
msgstr "\tfile handle();"

#. type: Plain text
#: cbot-help/file.txt:7
#, no-wrap
#, fuzzy, 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 ""
"Используйте синтаксис для объявления дескриптора файла. Вы должны "
"использовать () для создания класса <code>file</code>. без использования () "
"дескриптор вернет <code><a cbot|null>null</a></code>."

#. type: Plain text
#: cbot-help/file.txt:9
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Files can only be created and opened in the files/ folder which is located "
"in the folder where Colobot has been installed. You cannot not create or "
"open files elsewhere than in the files/ folder."
msgstr ""
"Файлы и папки могут быть открыты или созданы только в папке с установленной "
"игрой COLOBOT. Вы не можете удалять папки за пределами этой дирректории."

#. type: Plain text
#: cbot-help/file.txt:12
#, no-wrap
#, fuzzy, 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> на самом деле не просто тип, а класс. <code>open</code>, "
"<code>close</code>, <code>writeln</code> и т.п. - это все методы класса "
"<code>file</code>. Это причина, почему мы всегда пишем "
"<code>handle.method()</code>¦:"

#. type: \s; block (usually verbatim code)
#: cbot-help/file.txt:15
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"\thandle.open(\"test.txt\", \"w\");\n"
"\thandle.close();"
msgstr ""
"\thandle.open(\"test.txt\", \"w\");\n"
"\thandle.close();"

#. type: Plain text
#: cbot-help/file.txt:18
#, no-wrap
#, fuzzy, 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> and <code><a cbot|eof>eof</a></code>.\n"
"<a cbot>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/fire.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>fire</code>"
msgstr "Инструкция <code>fire</code>"

#. type: Plain text
#: cbot-help/fire.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid "The instruction <c/>fire();<n/> fires the bot's onboard cannon."
msgstr "Инструкция <c/>fire();<n/> стреляет бортовой пушкой бота."

#. type: Plain text
#: cbot-help/fire.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid "Generally this instruction is used to shoot one-second bursts:"
msgstr "Обычно эта инструкция используется для стрельбы односекундными залпами:"

#. type: \s; block (usually verbatim code)
#: cbot-help/fire.txt:8
#, no-wrap
#, fuzzy, no-wrap
msgid "\tfire(1);"
msgstr "\tfire(1);"

#. type: \s; block (usually verbatim code)
#: cbot-help/fire.txt:12
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>fire ( time );<n/>"
msgstr "<c/>fire ( время );<n/>"

#. type: Plain text
#: cbot-help/fire.txt:14
#, no-wrap
#, fuzzy, 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: \n"
msgstr ""
"Стреляет из оружия, причем залп продолжается некоторое время. Чем дольше "
"залп, тем больше энергии ему нужно. Эта инструкция может применяться к "
"следующим типам ботов:\n"

#. type: Plain text
#: cbot-help/fire.txt:21
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"In order to move the gun upward or downward, use the instruction <code><a "
"cbot|aim>aim</a></code>."
msgstr ""
"Чтобы сдвинуть оружие вниз или вверх, используйте инструкцию <code><a "
"cbot|aim>aim</a></code>."

#. type: \t; header
#: cbot-help/fire.txt:22 cbot-help/wait.txt:15
#, no-wrap
#, fuzzy, no-wrap
msgid "time: <code><a cbot|float>float</a></code>"
msgstr "время: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: cbot-help/fire.txt:24
#, no-wrap
#, fuzzy, 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 ""
"Длительность залпа. Обычно, присваемое значение равно 1. В целях экономии "
"времени и энергии можно производить боле короткие залпы."

#. type: Plain text
#: cbot-help/fire.txt:29
#, no-wrap
#, fuzzy, 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 ""
"Ноль если OK, или значение отличное от нуля, если произошла ошибка.\n"
"<code>== 0 </code>пушка выстрелила\n"
"<code>!= 0 </code>ошибка, пушка не смогла выстрелить"

#. type: \b; header
#: cbot-help/flatgrnd.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>flatground</code>"
msgstr "Инструкция <code>flatground</code>"

#. type: \s; block (usually verbatim code)
#: cbot-help/flatgrnd.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>flatground ( center, rmax );<n/>"
msgstr "<c/>flatground ( center, rmax );<n/>"

#. type: Plain text
#: cbot-help/flatgrnd.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Calculates the maximal radius of a flat zone on which a building ca be "
"built."
msgstr ""
"Подсчитывает максимальный радиус плоской зоны, на которой может быть что-"
"либо построено."

#. type: \t; header
#: cbot-help/flatgrnd.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid "center: <code><a cbot|point>point</a></code>"
msgstr "center: <code><a cbot|point>point</a></code>"

#. type: Plain text
#: cbot-help/flatgrnd.txt:9
#, no-wrap
#, fuzzy, no-wrap
msgid "Center of the circlular zone."
msgstr "Центр зона (зона - круг)."

#. type: \t; header
#: cbot-help/flatgrnd.txt:10
#, no-wrap
#, fuzzy, no-wrap
msgid "rmax: <code><a cbot|float>float</a></code>"
msgstr "rmax: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: cbot-help/flatgrnd.txt:12
#, no-wrap
#, fuzzy, no-wrap
msgid "Maximal radius."
msgstr "Максимальный радиус."

#. type: Plain text
#: cbot-help/flatgrnd.txt:15
#, no-wrap
#, fuzzy, no-wrap
msgid "Radius of the flat zone (always between 0 and rmax)."
msgstr "Радиус плоской зоны (всегда от 0 до rmax)."

#. type: \b; header
#: cbot-help/float.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Type <code>float</code>"
msgstr "Тип <code>float</code>"

#. type: Plain text
#: cbot-help/float.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Используйте этот тип для большинства переменных, содержащих числа. "
"Переменные этого типа могут содержать положительные и отрицательные числа, "
"целые и дробные, ф. экс.:"

#. type: \s; block (usually verbatim code)
#: cbot-help/float.txt:8
#, no-wrap
#, fuzzy, 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
#: cbot-help/float.txt:10
#, no-wrap
#, fuzzy, 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 ""
"Если вамнужно, чтобы переменная содержала только  целые числа (ф. экс. 12 "
"или -5000), вам стоит использовать  <code><a cbot|int>int</a></code>."

#. type: Plain text
#: cbot-help/float.txt:13
#, no-wrap
#, fuzzy, 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 ""
"Не вставляйте знаки пробелов или запятых в написание числа. Чтоюы отделить "
"целую часть от дробной, используйте точки."

#. type: \s; block (usually verbatim code)
#: cbot-help/float.txt:18
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"   Write       and not\n"
"   12.56       12 . 56\n"
"  -54.34       -54,34\n"
"12895.69    12,895.69"
msgstr ""
"   Писать       а не\n"
"   12.56       12 . 56\n"
"  -54.34       -54,34\n"
"12895.69    12,895.69"

#. type: Plain text
#: cbot-help/float.txt:23
#, no-wrap
#, fuzzy, 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 ""
"Числа с плавающей запятой представлены в игре в 32 битах.\n"
"Наивысшее значение, которое можно представить - 3.4E+38.\n"
"Наименьшее значение, которое можно представить - 3.4E-38."

#. type: \b; header
#: cbot-help/for.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>for</code>"
msgstr "Инструкция <code>for</code>"

#. type: \s; block (usually verbatim code)
#: cbot-help/for.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"<c/>for ( before ; condition ; end )\n"
"{\n"
"\t<n/>Instructions ...<c/>\n"
"}"
msgstr ""
"<c/>for ( before ; condition ; end )\n"
"{\n"
"\t<n/>Инструкции...<c/>\n"
"}"

#. type: Plain text
#: cbot-help/for.txt:9
#, no-wrap
#, fuzzy, 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 ""
"Эта инструкция позволяет вам выполнять инструкции содержащиеся в <a "
"cbot|bloc>блоке</a> определенное количество раз."

#. type: \t; header
#: cbot-help/for.txt:10
#, no-wrap
#, fuzzy, no-wrap
msgid "<code>before</code>"
msgstr "<code>before</code>"

#. type: Plain text
#: cbot-help/for.txt:12
#, no-wrap
#, fuzzy, no-wrap
msgid "This instruction is executed before the first loop instance."
msgstr "Эта инструкция выполняется до появления первого цикла."

#. type: Plain text
#: cbot-help/for.txt:15
#, no-wrap
#, fuzzy, 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>условие</a> определяет, нужно ли выполнять следующее кольцо "
"цикла. Она проверяется в ходе выполнения каждого кольца."

#. type: \t; header
#: cbot-help/for.txt:16
#, no-wrap
#, fuzzy, no-wrap
msgid "<code>end</code>"
msgstr "<code>end</code>"

#. type: Plain text
#: cbot-help/for.txt:18
#, no-wrap
#, fuzzy, no-wrap
msgid "This instruction is executed at the end of every instance of the loop. "
msgstr "Эта инструкция выпоолняется в конце каждого кольца цикла."

#. type: Plain text
#: cbot-help/for.txt:21
#, no-wrap
msgid ""
"Example: count from 1 to 4\n"
"<c/><s/><c/>for ( i = 0 ; i <= 4 ; i++ )"
msgstr ""

#. type: \s; block (usually verbatim code)
#: cbot-help/for.txt:24
#, no-wrap
msgid ""
"{\n"
"\tmessage(i) ;\n"
"}"
msgstr ""

#. type: Plain text
#: cbot-help/for.txt:26
#, no-wrap
#, fuzzy, 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 ""
"Этот пример строго эквивалентен циклу <code>for</code>, но он использует "
"инструкцию <code><a cbot|while>while</a></code>:"

#. type: \s; block (usually verbatim code)
#: cbot-help/for.txt:32
#, no-wrap
msgid ""
"<c/>before;\n"
"while ( condition )\n"
"{\n"
"\t<n/>Instructions ...<c/>\n"
"\tend;\n"
"}"
msgstr ""

#. type: Plain text
#: cbot-help/for.txt:35
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Do not put a <a cbot|term>semicolon</a> at the end of the line <code>for ( "
")</code>."
msgstr ""
"не следует ставить <a cbot|term>двоеточие</a> в конце строки оператора <code>"
"for ( )</code>."

#. type: Plain text
#: cbot-help/for.txt:37
#, no-wrap
#, fuzzy, 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 ""
"Инструкции <code><a cbot|break>break</a></code> и <code><a "
"cbot|continue>continue</a></code> могут быть полезными внутри блока после "
"инструкции <code>for </code>."

#. type: \b; header
#: cbot-help/function.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Functions"
msgstr "Функции"

#. type: Plain text
#: cbot-help/function.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"With functions you can divide your program into several parts, each of them "
"will execute a specific task.\n"
"Let's imagine following program¦:"
msgstr ""
"С помощью функций программу можно разделить на несколько частей, которые "
"будут выполнять каждая свою работу.\n"
"Давайте представим следующую программу¦:"

#. type: \s; block (usually verbatim code)
#: cbot-help/function.txt:16
#, no-wrap
#, fuzzy, 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
#: cbot-help/function.txt:18
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"<code>send</code> and <code>wait</code> are repeated several times. So it "
"would be a good thing if we created a function that executes these two "
"instructions:"
msgstr ""
"<code>send</code> и <code>wait</code> повторяются много раз. Поэтому, мы "
"можем сделать функцию, которая заменит их:"

#. type: \s; block (usually verbatim code)
#: cbot-help/function.txt:31
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"void object::SendToPost( float op )\n"
"{\n"
"\tsend(\"order\", op, 100);\n"
"\twait(5);\n"
"}\n"
"extern void object::Remote( )\n"
"{\n"
"\tSendToPost(1);\n"
"\tSendToPost(3);\n"
"\tSendToPost(2);\n"
"\tSendToPost(4);\n"
"}"
msgstr ""
"void object::SendToPost( float op )\n"
"{\n"
"\tsend(\"order\", op, 100);\n"
"\twait(5);\n"
"}\n"
"extern void object::Remote( )\n"
"{\n"
"\tSendToPost(1);\n"
"\tSendToPost(3);\n"
"\tSendToPost(2);\n"
"\tSendToPost(4);\n"
"}"

#. type: Plain text
#: cbot-help/function.txt:33
#, no-wrap
#, fuzzy, no-wrap
msgid "A function can have paramteters¦:"
msgstr "Функции могут иметь параметры¦:"

#. type: \s; block (usually verbatim code)
#: cbot-help/function.txt:35
#, no-wrap
#, fuzzy, no-wrap
msgid "void Example( int a, float x, string s )"
msgstr "void Example( int a, float x, string s )"

#. type: Plain text
#: cbot-help/function.txt:37
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"The <code>Exemple</code> function will reveive un integer <code>a</code>, a "
"floating point number <code>x</code> and a string <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>int</code> to a function, its parameter is a copy of whatever "
"value was being passed as argument, and the function can change its "
"parameter value without affecting values in the code that invoked the "
"function."
msgstr ""
"Функция <code>Exemple</code> функция получит целое <code>a</code>, число с "
"плавающей точкой <code>x</code> и строку <code>s</code>. Параметры - это "
"ничто иное, как просто копии значений в переменных. Если вы передадите "
"<code>int</code> функции, то ее параметр станет копией этого значения, т.е. "
"функция сможет изменять эту копию незатрагивая оригинал."

#. type: Plain text
#: cbot-help/function.txt:39
#, no-wrap
#, fuzzy, 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 actuallay modified."
msgstr ""
"Если вы передадите <a cbot|class>классу</a> массив <a cbot|array>array</a> "
"как параметр функции, то функция получит только <a cbot|pointer>ссылку</a> к "
"экземпляру массива. Это означает, что если вы измените массив в функции, то "
"будет модифицирован только экземпляр этой функции."

#. type: Plain text
#: cbot-help/function.txt:41
#, no-wrap
#, fuzzy, 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 void but as a type:"
msgstr ""
"Функция может возвращать результат с помощью инструкции <code><a "
"cbot|return>return</a></code>. Поэтому функции должны быть объявлены только "
"как тип:"

#. type: \s; block (usually verbatim code)
#: cbot-help/function.txt:53
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"float Mean( float a, float b )\n"
"{\n"
"\treturn (a+b)/2;\n"
"}\n"
"\n"
"extern void object::Test( )\n"
"{\n"
"\tfloat value;\n"
"\tvalue = Mean(2, 6);\n"
"\tmessage( value );  // will display 4\n"
"}"
msgstr ""
"float Mean( float a, float b )\n"
"{\n"
"\treturn (a+b)/2;\n"
"}\n"
"\n"
"extern void object::Test( )\n"
"{\n"
"\tfloat value;\n"
"\tvalue = Mean(2, 6);\n"
"\tmessage( value );  // will display 4\n"
"}"

#. type: Plain text
#: cbot-help/function.txt:55
#, no-wrap
#, fuzzy, no-wrap
msgid "Some other examples¦:"
msgstr "Пример¦:"

#. type: \s; block (usually verbatim code)
#: cbot-help/function.txt:67
#, no-wrap
#, fuzzy, 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 \"négative\";\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 \"positive\";\n"
"\tif ( a < 0 )  return \"negative\";\n"
"\treturn \"null\";\n"
"}"

#. type: Plain text
#: cbot-help/function.txt:69
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"You can declare several functions with the same name but different "
"parameters¦:"
msgstr ""
"вы также можете объявить несколько функций с одинаковыми именами, но разными "
"параметрами¦:"

#. type: \s; block (usually verbatim code)
#: cbot-help/function.txt:79
#, no-wrap
#, fuzzy, 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 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"
"}"

#. type: Plain text
#: cbot-help/function.txt:81
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"CBOT will call either the one or the other function depending on the "
"paramteres passed."
msgstr ""
"CBOT будет вызывать ту или иную функцию так, что вызов будет зависеть отт "
"параметров.\n"
"Вы также можете объявить функцию <a cbot|public>общедоступной</a>, так что "
"ее смогут использовать остальне боты."

#. type: Plain text
#: cbot-help/function.txt:83
#, no-wrap
msgid ""
"You can also declare a function <a cbot|public>public</a> so it can be used "
"by other bots."
msgstr ""

#. type: \b; header
#: cbot-help/goto.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>goto</code>"
msgstr "Инструкция <code>goto</code>"

#. type: Plain text
#: cbot-help/goto.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid "The instruction <c/>goto();<n/> instructs the bot to reach a given position."
msgstr ""
"Инструкция <c/>goto();<n/> приказывает боту достигнуть означенной позиции."

#. type: Plain text
#: cbot-help/goto.txt:6
#, no-wrap
#, fuzzy, 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 ""
"Самое распространенное использование состоит в том, чтобы переместить бот к "
"обьекту, обнаруженному с помощью инструкции <c/><a "
"cbot|radar>radar</a>();<n/>. Если информация, добытая инструкцией <c/><a "
"cbot|radar>radar</a>();<n/> помещена в определенную переменную, напишите имя "
"этой переменной, а за ним <code>.position</code>, чтобы получить "
"местоположение обьекта. Ниже приведен пример программы, которая ищет <a "
"object|titan>титановый куб</a>, идет в его местоположение и берет его:"

#. type: \s; block (usually verbatim code)
#: cbot-help/goto.txt:10
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"\titem = <a cbot|radar>radar</a>(Titanium);\n"
"\tgoto(item.position);\n"
"\t<a cbot|grab>grab</a>();"
msgstr ""
"\titem = <a cbot|radar>radar</a>(Titanium);\n"
"\tgoto(item.position);\n"
"\t<a cbot|grab>grab</a>();"

#. type: \s; block (usually verbatim code)
#: cbot-help/goto.txt:14
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>goto ( position, altitude, goal, crash );<n/>"
msgstr "<c/>goto ( position, altitude, goal, crash );<n/>"

#. type: Plain text
#: cbot-help/goto.txt:16
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Tells the robot to go to the given position, avoiding all the obstacles if "
"this is possible. "
msgstr ""
"Приказывает роботу двигаться к выбранной позиции, избегая все препятствия, "
"если это возможно."

#. type: Plain text
#: cbot-help/goto.txt:19
#, no-wrap
#, fuzzy, no-wrap
msgid "Coordinates of the goal position."
msgstr "Координаты позиции цели."

#. type: \t; header
#: cbot-help/goto.txt:20
#, no-wrap
#, fuzzy, no-wrap
msgid "altitude: <code><a cbot|float>float</a></code>"
msgstr "altitude: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: cbot-help/goto.txt:22
#, no-wrap
#, fuzzy, 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 ""
"Высота полета для <a object|botgj>летающих ботов</a>. Высота имеет смысл "
"только для <a object|botgj>летающих ботов</a>. От начальной высоты, бот "
"забирается выше, пока не достигнет назначенной высоты. Когда он окажется "
"близко к цели, он спускается и приземляется в назначенном месте. Если "
"значение высоты не задано, по умолчанию принимается значение 10 метров. На "
"очень коротких дистанциях, даже летающий бот останется на земле. Для всех "
"ботов за исключением летающих, этот параметр игнорируется."

#. type: \t; header
#: cbot-help/goto.txt:23
#, no-wrap
#, fuzzy, no-wrap
msgid "goal: <code><a cbot|int>int</a></code> (default value <code>0</code>)"
msgstr "goal: <code><a cbot|int>int</a></code> (по умолчанию <code>0</code>)"

#. type: Plain text
#: cbot-help/goto.txt:28
#, no-wrap
#, fuzzy, 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>1</code> (precision) is the default value. "
msgstr ""
"Этот параметр говорит боту, каким образом он должен достичь цели:\n"
"<code>0</code>  остановка прямо в позиции цели\n"
"<code>1</code>  подходит близко к позиции цели, не останавливаясь.\n"
"Если нет значение по умолчанию, <code>1</code> (точность) является значением "
"по умолчанию."

#. type: Plain text
#: cbot-help/goto.txt:33
#, no-wrap
#, fuzzy, 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 ""
"Обычно в случае ошибки программа останавливается. Вы можете приказать "
"программе не останавливаться, с помощью инструкции <code><a "
"cbot|errmode>errmode</a>(0)</code>. Тогда в случае ошибки инструкция "
"<code>goto()</code> возвращает значение отличное от нуля.\n"
"<code>== 0 </code>Достиг позиции цели\n"
"<code>!= 0 </code>Невозможно достичь позиции цели"

#. type: \b; header
#: cbot-help/grab.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>grab</code>"
msgstr "Инструкция <code>grab</code>"

#. type: Plain text
#: cbot-help/grab.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Инструкция <c/>grab();<n/> приказывает боту использовать рабочую руку для "
"взятия предмета лежащего на земле, на платформе здания или на месте "
"размещения энергобатареи бота."

#. type: Plain text
#: cbot-help/grab.txt:6
#, no-wrap
#, fuzzy, 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 ""
"Инструкция <c/>grab();<n/> написанная в данноц форме, забирает обьект "
"лежащий перед ботом. Вот пример короткой программы, которая забирает "
"предмет, лежащий перед ботом и кладет его на 5 метров дальше:"

#. type: \s; block (usually verbatim code)
#: cbot-help/grab.txt:10
#, no-wrap
#, fuzzy, 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: \s; block (usually verbatim code)
#: cbot-help/grab.txt:14
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>grab ( oper );<n/>"
msgstr "<c/>grab ( oper );<n/>"

#. type: Plain text
#: cbot-help/grab.txt:16
#, no-wrap
#, fuzzy, 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 ""
"Эта инструкция обращается к рабочей руке <a object|botgr>сборщика</a>, чтобы "
"взять ближайший обьект."

#. type: Plain text
#: cbot-help/grab.txt:22
#, no-wrap
#, fuzzy, 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 ""
"Oper означает, что бот должен сначала отыскать обьект. Если это не "
"обозначить, подбирается обьект прямо перед ботом.\n"
"<code>InFront   </code>  Берет пере собой (по умолчанию).\n"
"<code>Behind    </code>  Берет позади.\n"
"<code>EnergyPack</code>  Берет свою свою собственную батарею."

#. type: Plain text
#: cbot-help/grab.txt:27
#, no-wrap
#, fuzzy, 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 ""
"Обычно в случае ошибки программа останавливается. Вы можете приказать "
"программе не останавливаться, с помощью инструкции <code><a "
"cbot|errmode>errmode</a>(0)</code>. Тогда в случае ошибки инструкция "
"<code>grab()</code> возвращает значение отличное от нуля.\n"
"<code>== 0 </code>обьект был взят\n"
"<code>!= 0 </code>ошибка, обьект не был взят"

#. type: \b; header
#: cbot-help/if.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instructions <code>if</code> and <code>else</code>"
msgstr "Инструкции <code>if</code> и <code>else</code>"

#. type: Plain text
#: cbot-help/if.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Инструкция <code>if() {}</code> выполняет набор инструкций только если "
"выполняется определенное условие. Напишите условие в скобках <code>()</code>"
", а инструкции в квадратных скобках <code>{}</code>."

#. type: Plain text
#: cbot-help/if.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Here is a concrete example: The bot will shoot only if the target is closer "
"than 40 meters:"
msgstr ""
"Вот вам конкретный пример: Бот станет стрелять, только если цель находится "
"ближе чем в 40 метрах:"

#. type: \s; block (usually verbatim code)
#: cbot-help/if.txt:12
#, no-wrap
#, fuzzy, 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
#: cbot-help/if.txt:14
#, no-wrap
#, fuzzy, 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 ""
"Вы также можете проверить, существует ли обьект вообще. Если инструкция <c/><"
"a cbot|radar>radar</a>();<n/> не находит требуемый обьект, она возвращает "
"значение <code>null</code>. Поэтому вы можете проверить наличие обьекта с "
"помощью условия <code>(item == null)</code>, или с помощью <code>(item != "
"null)</code>. Два знака равенства <code>==</code> проверяют равность, знак "
"восклицания, за которым идет знак равенства <code>!=</code> проверяют "
"неравенство. Вот тестовая программа, которая отправит бот на перезарядку <a "
"object|power>энергобатареи</a> только в случае наличия <a "
"object|station>электростанции</a>:"

#. type: \s; block (usually verbatim code)
#: cbot-help/if.txt:21
#, no-wrap
#, fuzzy, 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: \s; block (usually verbatim code)
#: cbot-help/if.txt:32
#, no-wrap
#, fuzzy, 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 ( условие )\n"
"{\n"
"\t</code>Инструкции A ...<code>\n"
"}\n"
"else\n"
"{\n"
"\t</code>Инструкции B ...<c/>\n"
"}"

#. type: Plain text
#: cbot-help/if.txt:35
#, no-wrap
#, fuzzy, 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 ""
"Данной условной структурой вы можете выполнить <a cbot|bloc>блок</a> A или <"
"a cbot|bloc>блок</a> B в зависимости от <a cbot|cond>условия</a>. Если "
"условие выполняется, блок A выполняется. Если условие не выполняется, то "
"выполняется блок B.\n"
"Part <code>else { }</code> is not compulsory."

#. type: Plain text
#: cbot-help/if.txt:38
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Do not put a <a cbot|term>semicolon</a> at the end of the line <code>if ( "
")</code>."
msgstr ""
"Не следует ставить двоеточие <a cbot|term>semicolon</a> в конце строки <code>"
"if ( )</code>."

#. type: \b; header
#: cbot-help/int.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Type <code>int</code>"
msgstr "Тип <code>int</code>"

#. type: Plain text
#: cbot-help/int.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Use this type for variables that contain only whole numbers, negative or "
"positive. For example: "
msgstr ""
"Используйте этот тип для переменных содержащих только целые числа, "
"положительные и отрицательные. Например:"

#. type: \s; block (usually verbatim code)
#: cbot-help/int.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"\t12\n"
"\t1000\n"
"\t-4"
msgstr ""
"\t12\n"
"\t1000\n"
"\t-4"

#. type: Plain text
#: cbot-help/int.txt:9
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"To represent real numbers like 12.05 or -0.005, use the type <code><a "
"cbot|float>float</a></code>."
msgstr ""
"Чтобы представить числа подобные 12.05 или -0.005, исползуйте тип <code><a "
"cbot|float>float</a></code>."

#. type: Plain text
#: cbot-help/int.txt:12
#, no-wrap
#, fuzzy, no-wrap
msgid "Do not put space or colon signs inside a number. "
msgstr "Не ставьте пробел или запятую внутри числа."

#. type: Plain text
#: cbot-help/int.txt:17
#, no-wrap
#, fuzzy, 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 ""
"Числа типа <code>int</code> представлены в 32 битах.\n"
"Наибольшее число, которое можно представить  (2^31)-1, это 2'147'483'647.\n"
"Наименьшее число, которое можно представить -(2^31), this is -2'147'483'648."

#. type: \b; header
#: cbot-help/jet.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>jet</code>"
msgstr "Инструкция <code>jet</code>"

#. type: \s; block (usually verbatim code)
#: cbot-help/jet.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>jet ( power );<n/>"
msgstr "<c/>jet ( сила );<n/>"

#. type: Plain text
#: cbot-help/jet.txt:6
#, no-wrap
#, fuzzy, 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 ""
"Прямое управление реактивным двигателем <a object|botgj>крылатого бота</a>. "
"Именно двигатель заставляет бот перемещаться. Используйте эту инструкцию, "
"чтобы подыматься, опускаться или приземляться."

#. type: \t; header
#: cbot-help/jet.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid "power: <code><a cbot|float>float</a></code>"
msgstr "power: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: cbot-help/jet.txt:9
#, no-wrap
#, fuzzy, 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 ""
"Сила двигателся, варьируется между <code>-1</code> и <code>+1</code>. "
"<c/>jet(1);<n/> приказывает боту подняться как можно выше, <c/>jet(-1);<n/> "
"опускается как можно быстрее, <c/>jet(0);<n/> стабилизирует высоту. Чтобы "
"изменять высоту медленее, используйте средние значения, наприер "
"<c/>jet(0.3);<n/>."

#. type: \t; header
#: cbot-help/jet.txt:11 cbot-help/message.txt:21 cbot-help/motor.txt:35 cbot-help/shield.txt:15 cbot-help/wait.txt:18
#, no-wrap
#, fuzzy, no-wrap
msgid "Return value: <code><a cbot|void>void</a></code>"
msgstr "Возвращаемое значение: <code><a cbot|void>void</a></code>"

#. type: Plain text
#: cbot-help/jet.txt:13 cbot-help/message.txt:23 cbot-help/motor.txt:37 cbot-help/shield.txt:17 cbot-help/wait.txt:20
#, no-wrap
#, fuzzy, no-wrap
msgid "None."
msgstr "Нет."

#. type: \b; header
#: cbot-help/message.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>message</code>"
msgstr "Инструкция <code>message</code>"

#. type: \s; block (usually verbatim code)
#: cbot-help/message.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>message ( text, type );<n/>"
msgstr "<c/>message ( text, type );<n/>"

#. type: Plain text
#: cbot-help/message.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Prints a message on top of the screen. After a few seconds, the message "
"disappears automatically. "
msgstr ""
"Выводит сообщение сверху экрана. Через несколько секунд сообщение "
"автоматически исчезает."

#. type: \t; header
#: cbot-help/message.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid "text: <code><a cbot|string>string</a></code>"
msgstr "text: <code><a cbot|string>string</a></code>"

#. type: Plain text
#: cbot-help/message.txt:13
#, no-wrap
#, fuzzy, 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 ""
"Текст, который требуется отобразить. Возможно присоединять несколько кусков "
"текста и/или значение с оператором <code>+</code>:\n"
"<c/>message(\"не найден\");<n/>\n"
"<c/>message(angle);<n/>\n"
"<c/>message(n + \" обьект(ы) найден\");<n/>\n"
"<c/>message(\"Расстояние = \" + расст + \" метров\");<n/>"

#. type: \t; header
#: cbot-help/message.txt:14
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"type: <code><a cbot|int>int</a></code> (default value "
"<code>DisplayMessage</code>)"
msgstr ""
"type: <code><a cbot|int>int</a></code> (default value "
"<code>DisplayMessage</code>)"

#. type: Plain text
#: cbot-help/message.txt:16
#, no-wrap
#, fuzzy, no-wrap
msgid "Type of the message, that determines the background color. \n"
msgstr "ТИп сообщения, определяющий фоновый цвет.\n"

#. type: Bullet: 'o'
#: cbot-help/message.txt:16
#, no-wrap
#, fuzzy, no-wrap
msgid "<code>DisplayMessage</code>  Standard message on yellow background."
msgstr "<code>DisplayMessage</code>  Стандартное сообщение нажелтом фоне."

#. type: Bullet: 'o'
#: cbot-help/message.txt:17
#, no-wrap
#, fuzzy, no-wrap
msgid "<code>DisplayInfo   </code>  Information on green background."
msgstr "<code>DisplayInfo   </code>  Информация на зеленом фоне."

#. type: Bullet: 'o'
#: cbot-help/message.txt:18
#, no-wrap
#, fuzzy, no-wrap
msgid "<code>DisplayWarning</code>  Warning on blue background."
msgstr "<code>DisplayWarning</code>  Предупреждение на синем фоне."

#. type: Bullet: 'o'
#: cbot-help/message.txt:19
#, no-wrap
#, fuzzy, no-wrap
msgid "<code>DisplayError  </code>  Error on red background."
msgstr "<code>DisplayError  </code>  Ошибка на красном фоне."

#. type: \b; header
#: cbot-help/motor.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>motor</code>"
msgstr "Инструкция <code>motor</code>"

#. type: Plain text
#: cbot-help/motor.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"The instruction <c/>motor( , );<n/> sets the speed for the left-hand and the "
"right-hand motor of the bot."
msgstr ""
"Инструкция <c/>motor( , );<n/> устанавливает скорости для правого и левого "
"двигателей бота."

#. type: Plain text
#: cbot-help/motor.txt:6
#, no-wrap
#, fuzzy, 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 ""
"Указанная моторам скорость будет оставаться постоянной во время выполнения "
"последующих инструкций. Благодаря этой характеристике можно выполнять "
"вращение во время выполнения инструкции <c/><a cbot|fire>fire</a>();<n/>. "
"Это позволит накрыть целую зону местности одной очередью. Вот пример того, "
"как можно накрыть зону перед ботом:"

#. type: \s; block (usually verbatim code)
#: cbot-help/motor.txt:11
#, no-wrap
#, fuzzy, 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);         // поворачивает на 45 градусов влево\n"
"\tmotor(0.5, -0.5); // медленное вращение вправо\n"
"\t<a cbot|fire>fire</a>(2);          // огонь\n"
"\tmotor(0,0);       // остановка вращения"

#. type: Plain text
#: cbot-help/motor.txt:13
#, no-wrap
#, fuzzy, 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 ""
"Так как левый двигатель на половине скорости поворачивается вперед, а правый "
"двигатель на половине скорости поворачивается назад, так что бот медленно "
"поворачивается во время 2-секундной очереди."

#. type: \s; block (usually verbatim code)
#: cbot-help/motor.txt:17
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>motor ( left, right );<n/>"
msgstr "<c/>motor ( налево, направо );<n/>"

#. type: Plain text
#: cbot-help/motor.txt:19
#, no-wrap
#, fuzzy, 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 ""
"Дает инструкции о скорости движения правому и левому двигателям робота. "
"Двигатели будут поддерживать постоянную скорость до тех пор. пока двигателям "
"не будет отдана новая инструкция, или пока не будут отданы инструкции <code><"
"a cbot|move>move</a></code>, <code><a cbot|turn>turn</a></code> или <code><a "
"cbot|goto>goto</a></code>."

#. type: \t; header
#: cbot-help/motor.txt:20
#, no-wrap
#, fuzzy, no-wrap
msgid "left: <code><a cbot|float>float</a></code>"
msgstr "налево: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: cbot-help/motor.txt:22
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Speed instruction for the left motor; the value must range between -1 and "
"1. "
msgstr ""
"Дает инструкцию о скорости левого двигателя; значение должно быть в пределах "
"от -1 до 1."

#. type: \t; header
#: cbot-help/motor.txt:23
#, no-wrap
#, fuzzy, no-wrap
msgid "right: <code><a cbot|float>float</a></code>"
msgstr "направо: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: cbot-help/motor.txt:25
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Speed instruction for the right motor; the value must range between -1 and "
"1. "
msgstr ""
"Дает инструкцию о скорости правого двигателя; значение должно быть в "
"пределах от -1 до 1."

#. type: Plain text
#: cbot-help/motor.txt:30
#, no-wrap
#, fuzzy, 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 ""
"Примеры :\n"
"<c/>motor(1, 1);<n/> Двигается вперед с наибольшей возможной скоростью.\n"
"<c/>motor(-0.5, -0.5);<n/> двигается назад на половине скорости.\n"
"<c/>motor(1, -1);<n/> со всей возможной скоростью поворачивается направо."

#. type: Plain text
#: cbot-help/motor.txt:34
#, no-wrap
#, fuzzy, 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 ""
"Замечание :\n"
"<c/>motor(2, 2);<n/> будет двигаться вперед не быстрее, чем <code>motor(1, "
"1)</code>\n"
"<c/>motor(-2, -2);<n/> будет двигаться назад не быстрее, чем <code>motor(-1, "
"-1)</code>"

#. type: \b; header
#: cbot-help/move.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>move</code>"
msgstr "Инструкция <code>move</code>"

#. type: Plain text
#: cbot-help/move.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Инструкция <c/>move();<n/> приказывает боту двигаться вперед или назад, "
"придерживаясь той же ориентации. В скобках вы должны указать дальность "
"перемещения в метрах."

#. type: Plain text
#: cbot-help/move.txt:6
#, no-wrap
#, fuzzy, 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 ""
"Если вы хотите, чтобы бот переместился вперед на 30 метро, то напишите "
"<c/>move(30);<n/>. Чтобы отправить бота назад после того, как он бросил "
"кусок <a object|titanore>титаниумовой руды</a> в <a "
"object|convert>преобразователь</a>, напишите <c/>move(-2.5);<n/>."

#. type: \s; block (usually verbatim code)
#: cbot-help/move.txt:10
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>move ( length );<n/>"
msgstr "<c/>move ( дальность );<n/>"

#. type: Plain text
#: cbot-help/move.txt:12
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Moves forward or backward of a given distance, always keeping the current "
"orientation of the bot. "
msgstr ""
"Двигается вперед или назад на указанное расстояние, всегда выдерживая "
"текущую ориентацию бота."

#. type: \t; header
#: cbot-help/move.txt:13
#, no-wrap
#, fuzzy, no-wrap
msgid "length: <code><a cbot|float>float</a></code>"
msgstr "дальность: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: cbot-help/move.txt:15
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Length of the move, in meters. A negative value makes the bot move "
"backward. "
msgstr ""
"Дальность перемещения в метрах. Отрицательное значение заставляет его "
"двигаться назад."

#. type: Plain text
#: cbot-help/move.txt:20
#, no-wrap
#, fuzzy, 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 ""
"Обычно ошибка останавливает выполнение программы. Вы можете предотвратить "
"остановку работы программы при появлении ошибок, используя инструкцию <code><"
"a cbot|errmode>errmode</a>(0)</code>. В том случае, если возникла ошибка, "
"<code>move()</code> возвращает значение, отличное от нуля.\n"
"<code>== 0 </code>Произведено передвижение\n"
"<code>!= 0 </code>ошибка, инструкция не была выполнена соответствующим "
"образом"

#. type: \b; header
#: cbot-help/nan.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Type <code>nan</code>"
msgstr "Тип <code>nan</code>"

#. type: Plain text
#: cbot-help/nan.txt:4
#, no-wrap
#, fuzzy, 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 ""
"Это особое значение показывает, что <a cbot|var>переменная</a> типа <code><a "
"cbot|int>int</a></code> или <code><a cbot|float>float</a></code> не содержит "
"число, она не содержит \"ничего\".\n"
"Например если инструкция <code><a cbot|receive>receive</a></code> не может "
"получить запрашиваемую информацию, то она возвращает <code>nan</code> :"

#. type: \s; block (usually verbatim code)
#: cbot-help/nan.txt:10
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"\tvalue = receive(\"Length\");\n"
"\tif ( value == nan )  // not found ?\n"
"\t{\n"
"\t\t\n"
"\t}"
msgstr ""
"\tvalue = receive(\"Length\");\n"
"\tif ( value == nan )  // не найдена ?\n"
"\t{\n"
"\t\t\n"
"\t}"

#. type: \t; header
#: cbot-help/nan.txt:11
#, no-wrap
#, fuzzy, no-wrap
msgid "Dictionnary"
msgstr "Словарь"

#. type: Plain text
#: cbot-help/nan.txt:13
#, no-wrap
#, fuzzy, no-wrap
msgid "<code>nan</code> = Not A Number "
msgstr "<code>nan</code> = Не число"

#. type: \b; header
#: cbot-help/new.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>new</code> (for specialists)"
msgstr "Инструкция <code>new</code> (для специалистов)"

#. type: Plain text
#: cbot-help/new.txt:4
#, no-wrap
#, fuzzy, 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 ""
"Оператор <code>new</code> создает новый <a cbot|class>класс</a>:\n"
"<c/><s/>\tMyClass item;    // переменная item пуста"

#. type: \s; block (usually verbatim code)
#: cbot-help/new.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"\titem = new MyClass(); // now item is a reference\n"
"\t                      // to a new class instance"
msgstr ""
"\titem = new MyClass(); // теперь item - это ссылка\n"
"\t                      // в новый экземпляр класса"

#. type: Plain text
#: cbot-help/new.txt:8
#, no-wrap
#, fuzzy, 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 ""
"Если вы хотите создать новый экземпляр для объявления <code>new</code>, то "
"на время можно опустить () после объявления:"

#. type: Plain text
#: cbot-help/new.txt:13
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Instead of:\n"
"<c/><s/>\tMyClass item = new MyClass();\n"
"<n/>you can write:\n"
"<c/><s/>\tMyClass item();"
msgstr ""
"Вместо:\n"
"<c/><s/>\tMyClass item = new MyClass();\n"
"<n/>вы можете написать:\n"
"<c/><s/>\tMyClass item();"

#. type: Plain text
#: cbot-help/new.txt:18
#, no-wrap
#, fuzzy, 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 ""
"Если ваш класс имеет конструктор с параметрами, то вы можете написать так:\n"
"<c/><s/>\tMyClass item = new MyClass(2, 3);\n"
"<n/>или:\n"
"<c/><s/>\tMyClass item(2, 3);"

#. type: Plain text
#: cbot-help/new.txt:22
#, no-wrap
#, fuzzy, 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>class</a></code>, <code><a "
"cbot|pointer>reference</a></code>\n"
"<a cbot>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/null.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Type <code>null</code>"
msgstr "Тип <code>null</code>"

#. type: Plain text
#: cbot-help/null.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"This special value indicates that the variable containing it does not "
"reference an instance."
msgstr "Это особое значение показывает, что объект не существует."

#. type: Plain text
#: cbot-help/null.txt:7
#, no-wrap
#, fuzzy, 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>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/object.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Type <code>object</code>"
msgstr "Тип <code>object</code>"

#. type: Plain text
#: cbot-help/object.txt:3
#, no-wrap
#, fuzzy, 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. "
msgstr ""
"Используйте этот тип для переменных, которые должны содержать характеристики "
"объекта, это может быть бот, здание, какие природные ископаемые, враг и так "
"далее."

#. type: Plain text
#: cbot-help/object.txt:16
#, no-wrap
#, fuzzy, 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"
msgstr ""
"<code><a cbot|int>int</a>    object.category     </code><a "
"cbot|category>Категория</a> объекта\n"
"<code><a cbot|point>point</a>  object.position     </code>Положение объекта "
"(x,y,z)\n"
"<code><a cbot|float>float</a>  object.orientation  </code>Ориентация объекта "
"(0..360)\n"
"<code><a cbot|float>float</a>  object.pitch        </code>Передний/задний "
"угол объекта\n"
"<code><a cbot|float>float</a>  object.roll         </code>Правый/левый угол "
"объекта\n"
"<code><a cbot|float>float</a>  object.energyLevel  </code>Уровень энергии "
"(0..1)\n"
"<code><a cbot|float>float</a>  object.shieldLevel  </code>Уровень полей "
"(0..1)\n"
"<code><a cbot|float>float</a>  object.temperature  </code>Температура "
"двигателя (0..1)\n"
"<code><a cbot|float>float</a>  object.altitude     </code>Высота над землей\n"
"<code><a cbot|float>float</a>  object.lifeTime     </code>Lifetime of the "
"object\n"
"<code>object object.energyCell   </code>Энергетические ячейки бота\n"
"<code>object object.load         </code>Объект, который несет бот"

#. type: \s; block (usually verbatim code)
#: cbot-help/object.txt:18
#, no-wrap
#, fuzzy, no-wrap
msgid "<code>category</code>"
msgstr "<code>category</code>"

#. type: Plain text
#: cbot-help/object.txt:19
#, no-wrap
#, fuzzy, 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>Категория</a> объекта позволяет вам узнать, что это "
"такое, то есть например какой это вид бота, здания, врага и так далее."

#. type: \s; block (usually verbatim code)
#: cbot-help/object.txt:21
#, no-wrap
#, fuzzy, no-wrap
msgid "<code>position</code>"
msgstr "<code>position</code>"

#. type: Plain text
#: cbot-help/object.txt:22
#, no-wrap
#, fuzzy, 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 ""
"Положение объекта на планете в метрах. Координаты <code>x</code> и "
"<code>y</code> соответствуют положению на карте, а координата <code>z</code> "
"соответствует высоте над (и соответственно под) уровнем моря."

#. type: \s; block (usually verbatim code)
#: cbot-help/object.txt:24
#, no-wrap
#, fuzzy, no-wrap
msgid "<code>orientation</code>"
msgstr "<code>orientation</code>"

#. type: Plain text
#: cbot-help/object.txt:25
#, no-wrap
#, fuzzy, 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 ""
"Ориентация объекта в градусах. Ориентация говорит вам о том, в каком "
"направлении смотрит объект. Ориентация <code>0</code> соответствует объекту. "
"который смотрит на восток, таким образом следуя положительному направлению "
"оси <code>x</code>. Ориентация измеряется против часовой стрелки."

#. type: \s; block (usually verbatim code)
#: cbot-help/object.txt:27
#, no-wrap
#, fuzzy, no-wrap
msgid "<code>pitch</code>"
msgstr "<code>pitch</code>"

#. type: Plain text
#: cbot-help/object.txt:28
#, no-wrap
#, fuzzy, 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 ""
"Передний/задний угол робота. Уклон равный <code>0</code> означает, что бот "
"стоит на ровно поверхности. Положительный наклон означает, что он смотрит "
"вверх, а отрицательный, что он смотрит вниз."

#. type: \s; block (usually verbatim code)
#: cbot-help/object.txt:30
#, no-wrap
#, fuzzy, no-wrap
msgid "<code>roll</code>"
msgstr "<code>roll</code>"

#. type: Plain text
#: cbot-help/object.txt:31
#, no-wrap
#, fuzzy, 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 ""
"Левый/правый угол бота в градусах. Положительное значение значит, что бот "
"наклонен на левый бок, а отрицательное, что он клонится на правый бок."

#. type: \s; block (usually verbatim code)
#: cbot-help/object.txt:33
#, no-wrap
#, fuzzy, no-wrap
msgid "<code>energyLevel</code>"
msgstr "<code>energyLevel</code>"

#. type: Plain text
#: cbot-help/object.txt:34
#, no-wrap
#, fuzzy, 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 ""
"Уровень энергии может быть от 0 до 1. Обычная <a object|power>энергетическая "
"ячейка</a>, которая полностью заряжена, будет возвращать значение "
"<code>1</code>. <a object|atomic>Ядерная энергетическая ячейка</a> тоже не "
"будет возвращать значение больше 1, просто это значение будет держаться "
"дольше. Внимание: энергетический уровень бота всегда равен нулю, так как "
"энергия содержится не в боте, а в энергетической ячейке. Чтобы определить "
"энергетический уровень энергетической ячейки бота, вы должны написать "
"<code>energyPack.energyLevel</code>."

#. type: \s; block (usually verbatim code)
#: cbot-help/object.txt:36
#, no-wrap
#, fuzzy, no-wrap
msgid "<code>shieldLevel</code>"
msgstr "<code>shieldLevel</code>"

#. type: Plain text
#: cbot-help/object.txt:38
#, no-wrap
#, fuzzy, 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 ""
"Уровень полей робота или здания. Уровень <code>1</code> показывает, что поля "
"превосходны. Каждый раз, когда по боту или зданию попадает пуля или же он "
"сталкивается с другим объектом, уровень полей уменьшается. Когда уровень "
"становится равным <code>0</code>, первая же пуля или столкновение приведут к "
"уничтожению бота или здания.\n"
"Боты могут перезаряжать свои поля в <a object|repair>центре починки</a>. "
"Поля здания восстанавливаются, если оно помещается внутрь защитной сферы <a "
"object|botshld>полевика</a>."

#. type: \s; block (usually verbatim code)
#: cbot-help/object.txt:40
#, no-wrap
#, fuzzy, no-wrap
msgid "<code>temperature</code>"
msgstr "<code>temperature</code>"

#. type: Plain text
#: cbot-help/object.txt:41
#, no-wrap
#, fuzzy, 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 ""
"Температура реактивной струи <a object|botgj>летающих ботов</a>. "
"<code>0</code> соответствует холодной струе. При их использовании "
"температура растет по прогрессии. Когда она достигает значения <code>1</code>"
", двигатель перенагревается и прекращает работать до тех пор, пока немного "
"не остынет."

#. type: \s; block (usually verbatim code)
#: cbot-help/object.txt:43
#, no-wrap
#, fuzzy, no-wrap
msgid "<code>altitude</code>"
msgstr "<code>altitude</code>"

#. type: Plain text
#: cbot-help/object.txt:44
#, no-wrap
#, fuzzy, 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 ""
"Координата положения <code>z</code> показывает высоту над уровнем моря, то "
"есть <code>высота</code> показывает высоту над землей. Это значение имеет "
"смысл только для <a object|botgj>летающих ботов</a> и для <a "
"object|wasp>ос</a>. Для всех остальных объектов это значение равно нулю."

#. type: \s; block (usually verbatim code)
#: cbot-help/object.txt:46
#, no-wrap
#, fuzzy, no-wrap
msgid "<code>lifeTime</code>"
msgstr "<code>lifeTime</code>"

#. type: Plain text
#: cbot-help/object.txt:47
#, no-wrap
msgid "The age of the object in seconds since it's creation."
msgstr ""

#. type: \s; block (usually verbatim code)
#: cbot-help/object.txt:49
#, no-wrap
#, fuzzy, no-wrap
msgid "<code>energyCell</code>"
msgstr "<code>energyCell</code>"

#. type: Plain text
#: cbot-help/object.txt:52
#, no-wrap
#, fuzzy, 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 ""
"Это особая информация, так как она возвращает информацию о другом объекте, в "
"данном случае о энергетическом заряде. Это означает, что energyPack содержит "
"все характеристики обычного объекта, например <code>категорию</code> ("
"PowerCell или NuclearCell), <code>положение</code> (положение ячейки) и так "
"далее.\n"
"Если вы хотите определить энергетический уровень робота, то вы должны "
"проверить не <code>energyLevel</code>, а <code>energyPack.energyLevel</code>."
"\n"
"Если у бота нет энергетической ячейки, то <code>energyPack</code> вернет "
"<code>null</code>."

#. type: \s; block (usually verbatim code)
#: cbot-help/object.txt:54
#, no-wrap
#, fuzzy, no-wrap
msgid "<code>load</code>"
msgstr "<code>load</code>"

#. type: Plain text
#: cbot-help/object.txt:55
#, no-wrap
#, fuzzy, 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 ""
"Эта информация также вернет описание целого объекта: описание объекта, "
"который несет <a object|botgr>несущий</a>. Если он ничего не несет, то "
"<code>load</code> вернет <code>null</code>."

#. type: \b; header
#: cbot-help/object.txt:56
#, no-wrap
#, fuzzy, no-wrap
msgid "Examples"
msgstr "Примеры"

#. type: Plain text
#: cbot-help/object.txt:58
#, no-wrap
#, fuzzy, 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 ""
"Тип <code>object</code> возвращает особое значение <code><a "
"cbot|null>null</a></code>, когда объект не существует. Например:"

#. type: \s; block (usually verbatim code)
#: cbot-help/object.txt:67
#, no-wrap
#, fuzzy, 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 )  // объект не существует ?\n"
"\t{\n"
"\t}\n"
"\tif ( a.position.z > 50 )  // он на горе ?\n"
"\t{\n"
"\t}"

#. type: \b; header
#: cbot-help/openfile.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>openfile</code>"
msgstr "Инструкция <code>openfile</code>"

#. type: Plain text
#: cbot-help/openfile.txt:3
#, no-wrap
#, fuzzy, 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 returne "
"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 ""
"<c/>openfile();<n/> открывает файл. Это не метод класса <code><a "
"cbot|file>file</a></code>, однако openfile возвращает <a "
"cbot|pointer>ссылку</a> для нового экземпляра класса. Вы должны указать два "
"параметра - имя файла и режим открытия."

#. type: \s; block (usually verbatim code)
#: cbot-help/openfile.txt:5
#, no-wrap
#, fuzzy, no-wrap
msgid "file handle = openfile(\"filename\", \"r\");"
msgstr "file handle = openfile(\"filename\", \"r\");"

#. type: Plain text
#: cbot-help/openfile.txt:8 cbot-help/open.txt:15
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"<code>\"r\"</code> mode: open for reading.\n"
"<code>\"w\"</code> mode: open for writing."
msgstr ""
"<code>\"r\"</code> mode: открыть для чтения.\n"
"<code>\"w\"</code> mode: открыть для записи."

#. type: \b; header
#: cbot-help/open.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>open</code>"
msgstr "Инструкция <code>open</code>"

#. type: Plain text
#: cbot-help/open.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Открывает текстовой файл. Это метод класса <code><a cbot|file>file</a></code>"
". Это причина, почему мы всегда пишем <code>handle.open()</code>¦:"

#. type: \s; block (usually verbatim code)
#: cbot-help/open.txt:5
#, no-wrap
#, fuzzy, no-wrap
msgid "\thandle.open(\"test.txt\", \"w\");"
msgstr "\thandle.open(\"test.txt\", \"w\");"

#. type: Plain text
#: cbot-help/open.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid "To open a file, proceed as follows¦:"
msgstr "Для открытия файла необходимо выполнить¦:"

#. type: \s; block (usually verbatim code)
#: cbot-help/open.txt:12
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"\tfile handle();\n"
"\thandle.open(\"filename\", \"w\");\n"
"\thandle.writeln(\"abc\");\n"
"\thandle.close();"
msgstr ""
"\tfile handle();\n"
"\thandle.open(\"filename\", \"w\");\n"
"\thandle.writeln(\"abc\");\n"
"\thandle.close();"

#. type: Plain text
#: cbot-help/open.txt:17
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Files can only be created and opened in the files/ folder which is located "
"in the folder where Colobot has been installed. You cannot not create or "
"open files that are located elsewhere than in the files/ folder."
msgstr "Файлы могут находиться только в папке с установленной игрой."

#. type: Plain text
#: cbot-help/open.txt:20
#, no-wrap
#, fuzzy, 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> and <code><a cbot|eof>eof</a></code>.\n"
"<a cbot>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/pointer.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "References (for specialists)"
msgstr "Ссылки (для специалистов)"

#. type: Plain text
#: cbot-help/pointer.txt:3
#, no-wrap
#, fuzzy, 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 использует ссылки для <a cbot|class>классов</a> и <a "
"cbot|array>массивов</a>. Любой класс содержит в себе ссылку на данный "
"экземпляр. Экземпляр на самом деле содержит в себе ячейки классов. Некоторые "
"ссылки могут ссылаться на ту же функцию. <code><a cbot|null>null</a></code> "
"ссылка не ссылается ни на что. Например, каждый раз, когда нам нужет новый "
"чемодан, мы создаем новый экземпляр перевозчика. Но чемодан может "
"перевозиться более чем на одном носителе. Перевозчик, не имеющий груза имеет "
"<code><a cbot|null>null</a></code> ссылку."

#. type: Plain text
#: cbot-help/pointer.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Example:\n"
"<c/><s/>{"
msgstr ""
"Например:\n"
"<c/><s/>{"

#. type: \s; block (usually verbatim code)
#: cbot-help/pointer.txt:16
#, no-wrap
#, fuzzy, 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 ""
"\tMyClass item1(); // создать новый экземпляр\n"
"\t                 // ссылающийся на item1\n"
"\tMyClass item2;   // создаем нулевую ссылку\n"
"\titem2 = item1;   // копируем ссылку,\n"
"\t                 // item2 and item1 теперь ссылки\n"
"\t                 // какого-то экземпляра\n"
"\titem1.a = 12;    // изменяем экземпляр\n"
"\t                 // ссылающийся на item1 (и item2)\n"
"\tmessage(item2.a);// выводим 12\n"
"}"

#. type: Plain text
#: cbot-help/pointer.txt:18
#, no-wrap
#, fuzzy, 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 ""
"Если вы передадите функции <a cbot|class>класс</a> как параметр, то функция "
"получит только ссылку на экземпляр. Это означает, что если изменить значение "
"ссылки в функции, то изменение на самом деле произойдет."

#. type: Plain text
#: cbot-help/pointer.txt:20
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/><s/>void Test( MyClass item )"
msgstr "<c/><s/>void Test( MyClass item )"

#. type: \s; block (usually verbatim code)
#: cbot-help/pointer.txt:25
#, no-wrap
#, fuzzy, 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;          // изменяем локальный экземпяр\n"
"\titem = new MyClass(); // создаем новый\n"
"\titem.a = 33;          // изменяем локальный экземпяр\n"
"}"

#. type: Plain text
#: cbot-help/pointer.txt:28
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Calling the fucntion <code>Test()</code>¦:\n"
"<c/><s/>{"
msgstr ""
"Вызов функции <code>Test()</code>¦:\n"
"<c/><s/>{"

#. type: \s; block (usually verbatim code)
#: cbot-help/pointer.txt:32
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"\tMyClass toto();\n"
"\tTest(toto);\n"
"\tmessage(toto.a);  // displays 12\n"
"}"
msgstr ""
"\tMyClass toto();\n"
"\tTest(toto);\n"
"\tmessage(toto.a);  // выводим 12\n"
"}"

#. type: Plain text
#: cbot-help/pointer.txt:34
#, no-wrap
#, fuzzy, 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 ""
"Экземпляр, содержащий поле <code>a = 33</code> ссылается на более новый "
"экземпляр <code>item</code> внутри функции <code>Test</code>. В конце "
"функции <code>Test</code> недавно созданная ссылка <code>item</code> будет "
"автоматически удалена."

#. type: Plain text
#: cbot-help/pointer.txt:37
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"A function can return an instance¦:\n"
"<c/><s/>MyClass Test2( )"
msgstr ""
"Функция может возвратить экземпляр¦:\n"
"<c/><s/>MyClass Test2( )"

#. type: \s; block (usually verbatim code)
#: cbot-help/pointer.txt:42
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"{\n"
"\tMyClass item = new MyClass();\n"
"\titem.x = 33;\n"
"\treturn item;\n"
"}"
msgstr ""
"{\n"
"\tMyClass item = new MyClass();\n"
"\titem.x = 33;\n"
"\treturn item;\n"
"}"

#. type: Plain text
#: cbot-help/pointer.txt:45
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Call the function like this:\n"
"<c/><s/>{"
msgstr ""
"Вызов функции, как здесь:\n"
"<c/><s/>{"

#. type: \s; block (usually verbatim code)
#: cbot-help/pointer.txt:50
#, no-wrap
#, fuzzy, 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 ""
"\tMyClass toto;\n"
"\ttoto = Test2(); // toto содержит ссылку на\n"
"\t                // созданный экземпляр Test2()\n"
"\tmessage(toto.a); // выводим 33\n"
"}"

#. type: Plain text
#: cbot-help/pointer.txt:53
#, no-wrap
#, fuzzy, 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>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/point.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Type <code>point</code>"
msgstr "Тип <code>point</code>"

#. type: Plain text
#: cbot-help/point.txt:5
#, no-wrap
#, fuzzy, 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 ""
"Переменные этого типа содержат координаты точки в пространстве. Этот тип "
"состоит из трех значений, которые представляют собой <code>x</code>, "
"<code>y</code> и <code>z</code> координаты.\n"
"<code>x</code> и <code>y</code> соответствуют месту на поверхности. "
"Положительная ось <code>x</code> смотрит на восток, положительная ось "
"<code>y</code> смотрит на север.\n"
"Значение <code>z</code> соответствует высоте над уровнем моря."

#. type: Plain text
#: cbot-help/point.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid "If you want to declare a variable of type point, you can write: "
msgstr "Если вы хотите объявить переменную типа point, вы должны написать:"

#. type: \s; block (usually verbatim code)
#: cbot-help/point.txt:9
#, no-wrap
#, fuzzy, no-wrap
msgid "\tpoint a (10, 20, 30);"
msgstr "\tpoint a (10, 20, 30);"

#. type: Plain text
#: cbot-help/point.txt:11
#, no-wrap
#, fuzzy, no-wrap
msgid "You can also set the variable taking one value after another:"
msgstr ""
"Вы также можете присвоить переменной значение поочередным присвоением "
"значений:"

#. type: \s; block (usually verbatim code)
#: cbot-help/point.txt:16
#, no-wrap
#, fuzzy, 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
#: cbot-help/point.txt:18
#, no-wrap
#, fuzzy, no-wrap
msgid "With these examples, the following <a cbot|cond>condition</a> is true:"
msgstr "После этого примера следующее <a cbot|cond>условие</a> будет правдивым:"

#. type: \s; block (usually verbatim code)
#: cbot-help/point.txt:22
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"\tif ( a == b )\n"
"\t{\n"
"\t}"
msgstr ""
"\tif ( a == b )\n"
"\t{\n"
"\t}"

#. type: Plain text
#: cbot-help/point.txt:24
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"<n/> \n"
"The following declaration :"
msgstr "Следующее объявление:"

#. type: \s; block (usually verbatim code)
#: cbot-help/point.txt:26
#, no-wrap
#, fuzzy, no-wrap
msgid "\tpoint c (4, 7);"
msgstr "\tpoint c (4, 7);"

#. type: Plain text
#: cbot-help/point.txt:28
#, no-wrap
#, fuzzy, no-wrap
msgid "Is equivalent to :"
msgstr "Эквивалентно:"

#. type: \s; block (usually verbatim code)
#: cbot-help/point.txt:33
#, no-wrap
#, fuzzy, 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
#: cbot-help/private.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>private</code> (for specialists)"
msgstr "Инструкция <code>private</code> (for specialists)"

#. type: Plain text
#: cbot-help/private.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"<a cbot|class>Class</a> members can be <a cbot|public>public</a> (by "
"default) or private. A member can be declared privat by putting "
"<code>private</code> before the type declaration of the member. Private "
"members are not accessible from outside the class definition."
msgstr ""
"Члены <a cbot|class>класса</a> могут быть <a cbot|public>общедоступны</a> "
"(по-умолчанию) или личными. Член может быть объявлен частным, если поставить "
"<code>private</code> до объявления элемента. Личные(локальные) члены не "
"доступны извне для других классов."

#. type: \s; block (usually verbatim code)
#: cbot-help/private.txt:16
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"public class MyClass\n"
"{\n"
"\tint    b;                // public by défault\n"
"\tpublic int a;            // als 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 MyClass\n"
"{\n"
"\tint    b;                // общедоступна по-умолчанию\n"
"\tpublic int a;            // всегда общедоступна\n"
"\tprivate point position;  // локальная/личная\n"
"}\n"
"void Test()\n"
"{\n"
"\tMyClass item;\n"
"\titem.a = item.b = 12;      // ок\n"
"\tmessage( item.position );  // это ошибка\n"
"}"

#. type: Plain text
#: cbot-help/private.txt:19
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>, <code><a "
"cbot|public>public</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|public>public</a></code>"
"\n"
"<a cbot>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/public.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>public</code> (for specialists)"
msgstr "Инструкция <code>public</code> (для специалистов)"

#. type: Plain text
#: cbot-help/public.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid "This instruction has two distinct purposes¦:"
msgstr "Эта команда имеет две различные цели¦:"

#. type: Bullet: '1)'
#: cbot-help/public.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid "Make a function available to other bots."
msgstr "Сделать функцию доступной для других ботов."

#. type: Bullet: '2)'
#: cbot-help/public.txt:5
#, no-wrap
#, fuzzy, no-wrap
msgid "Make a class member accessible from outside the class definition."
msgstr "Сделать член класса доступным извне для других классов."

#. type: \b; header
#: cbot-help/public.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>public</code> for functions"
msgstr "Инструкция <code>public</code> для функций"

#. type: Plain text
#: cbot-help/public.txt:9
#, no-wrap
#, fuzzy, 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 ""
"Еслы вы напишете <code>public</code> перед определением <a "
"cbot|function>функциии</a>, то вы сможете сделать эту программу доступной "
"для других ботов."

#. type: Plain text
#: cbot-help/public.txt:11
#, no-wrap
#, fuzzy, no-wrap
msgid "For example in the first bot we would have¦:"
msgstr "Например, вот программа первого бота¦:"

#. type: \s; block (usually verbatim code)
#: cbot-help/public.txt:17
#, no-wrap
#, fuzzy, 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 dist, float angle)\n"
"{\n"
"\tmove(dist);\n"
"\tturn(angle);\n"
"}"

#. type: Plain text
#: cbot-help/public.txt:19
#, no-wrap
#, fuzzy, no-wrap
msgid "And in another bot we would have¦:"
msgstr "А в другом боте мы имеем¦:"

#. type: \s; block (usually verbatim code)
#: cbot-help/public.txt:28
#, no-wrap
#, fuzzy, 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::Square( )\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
#: cbot-help/public.txt:30
#, no-wrap
#, fuzzy, 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 ""
"Если вы объявили функцию <code>общедоступной</code>, то вы сможете "
"использовать ее в других миссиях."

#. type: Plain text
#: cbot-help/public.txt:32
#, no-wrap
#, fuzzy, 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 ""
"Если бот, содержащий <code>общедоступную</code> функцию будет уничтожен, то "
"другие боты, использовавшие ее будут остановлены с ошибкой."

#. type: \b; header
#: cbot-help/public.txt:33
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>public</code> for classes"
msgstr "Инструкция <code>public</code> для классов"

#. type: Plain text
#: cbot-help/public.txt:35
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"<a cbot|class>Class</a> members can be public (by default) or <a "
"cbot|private>privat</a>. A member can be declared private by putting "
"<code>private</code> before the member type. Private members are not "
"accessible from outside the class definition."
msgstr ""
"Член <a cbot|class>класса</a> может быть общедоступен (по-умолчанию) или <a "
"cbot|private>быть личным</a>. Член может быть объявлен локальным с помощью "
"<code>private</code>, написав это перед самим членом. Закрытые члены будут "
"недоступны извне для других классов."

#. type: \s; block (usually verbatim code)
#: cbot-help/public.txt:48
#, no-wrap
#, fuzzy, 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 MyClass\n"
"{\n"
"\tint    b;                // общедоступно по-умолчанию\n"
"\tpublic int a;            // всегда общедоступно\n"
"\tprivate point position;  // личная\n"
"}\n"
"void Test()\n"
"{\n"
"\tMyClass item;\n"
"\titem.a = item.b = 12;      // ок\n"
"\tmessage( item.position );  // это ошибка\n"
"}"

#. type: Plain text
#: cbot-help/public.txt:51
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>, <code><a "
"cbot|private>private</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 ""
"<code><a cbot|class>class</a></code>, <code><a "
"cbot|private>private</a></code>, <code><a cbot|function>functions</a></code>"
"\n"
"<a cbot>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/radar.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>radar</code>"
msgstr "Инструкция <code>radar</code>"

#. type: Plain text
#: cbot-help/radar.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"With the instruction <code>radar()</code>, you can look for objects like <a "
"object|mother>enemies</a>, bots, buildings or raw materials."
msgstr ""
"С помощью инструкции <code>radar()</code> вы можете следить за такими "
"объектами как <a object|mother>враги</a>, боты, здания или природные "
"ископаемые."

#. type: Plain text
#: cbot-help/radar.txt:6
#, no-wrap
#, fuzzy, 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 ""
"В скобках напишите <a cbot|category>название объекта</a>, который вы ищете. "
"Поместите результат в переменную <a cbot|type>типа</a> <code>объекта</code>. "
"Вот пример поиска ближайшего муравья:"

#. type: \s; block (usually verbatim code)
#: cbot-help/radar.txt:12
#, no-wrap
#, fuzzy, 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 ""
"// В начале программы:\n"
"object  item; // объявление переменной\n"
"\n"
"// Поиск ближайшего муравья\n"
"item = radar(AlienAnt);"

#. type: \s; block (usually verbatim code)
#: cbot-help/radar.txt:16
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>radar ( category, angle, focus, min, max, way );<n/>"
msgstr "<c/>radar ( категория, угол, фокус, мин, макс, путь );<n/>"

#. type: Plain text
#: cbot-help/radar.txt:18
#, no-wrap
#, fuzzy, no-wrap
msgid "Detects an object according to several parameters. "
msgstr "Обнаруживает объект в соответствии с несколькими параметрами."

#. type: Image filename
#: cbot-help/radar.txt:19
#, no-wrap
#, fuzzy, no-wrap
msgid "radar1"
msgstr "radar1"

#. type: Plain text
#: cbot-help/radar.txt:21
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Seen from above, the purple zone corresponds to the zone where objects will "
"be detected. "
msgstr ""
"Как видно выше, пурпурная зона соответствует зоне, где будут обнаружены "
"объекты."

#. type: \t; header
#: cbot-help/radar.txt:22 cbot-help/search.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid "category: <code><a cbot|int>int</a></code>"
msgstr "категория: <code><a cbot|int>int</a></code>"

#. type: Plain text
#: cbot-help/radar.txt:24
#, no-wrap
#, fuzzy, 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>Категория</a> объекта, который нужно обнаружить. Например "
"когда вы ищете муравья, напишите <code>radar (AlienAnt)</code>."

#. type: \t; header
#: cbot-help/radar.txt:25
#, no-wrap
#, fuzzy, no-wrap
msgid "angle: <code><a cbot|float>float</a></code> (default value<code>0</code>)"
msgstr ""
"угол: <code><a cbot|float>float</a></code> (значение по "
"умолчанию<code>0</code>)"

#. type: Plain text
#: cbot-help/radar.txt:30
#, no-wrap
#, fuzzy, 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 ""
"Направление, в котором смотрит радар, в градусах.\n"
"<code>  0</code> -> радар смотрит прямо вперед\n"
"<code>-90</code> -> радар смотрит на четверть круга вправо\n"
"<code> 90</code> -> радар смотрит на четверть круга влево"

#. type: \t; header
#: cbot-help/radar.txt:31
#, no-wrap
#, fuzzy, no-wrap
msgid "focus: <code><a cbot|float>float</a></code> (default value<code>360</code>)"
msgstr ""
"фокус: <code><a cbot|float>float</a></code> (значение по "
"умолчанию<code>360</code>)"

#. type: Plain text
#: cbot-help/radar.txt:33
#, no-wrap
#, fuzzy, no-wrap
msgid "Opening angle of the radar, in degrees. "
msgstr "Угол раскрытия радара в градусах."

#. type: \t; header
#: cbot-help/radar.txt:34
#, no-wrap
#, fuzzy, no-wrap
msgid "min: <code><a cbot|float>float</a></code> (default value <code>0</code>)"
msgstr ""
"мин: <code><a cbot|float>float</a></code> (значение по умолчанию "
"<code>0</code>)"

#. type: Plain text
#: cbot-help/radar.txt:36
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Minimum detection distance, in meters. Objects that are closer than the "
"minimum distance will not be detected. "
msgstr ""
"Минимальное расстояние обнаружения в метрах. Объекты, которые находятся на "
"расстояниях меньших, чем минимальное расстояние, обнаружены не будут."

#. type: \t; header
#: cbot-help/radar.txt:37
#, no-wrap
#, fuzzy, no-wrap
msgid "max: <code><a cbot|float>float</a></code> (Default value<code>1000</code>)"
msgstr ""
"макс: <code><a cbot|float>float</a></code> (Значение по "
"умолчанию<code>1000</code>)"

#. type: Plain text
#: cbot-help/radar.txt:39
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Maximum detection distance, in meters. Objects that are farther away than "
"the maximum distance will not be detected. "
msgstr ""
"Максимальное расстояние обнаружения в метрах. Объекты, которые находятся на "
"расстояниях, больше максимального расстояния, обнаружены не будут."

#. type: \t; header
#: cbot-help/radar.txt:40
#, no-wrap
#, fuzzy, no-wrap
msgid "way: <code><a cbot|float>float</a></code> (default value<code>1</code>)"
msgstr ""
"путь: <code><a cbot|float>float</a></code> (значение по "
"умолчанию<code>1</code>)"

#. type: Plain text
#: cbot-help/radar.txt:42
#, no-wrap
#, fuzzy, 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 ""
"Определяет каким образом будут обнаруживаться объекты. Если его значение "
"<code>1</code>, то будет возвращен ближайший объект в указанной зоне. Если "
"значение <code>-1</code>, то будет возвращен самый дальний объект в зоне "
"обнаружения."

#. type: \t; header
#: cbot-help/radar.txt:43 cbot-help/retobj.txt:10 cbot-help/search.txt:13
#, no-wrap
#, fuzzy, no-wrap
msgid "Return value: <code><a cbot|object>object</a></code>"
msgstr "Возвращаемое значение: <code><a cbot|object>object</a></code>"

#. type: Plain text
#: cbot-help/radar.txt:45
#, no-wrap
#, fuzzy, 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 ""
"Возвращает первый найденный объект, который соответствует указанной "
"категории в указанной зоне. Если объект найден не был, то возвращается "
"значение <code><a cbot|null>null</a></code>."

#. type: \t; header
#: cbot-help/radar.txt:46
#, no-wrap
#, fuzzy, no-wrap
msgid "Remark"
msgstr "Замечание"

#. type: Plain text
#: cbot-help/radar.txt:48
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"You do not have to give all the parameters. Here are two examples of "
"instructions that are equivalent: "
msgstr ""
"Вы не должны указывать все параметры. Вот два примера эквивалентных "
"инструкций:"

#. type: \s; block (usually verbatim code)
#: cbot-help/radar.txt:51
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"\tradar(Titanium, 0, 360, 0, 1000);\n"
"\tradar(Titanium);  // equivalent"
msgstr ""
"\tradar(Titanium, 0, 360, 0, 1000);\n"
"\tradar(Titanium);  // эквивалентна предыдущей"

#. type: \s; block (usually verbatim code)
#: cbot-help/radar.txt:54
#, no-wrap
#, fuzzy, 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);  // эквивалентна предыдущей"

#. type: Plain text
#: cbot-help/radar.txt:57
#, no-wrap
#, fuzzy, 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 ""
"Когда не определен один или более параметров, то используются указанные выше "
"значения по умолчанию; обязателен только первый параметр.\n"
"Обычно указывается только первый параметр: например <code>radar "
"(AlienAnt)</code> обнаружит ближайшего муравья, где бы он ни был."

#. type: \b; header
#: cbot-help/readln.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>readln</code>"
msgstr "Инструкция <code>readln</code>"

#. type: Plain text
#: cbot-help/readln.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Читает одну строку из файла. это метод класса <code><a "
"cbot|file>file</a></code>. Это причина, почему мы всегда пишем "
"<code>handle.readln()</code>¦:"

#. type: \s; block (usually verbatim code)
#: cbot-help/readln.txt:5
#, no-wrap
#, fuzzy, no-wrap
msgid "\ts = handle.readln();"
msgstr "\ts = handle.readln();"

#. type: Plain text
#: cbot-help/readln.txt:7
#, no-wrap
#, fuzzy, 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 ""
"Файл должен быть октрыть на чтение (<code>\"r\"</code>) с помощью инструкции "
"<code><a cbot|open>open</a></code>. <code>readln</code> возвращает строку, "
"содержащую линию, но юез символа конца линии 0x0D (CR) и 0x0A (LF)."

#. type: \s; block (usually verbatim code)
#: cbot-help/readln.txt:10
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>string = handle.readln ( );<n/>"
msgstr "<c/>string = handle.readln ( );<n/>"

#. type: \s; block (usually verbatim code)
#: cbot-help/readln.txt:17
#, no-wrap
#, fuzzy, 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
#: cbot-help/readln.txt:20
#, no-wrap
#, fuzzy, 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> and <code><a cbot|eof>eof</a></code>.\n"
"<a cbot>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/receive.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>receive</code>"
msgstr "Инструкция <code>receive</code>"

#. type: \s; block (usually verbatim code)
#: cbot-help/receive.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>receive ( name, power );<n/>"
msgstr "<c/>receive ( имя, power );<n/>"

#. type: Plain text
#: cbot-help/receive.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Retrieves an information from the closest <a object|exchange>information "
"exchange post</a>."
msgstr ""
"Получает информацию от ближайшего <a object|exchange>поста обмена "
"информацией</a>."

#. type: Plain text
#: cbot-help/receive.txt:9
#, no-wrap
#, fuzzy, 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 ""
"Вид информации, которая нужна от поста обмена. Имя это строка: при написании "
"его нужно брать в пометки \" \"."

#. type: Plain text
#: cbot-help/receive.txt:12
#, 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 ""

#. type: Plain text
#: cbot-help/receive.txt:15
#, no-wrap
#, fuzzy, 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 ""
"Значение полученной информации. Если вблизи нет ни одного поста обмена, или "
"на посте обмена нет вида запрошенной информации, то возвращается значение "
"<code>nan</code>."

#. type: Plain text
#: cbot-help/receive.txt:18
#, no-wrap
#, fuzzy, 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 ""
"<a cbot>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/recycle.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>recycle</code>"
msgstr "Инструкция <code>recycle</code>"

#. type: \s; block (usually verbatim code)
#: cbot-help/recycle.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>recycle ( );<n/>"
msgstr "<c/>recycle ( );<n/>"

#. type: Plain text
#: cbot-help/recycle.txt:6
#, no-wrap
#, fuzzy, 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 ""
"Превращает брошенного бота перед <a object|botrecy>превращающим</a> в <a "
"object|titan>титановый куб</a>."

#. type: Plain text
#: cbot-help/recycle.txt:11
#, no-wrap
#, fuzzy, 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 ""
"Если все нормально, то возвращает ноль, если же возникла ошибка, то какое-то "
"число.\n"
"<code>== 0 </code>брошенный бот был превращен\n"
"<code>!= 0 </code>ошибка, брошенного бота нельзя переработать"

#. type: \b; header
#: cbot-help/retobj.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>retobject</code>"
msgstr "Инструкция <code>retobject</code>"

#. type: \s; block (usually verbatim code)
#: cbot-help/retobj.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>retobject ( number );<n/>"
msgstr "<c/>retobject ( число );<n/>"

#. type: Plain text
#: cbot-help/retobj.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid "Returns the object corresponding to the given number."
msgstr "Возвращает объект, соответствующий указанному числу."

#. type: \t; header
#: cbot-help/retobj.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid "number: <code><a cbot|int>int</a></code>"
msgstr "число: <code><a cbot|int>int</a></code>"

#. type: Plain text
#: cbot-help/retobj.txt:9
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Number of the object, between 0 and n. \"n\" represents the total number of "
"objects in the scene. "
msgstr ""
"Номер объекта может быть от 0 до n. \"n\" представляет собой общее "
"количество объектов на сцене."

#. type: Plain text
#: cbot-help/retobj.txt:12
#, no-wrap
#, fuzzy, 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 ""
"Объект соответствует числу. Если возвращаемое значение <code><a "
"cbot|null>null</a></code>, то это означает, что этому числу не соответствует "
"никакой объект, так как число слишком велико и на сцене нет такого "
"количества объектов."

#. type: \b; header
#: cbot-help/return.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>return</code>"
msgstr "Инструкция <code>return</code>"

#. type: Plain text
#: cbot-help/return.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid "Returns from a function. Syntax:"
msgstr ""
"С помощью этой функции вы можете немедленно выйти за пределы функции. "
"Синтаксис:"

#. type: \s; block (usually verbatim code)
#: cbot-help/return.txt:8
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"void function ( )\n"
"{\n"
"\treturn;\n"
"}"
msgstr ""
"<c/>void function ( )\n"
"{\n"
"\treturn;\n"
"}"

#. type: Plain text
#: cbot-help/return.txt:11
#, no-wrap
#, fuzzy, 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 ""
"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:"

#. type: \s; block (usually verbatim code)
#: cbot-help/return.txt:16
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"float Pi ( )\n"
"{\n"
"\treturn 3.1415;\n"
"}"
msgstr ""
"float Pi ( )\n"
"{\n"
"\treturn 3.1415;\n"
"}"

#. type: \s; block (usually verbatim code)
#: cbot-help/return.txt:21
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"float Mean (float a, float b)\n"
"{\n"
"\treturn (a+b)/2;\n"
"}"
msgstr ""
"float Mean (float a, float b)\n"
"{\n"
"\treturn (a+b)/2;\n"
"}"

#. type: \s; block (usually verbatim code)
#: cbot-help/return.txt:28
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"string Sign (float a)\n"
"{\n"
"\tif ( a > 0 )  return \"positive\";\n"
"\tif ( a < 0 )  return \"négative\";\n"
"\treturn \"null\";\n"
"}"
msgstr ""
"string Sign (float a)\n"
"{\n"
"\tif ( a > 0 )  return \"positive\";\n"
"\tif ( a < 0 )  return \"négative\";\n"
"\treturn \"null\";\n"
"}"

#. type: \b; header
#: cbot-help/search.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>search</code>"
msgstr "Инструкция <code>search</code>"

#. type: \s; block (usually verbatim code)
#: cbot-help/search.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>search ( category, position );<n/>"
msgstr "<c/>search ( категория, позиция );<n/>"

#. type: Plain text
#: cbot-help/search.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Detects the object of the given category that is closest to the given "
"position. "
msgstr ""
"Обнаруживает объект указанной категории, который ближе всего к указанной "
"позиции."

#. type: Plain text
#: cbot-help/search.txt:9
#, no-wrap
#, fuzzy, no-wrap
msgid "<a cbot|category>Category</a> of the requested object."
msgstr "<a cbot|category>Категория</a> нужного объекта."

#. type: \t; header
#: cbot-help/search.txt:10 cbot-help/topo.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid "position: <code><a cbot|point>point</a></code>"
msgstr "положение: <code><a cbot|point>point</a></code>"

#. type: Plain text
#: cbot-help/search.txt:12
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"<code>search</code> returns the object of the given category that is closest "
"to the position indicated here. "
msgstr ""
"<code>search</code> возвращает объект указанной категории, который ближе "
"всего к указанной здесь позиции."

#. type: Plain text
#: cbot-help/search.txt:15
#, no-wrap
#, fuzzy, 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 ""
"Характеристики объекта, который был найден. Значение <code><a "
"cbot|null>null</a></code> означает, что объект этой категории найден не был."

#. type: \b; header
#: cbot-help/send.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>send</code>"
msgstr "Инструкция <code>send</code>"

#. type: \s; block (usually verbatim code)
#: cbot-help/send.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>send ( name, value, power );<n/>"
msgstr "<c/>send ( name, value, power );<n/>"

#. type: Plain text
#: cbot-help/send.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Sends an information to the closest <a object|exchange>information exchange "
"post</a>."
msgstr ""
"Передает информуцию на ближайший <a object|exchange>пост обмена "
"информации</a>."

#. type: Plain text
#: cbot-help/send.txt:10
#, no-wrap
#, fuzzy, 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 ""
"Название информации, которая будет отправлена на пост обмена. Имя - это "
"строка: она должна быть написана в кавычках \"¦\".\n"
"Если есть информация с таким же названием, то новая запись будет создана, "
"также общее количество записей не должно превышать 10. Если же такое же имя "
"уже имеет информацию, то оно будет перезаписано."

#. type: \t; header
#: cbot-help/send.txt:11
#, no-wrap
#, fuzzy, no-wrap
msgid "value: <code>float</code>"
msgstr "value: <code>float</code>"

#. type: Plain text
#: cbot-help/send.txt:13
#, no-wrap
#, fuzzy, no-wrap
msgid "Value of the information to be sent."
msgstr "Значения для отправки."

#. type: Plain text
#: cbot-help/send.txt:16
#, no-wrap
#, fuzzy, 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 ""
"Сигнал. подающийся для отправки информации, от которого зависит и дистанця. "
"Стандартное значение - это 10 метров."

#. type: Plain text
#: cbot-help/send.txt:19
#, no-wrap
#, fuzzy, 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> and <code><a "
"cbot|delinfo>deleteinfo</a></code>.\n"
"<a cbot>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/shield.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>shield</code>"
msgstr "Инструкция <code>shield</code>"

#. type: \s; block (usually verbatim code)
#: cbot-help/shield.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>shield ( oper, radius );<n/>"
msgstr "<c/>shield ( опер );<n/>"

#. type: Plain text
#: cbot-help/shield.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Activates or deactivates the shield of the <a "
"object|botshld>ahielder</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 ""
"Активизирует или деактивизирует поля <a object|botshld>полевика</a>. Вы "
"можете конечно передвигать полевика при активных щитах. Оно защищает от "
"вражеского огня все объекты, которые находятся в сфере поля. Радиус сферы "
"может меняться от 10 до 25 метров."

#. type: \t; header
#: cbot-help/shield.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid "oper: <code><a cbot|float>float</a></code>"
msgstr "опер: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: cbot-help/shield.txt:11
#, no-wrap
#, fuzzy, 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> активизирует поле.\n"
"<code>0</code> деактивизирует поле\n"
"Обычная полностью заряженная <a object|power>энергетическая ячейка</a> может "
"поддерживать поля на протяжении 20 секунд. Когда энергия заканчивается, поле "
"снимается."

#. type: \t; header
#: cbot-help/shield.txt:12
#, no-wrap
#, fuzzy, no-wrap
msgid "radius: <code><a cbot|float>float</a></code>"
msgstr "радиус: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: cbot-help/shield.txt:14
#, no-wrap
#, fuzzy, no-wrap
msgid "Radius of the shield, ranging between 10 and 25 meters."
msgstr "Радиус поля, который меняется от 10 до 25 метров."

#. type: \b; header
#: cbot-help/sizeof.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>sizeof</code>"
msgstr "Инструкция <code>sizeof</code>"

#. type: Plain text
#: cbot-help/sizeof.txt:4
#, no-wrap
#, fuzzy, 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 ""
"Фунция sizeof позволяет узнать количестов элементов. содержащихся в <a "
"cbot|array>массиве</a>.\n"
"Т.е. индекс последнего элемента +1 (\"пустые\" элементы тоже считаются)."

#. type: \s; block (usually verbatim code)
#: cbot-help/sizeof.txt:10
#, no-wrap
#, fuzzy, 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) );  // will display 6\n"
"}"

#. type: Plain text
#: cbot-help/sizeof.txt:12
#, no-wrap
#, fuzzy, 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 ""
"В этом примере у нас есть 6 элементов в массиве после <code>a[5]=345</code>. "
"Не инициализированные элементы -  <code>[0]</code>, <code>[1]</code>, "
"<code>[2]</code>, <code>[3]</code> и <code>[4]</code> будут посчитаны."

#. type: Plain text
#: cbot-help/sizeof.txt:14
#, no-wrap
#, fuzzy, no-wrap
msgid "With multidimensionnal arrays you can get the size of a sub array:"
msgstr "С многомерными массивами вы можете получить размер суб массива:"

#. type: \s; block (usually verbatim code)
#: cbot-help/sizeof.txt:20
#, no-wrap
#, fuzzy, 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[][];  // 2 одномерных массива\n"
"xy[5][10] = 67;\n"
"message( sizeof(xy)    );  // выведем 6\n"
"message( sizeof(xy[5]) );  // выведем 11\n"

#. type: \b; header
#: cbot-help/sniff.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>sniff</code>"
msgstr "Инструкция <code>sniff</code>"

#. type: \s; block (usually verbatim code)
#: cbot-help/sniff.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>sniff ( );<n/>"
msgstr "<c/>sniff ( );<n/>"

#. type: Plain text
#: cbot-help/sniff.txt:6
#, no-wrap
#, fuzzy, 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 ""
"Проверяет землю перед <a object|botsr>проверяющим</a>. В зависимости от "
"того, какие были обнаружены природные ископаемые, будут созданы следующие "
"объекты:"

#. type: Plain text
#: cbot-help/sniff.txt:10
#, no-wrap
#, fuzzy, 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>TitaniumSpot</code>  ->  <a object|stonspot>Красный крест</a>\n"
"<code>UraniumSpot </code>  ->  <a object|uranspot>Желтый круг</a>\n"
"<code>PowerSpot   </code>  ->  <a object|enerspot>Зеленый крест</a>"

#. type: Plain text
#: cbot-help/sniff.txt:15
#, no-wrap
#, fuzzy, 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 ""
"Если все нормально, то будет возвращен ноль, если же возникла ошибка, то "
"будет возвращено другое значение.\n"
"<code>== 0 </code>проверка выполнена\n"
"<code>!= 0 </code>проверка невозможна"

#. type: \b; header
#: cbot-help/space.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>space</code>"
msgstr "Инструкция <code>space</code>"

#. type: \s; block (usually verbatim code)
#: cbot-help/space.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>space ( center, rmin, rmax, dist );<n/>"
msgstr "<c/>space ( центр, рмин, рмакс, раст );<n/>"

#. type: Plain text
#: cbot-help/space.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid "Determines the position of the nearest free space around a given position."
msgstr "Определяет положение ближайшего свободного места возле указанной точки."

#. type: \t; header
#: cbot-help/space.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid "center: <code><a cbot|point>point</a></code> (default: bot position)"
msgstr ""
"центр: <code><a cbot|point>point</a></code> (по умолчанию: положение бота)"

#. type: Plain text
#: cbot-help/space.txt:9
#, no-wrap
#, fuzzy, no-wrap
msgid "Desired position of the free space."
msgstr "Интересующая вас точка в пространстве."

#. type: \t; header
#: cbot-help/space.txt:10
#, no-wrap
#, fuzzy, no-wrap
msgid "rmin: <code><a cbot|float>float</a></code> (default value: <code>8</code>)"
msgstr ""
"рмин: <code><a cbot|float>float</a></code> (значение по умолчанию: "
"<code>8</code>)"

#. type: Plain text
#: cbot-help/space.txt:12
#, no-wrap
#, fuzzy, no-wrap
msgid "Minimum distance from the desired position."
msgstr "Минимальное расстояние от интересующей точки."

#. type: \t; header
#: cbot-help/space.txt:13
#, no-wrap
#, fuzzy, no-wrap
msgid "rmax: <code><a cbot|float>float</a></code> (default value: <code>50</code>)"
msgstr ""
"рмакс: <code><a cbot|float>float</a></code> (значение по умолчанию: "
"<code>50</code>)"

#. type: Plain text
#: cbot-help/space.txt:15
#, no-wrap
#, fuzzy, no-wrap
msgid "Maximum distance from the desired position."
msgstr "Максимальное расстояние от интересующей точки."

#. type: \t; header
#: cbot-help/space.txt:16
#, no-wrap
#, fuzzy, no-wrap
msgid "dist: <code><a cbot|float>float</a></code> (default value: <code>4</code>)"
msgstr ""
"раст: <code><a cbot|float>float</a></code> (значение по умолчанию: "
"<code>4</code>)"

#. type: Plain text
#: cbot-help/space.txt:18
#, no-wrap
#, fuzzy, no-wrap
msgid "Required distance between two free spaces."
msgstr "Требуемое расстояние между двумя свободными местами."

#. type: \t; header
#: cbot-help/space.txt:19
#, no-wrap
#, fuzzy, no-wrap
msgid "Return: <code><a cbot|point>point</a></code>"
msgstr "Возвращает: <code><a cbot|point>point</a></code>"

#. type: Plain text
#: cbot-help/space.txt:21
#, no-wrap
#, fuzzy, no-wrap
msgid "Position of the free space."
msgstr "Положение свободного места."

#. type: \b; header
#: cbot-help/static.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>static</code> (for specialists)"
msgstr "Инструкция <code>static</code> (для специалистов)"

#. type: Plain text
#: cbot-help/static.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"<a cbot|class>Class</a> members declared with <code>static</code> are shared "
"between all instances of the class."
msgstr ""
"Члены <a cbot|class>класса</a>, объявленные как <code>static</code>, "
"являются общими для всех экземпляров класса."

#. type: \s; block (usually verbatim code)
#: cbot-help/static.txt:17
#, no-wrap
#, fuzzy, 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 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] ); // вывести \"Hello\"\n"
"}"

#. type: Plain text
#: cbot-help/static.txt:19
#, no-wrap
#, fuzzy, 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 ""
"<code>Статичные</code> члены могут быть объявлены как <code><a "
"cbot|private>private</a></code>, таким образов они будут доступны только "
"внутри членов класса (including constructors and destructors)."

#. type: Plain text
#: cbot-help/static.txt:22
#, no-wrap
#, fuzzy, 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>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/strfind.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>strfind</code>"
msgstr "Инструкция <code>strfind</code>"

#. type: Plain text
#: cbot-help/strfind.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Поиск подстроки в строче и возвращение ее позиции (если найдена) или <a "
"cbot|nan>nan</a>, если поиск не дал результатов."

#. type: \s; block (usually verbatim code)
#: cbot-help/strfind.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>strfind ( string, sub );<n/>"
msgstr "<c/>strfind ( string, sub );<n/>"

#. type: \t; header
#: cbot-help/strfind.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid "string: <code><a cbot|string>string</a></code>"
msgstr "string: <code><a cbot|string>string</a></code>"

#. type: Plain text
#: cbot-help/strfind.txt:9
#, no-wrap
#, fuzzy, no-wrap
msgid "String we are searching in."
msgstr "Строчка, в которой будем искать."

#. type: \t; header
#: cbot-help/strfind.txt:10
#, no-wrap
#, fuzzy, no-wrap
msgid "sub: <code><a cbot|string>string</a></code>"
msgstr "sub: <code><a cbot|string>string</a></code>"

#. type: Plain text
#: cbot-help/strfind.txt:12
#, no-wrap
#, fuzzy, no-wrap
msgid "Substring we are searching for."
msgstr "Подстрока для поиска."

#. type: Plain text
#: cbot-help/strfind.txt:14 cbot-help/strleft.txt:11 cbot-help/strlen.txt:8 cbot-help/strlower.txt:8 cbot-help/strmid.txt:14 cbot-help/strright.txt:11 cbot-help/strupper.txt:8 cbot-help/strval.txt:5 cbot-help/strval.txt:12 cbot-help/writeln.txt:12
#, no-wrap
#, fuzzy, no-wrap
msgid "Examples¦:"
msgstr "Примеры¦:"

#. type: \s; block (usually verbatim code)
#: cbot-help/strfind.txt:17
#, no-wrap
#, fuzzy, 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\"); // позиция будет 0\n"
"\tint pos = strfind(\"abcdef\", \"de\"); // позиция будет 3\n"
"\tint pos = strfind(\"abcdef\", \"xy\"); // позиция будет <a cbot|nan>nan</a>"

#. type: Plain text
#: cbot-help/strfind.txt:20
#, no-wrap
#, fuzzy, 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>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/string.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Type <code>string</code>"
msgstr "Тип <code>string</code>"

#. type: Plain text
#: cbot-help/string.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid "Use a variable of this type for storing characters or strings."
msgstr ""
"Используйте переменные этого типа для хранения строки, которая может "
"состоять как из одного символа, так и из целого предложения."

#. type: Plain text
#: cbot-help/string.txt:5
#, no-wrap
#, fuzzy, no-wrap
msgid "For example: "
msgstr "Например:"

#. type: \s; block (usually verbatim code)
#: cbot-help/string.txt:9
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"<c/>\t\"Hello!\"\n"
"\t\"This is a string\"\n"
"\t\"x\"\n"
"\t\"\"  // empty string"
msgstr ""
"<c/>\t\"Привет!\"\n"
"\t\"Это строка\"\n"
"\t\"х\"\n"
"\t\"\"  // пустая строка"

#. type: Plain text
#: cbot-help/string.txt:11
#, no-wrap
#, fuzzy, no-wrap
msgid "You can append two strings with the <code>+</code> operator :"
msgstr "Чтобы соединить две строки, используйте оператор <code>+</code> :"

#. type: \s; block (usually verbatim code)
#: cbot-help/string.txt:12
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>\t\"Good morning,\" + \" \" + \"Sir\""
msgstr "<c/>\t\"Доброе утро,\" + \" \" + \"сер\""

#. type: Plain text
#: cbot-help/string.txt:14
#, no-wrap
#, fuzzy, no-wrap
msgid "Returns the string:"
msgstr "Получится строка:"

#. type: \s; block (usually verbatim code)
#: cbot-help/string.txt:15
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>\t\"Good morning, Sir\""
msgstr "<c/>\t\"Доброе утро, сер\""

#. type: Plain text
#: cbot-help/string.txt:17
#, no-wrap
msgid ""
"If you want to put a quotation mark (\") or a backslash (\\) in a string you "
"must write¦:"
msgstr ""

#. type: \s; block (usually verbatim code)
#: cbot-help/string.txt:18
#, no-wrap
msgid "<c/>\"This is \\\"very\\\" important\""
msgstr ""

#. type: Plain text
#: cbot-help/string.txt:19
#, no-wrap
msgid "<n/>which will result in the string <c/> This is \"very\" important."
msgstr ""

#. type: \s; block (usually verbatim code)
#: cbot-help/string.txt:20
#, no-wrap
msgid "<c/>\"%user%\\\\ant.txt\""
msgstr ""

#. type: Plain text
#: cbot-help/string.txt:21
#, no-wrap
msgid "<n/>will result in <c/>%user%\\ant.txt"
msgstr ""

#. type: Plain text
#: cbot-help/string.txt:31
#, no-wrap
#, fuzzy, 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 ""
"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"

#. type: \b; header
#: cbot-help/strleft.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>strleft</code>"
msgstr "Инструкция <code>strleft</code>"

#. type: Plain text
#: cbot-help/strleft.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid "Extracts the first (that is, leftmost) characters from a string."
msgstr "Извлекает первый (тот. что слева) символов в строке."

#. type: \s; block (usually verbatim code)
#: cbot-help/strleft.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>strleft ( string, len );<n/>"
msgstr "<c/>strleft ( string, len );<n/>"

#. type: \t; header
#: cbot-help/strleft.txt:7 cbot-help/strmid.txt:10 cbot-help/strright.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid "len: <code><a cbot|int>int</a></code>"
msgstr "len: <code><a cbot|int>int</a></code>"

#. type: Plain text
#: cbot-help/strleft.txt:9 cbot-help/strmid.txt:12 cbot-help/strright.txt:9
#, no-wrap
#, fuzzy, no-wrap
msgid "Number of characters to be extracted."
msgstr "Количество извлекаемых символов."

#. type: \s; block (usually verbatim code)
#: cbot-help/strleft.txt:13
#, no-wrap
#, fuzzy, 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 будет \"ab\"\n"
"\tstring s = strleft(\"abc\", 10);  // s будет \"abc\""

#. type: Plain text
#: cbot-help/strleft.txt:16
#, no-wrap
#, fuzzy, 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>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/strlen.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>strlen</code>"
msgstr "Инструкция <code>strlen</code>"

#. type: Plain text
#: cbot-help/strlen.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid "Get the length of a string."
msgstr "Возвращает длину строки."

#. type: \s; block (usually verbatim code)
#: cbot-help/strlen.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>strlen ( string );<n/>"
msgstr "<c/>strlen ( string );<n/>"

#. type: \s; block (usually verbatim code)
#: cbot-help/strlen.txt:11
#, no-wrap
#, fuzzy, 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\");  // длина = 3\n"
"\tint len = strlen(\"\");  // длина = 0\n"
"\tif ( strlen(s) == 0 )  // строка пуста ?"

#. type: Plain text
#: cbot-help/strlen.txt:14
#, no-wrap
#, fuzzy, 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>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/strlower.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>strlower</code>"
msgstr "Инструкция <code>strlower</code>"

#. type: Plain text
#: cbot-help/strlower.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid "Convert all characters in a string to lowercase."
msgstr "Переписывает все символы в нижнем регистре."

#. type: \s; block (usually verbatim code)
#: cbot-help/strlower.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>strlower ( string );<n/>"
msgstr "<c/>strlower ( string );<n/>"

#. type: \s; block (usually verbatim code)
#: cbot-help/strlower.txt:9
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>\tstring s = strlower(\"Abc\");  // s is \"abc\""
msgstr "<c/>\tstring s = strlower(\"Abc\");  // s будет \"abc\""

#. type: Plain text
#: cbot-help/strlower.txt:12
#, no-wrap
#, fuzzy, 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>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/strmid.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>strmid</code>"
msgstr "Инструкция <code>strmid</code>"

#. type: Plain text
#: cbot-help/strmid.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Extracts a substring of a given length starting at a given position from a "
"string."
msgstr ""
"Извлекает подстроку заданной длины, начиная с выбранной позиции строчки."

#. type: \s; block (usually verbatim code)
#: cbot-help/strmid.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>strmid ( string, pos, len );<n/>"
msgstr "<c/>strmid ( string, pos, len );<n/>"

#. type: \t; header
#: cbot-help/strmid.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid "pos: <code><a cbot|int>int</a></code>"
msgstr "pos: <code><a cbot|int>int</a></code>"

#. type: Plain text
#: cbot-help/strmid.txt:9
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"The index of the first character that is to be included in the extracted "
"substring."
msgstr "Индекс первого символа (начало считывания)"

#. type: \s; block (usually verbatim code)
#: cbot-help/strmid.txt:17
#, no-wrap
#, fuzzy, 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 = \"bc\"\n"
"\tstring s = strmid(\"abcdef\", 4, 5);  // s = \"ef\"\n"
"\tstring s = strmid(\"abcdef\", 9, 2);  // s = \"\""

#. type: Plain text
#: cbot-help/strmid.txt:20
#, no-wrap
#, fuzzy, 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>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/strright.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>strright</code>"
msgstr "Инструкция <code>strright</code>"

#. type: Plain text
#: cbot-help/strright.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid "Extracts the last (that is, rightmost) characters from a string."
msgstr "Извлекает последние символы из строки.."

#. type: \s; block (usually verbatim code)
#: cbot-help/strright.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>strright ( string, len );<n/>"
msgstr "<c/>strright ( string, len );<n/>"

#. type: \s; block (usually verbatim code)
#: cbot-help/strright.txt:13
#, no-wrap
#, fuzzy, 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 = \"ef\"\n"
"\tstring s = strright(\"abc\", 10);  // s = \"abc\""

#. type: Plain text
#: cbot-help/strright.txt:16
#, no-wrap
#, fuzzy, 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>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/strupper.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>strupper</code>"
msgstr "Инструкция <code>strupper</code>"

#. type: Plain text
#: cbot-help/strupper.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid "Convert all characters in a string to uppercase."
msgstr "Преобразует все символы в верхний регистр"

#. type: \s; block (usually verbatim code)
#: cbot-help/strupper.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>strupper ( string );<n/>"
msgstr "<c/>strupper ( string );<n/>"

#. type: \s; block (usually verbatim code)
#: cbot-help/strupper.txt:9
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>\tstring s = strupper(\"Abc\");  // s is \"ABC\""
msgstr "<c/>\tstring s = strupper(\"Abc\");  // s is \"ABC\""

#. type: Plain text
#: cbot-help/strupper.txt:12
#, no-wrap
#, fuzzy, 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>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/strval.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>strval</code>"
msgstr "Инструкция <code>strval</code>"

#. type: Plain text
#: cbot-help/strval.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Преобразует строку в число. Не путайте строку <code>\"45\"</code>, которая "
"содержит в себе на самом деле два символа - <code>4</code> и <code>5</code>, "
"и число <code>45</code>."

#. type: \s; block (usually verbatim code)
#: cbot-help/strval.txt:7
#, no-wrap
#, fuzzy, 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 содержит \"4512\"\n"
"\tfloat  n =  45 + 12;   // n содержит 67"

#. type: \s; block (usually verbatim code)
#: cbot-help/strval.txt:10
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>strval ( string );<n/>"
msgstr "<c/>strval ( string );<n/>"

#. type: \s; block (usually verbatim code)
#: cbot-help/strval.txt:16
#, no-wrap
#, fuzzy, 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 станет 1.23\n"
"\tfloat n = strval(\"12abc45\");  // n станет 12\n"
"\tfloat n = strval(\"abc\");      // n станет 0\n"
"\tfloat n = strval(\"100\")+2;    // n станет 102"

#. type: Plain text
#: cbot-help/strval.txt:19
#, no-wrap
#, fuzzy, 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>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/synchro.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>synchronized</code> (for specialists)"
msgstr "Инструкция <code>synchronized</code> (для специалистов)"

#. type: Plain text
#: cbot-help/synchro.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Метод <a cbot|class>класса</a> может быть объявлен с помощью "
"<code>synchronized</code>. Данный метод помогает убедиться в том, что какая-"
"либо функция никогда не выполняется более чем одним ботом."

#. type: Plain text
#: cbot-help/synchro.txt:5
#, no-wrap
#, fuzzy, no-wrap
msgid "The following example illustrates the problem:"
msgstr "Проиллюстрируем проблему:"

#. type: \s; block (usually verbatim code)
#: cbot-help/synchro.txt:17
#, no-wrap
#, fuzzy, 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 blocking\n"
"{\n"
"\tstatic int nb = 33;\n"
"\tsynchronized int inc( )\n"
"\t{\n"
"\t\tint val = nb;\n"
"\t\twait ( 2 );  // ждать 2 секунды.\n"
"\t\tnb = nb + 1;\n"
"\t\treturn val;\n"
"\t}\n"
"}"

#. type: Plain text
#: cbot-help/synchro.txt:20
#, no-wrap
#, fuzzy, 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 ""
"Что произойдет. если два боту будут выполнять метод <code>inc</code> в одно "
"время¦?\n"
"Оба она будут выполнять <code>val=nb</code> и ждать две секунды, так что "
"один из них будет иметь <code>val=33</code>. С помощью "
"<code>synchronized</code> первый бот начнет выполнение с <code>val=33</code> "
"и подождет 2 секунды, а затем вернет значение. Только после того, как первый "
"бот вернет значение из метода <code>inc</code>, второй бот начнет выполнять "
"метод <code>inc</code> и, следовательно, второй бот будет всегда иметь "
"<code>val=34</code>."

#. type: Plain text
#: cbot-help/synchro.txt:22
#, no-wrap
#, fuzzy, 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 ""
"Вы можете иметь больше синхронизаций <a cbot|class>классов</a> для того, "
"чтобы предотвратить выполнение одного метода более чем одним ботом. Другими "
"словами: до тех пор, пока один бот не закончит работу, другие боты не смогут "
"выполнить этот класс."

#. type: Plain text
#: cbot-help/synchro.txt:25
#, no-wrap
#, fuzzy, 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>class</a></code>, <code><a cbot|static>static</a></code>"
"\n"
"<a cbot>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/term.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Semicolon"
msgstr "Точка с запятой"

#. type: Plain text
#: cbot-help/term.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid "Always use a semicolon <c/>;<n/> after a simple expression. For example: "
msgstr ""
"После простого выражения всегда ставьте точку с запятой <c/>;<n/>. Например:"

#. type: \s; block (usually verbatim code)
#: cbot-help/term.txt:5
#, no-wrap
#, fuzzy, no-wrap
msgid "\tint counter = 0;"
msgstr "\tint counter = 0;"

#. type: Plain text
#: cbot-help/term.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid "However, after a <a cbot|bloc>bloc</a>, never put a semicolon:"
msgstr ""
"Тем не менее после <a cbot|bloc>блока</a> точка с запятой никогда не "
"ставятся:"

#. type: \s; block (usually verbatim code)
#: cbot-help/term.txt:12
#, no-wrap
#, fuzzy, 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 dist;\n"
"\t\tdist = distance(p1, p2);\n"
"\t} <n/>// здесь точки с запятой нет!<c/>"

#. type: Plain text
#: cbot-help/term.txt:14
#, no-wrap
#, fuzzy, 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 ""
"Также не используйте точку с запятой сразу же после инструкций <code><a "
"cbot|while>while</a></code>, <code><a cbot|if>if</a></code> и <code><a "
"cbot|for>for</a></code>:"

#. type: \s; block (usually verbatim code)
#: cbot-help/term.txt:19
#, no-wrap
#, fuzzy, 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/>// здесь нет точки с запятой!<c/>\n"
"\t{\n"
"\t\tb = 100-a;\n"
"\t}"

#. type: Plain text
#: cbot-help/term.txt:21
#, no-wrap
#, fuzzy, 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 ""
"Инструкции всегда заканчиваются точкой с запятой, а не концом строки. "
"Поэтому вы можете спокойно поместить в одну строку несколько инструкций:"

#. type: \s; block (usually verbatim code)
#: cbot-help/term.txt:25
#, no-wrap
#, fuzzy, 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
#: cbot-help/term.txt:27
#, no-wrap
#, fuzzy, no-wrap
msgid "Is equivalent to:"
msgstr "Это эквивалентно:"

#. type: \s; block (usually verbatim code)
#: cbot-help/term.txt:29
#, no-wrap
#, fuzzy, no-wrap
msgid "\tint d=20; move(d); turn(90);"
msgstr "\tint d=20; move(d); turn(90);"

#. type: \b; header
#: cbot-help/testinfo.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>testinfo</code>"
msgstr "Инструкция <code>testinfo</code>"

#. type: \s; block (usually verbatim code)
#: cbot-help/testinfo.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>testinfo ( name, power );<n/>"
msgstr "<c/>testinfo ( name, power );<n/>"

#. type: Plain text
#: cbot-help/testinfo.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Tests if an information exists in the closest <a object|exchange>information "
"exchange post</a>."
msgstr ""
"Проверяет, существует ли информация в ближайшем <a object|exchange>посту "
"обмена информацией</a>."

#. type: Plain text
#: cbot-help/testinfo.txt:9
#, no-wrap
#, fuzzy, 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 ""
"Имя информации, которое будет тестироваться на посту. Это имя представляет "
"из себя строку: оно должно быть написано в кавычках \"¦\"."

#. type: Plain text
#: cbot-help/testinfo.txt:12
#, no-wrap
#, fuzzy, 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 ""
"Мощность передатчика, которая соответствует максимальному расстоянию между "
"передатчиком и постом. Если дистанция большая, то функция вернет "
"<code>false(ложь)</code>. Стандартное значение 10 метров."

#. type: \t; header
#: cbot-help/testinfo.txt:13
#, no-wrap
#, fuzzy, no-wrap
msgid "Return: <code><a cbot|bool>bool</a></code>"
msgstr "Return: <code><a cbot|bool>bool</a></code>"

#. type: Plain text
#: cbot-help/testinfo.txt:15
#, no-wrap
#, fuzzy, 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 ""
"Возвращает <code>true(правда)</code>, если информация существует. Возвращает "
"<code>false</code>, если пост слишком далеко или на нем не записана такая "
"информация.."

#. type: Plain text
#: cbot-help/testinfo.txt:18
#, no-wrap
#, fuzzy, 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> "
"and <code><a cbot|delinfo>deleteinfo</a></code>.\n"
"<a cbot>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."

#. type: \b; header
#: cbot-help/this.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>this</code>"
msgstr "Инструкция <code>this</code>"

#. type: Plain text
#: cbot-help/this.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Иногда, методы <a cbot|class>класса</a> должны знать ссылку уже действующего "
"экземпляра. Например, экземпляр, возможно, захочет передать свои ссылки "
"другой функции. Неявное имя ссылки <code>this</code> доступно для методов, а "
"также <code>this</code> это ссылка на текущий экземпляр."

#. type: \s; block (usually verbatim code)
#: cbot-help/this.txt:26
#, no-wrap
#, fuzzy, 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 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();  // вывести \"Hello\"\n"
"}"

#. type: Plain text
#: cbot-help/this.txt:28
#, no-wrap
#, fuzzy, 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 ""
"Вы можете написать <code>this</code> перед методом, но в этом нет "
"необходимости. В приведенном ниже примере мы видим две строго одинаковых "
"строки:"

#. type: \s; block (usually verbatim code)
#: cbot-help/this.txt:31
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"\tm_int = 2;\n"
"\tthis.m_int = 2;  // identical"
msgstr ""
"\tm_int = 2;\n"
"\tthis.m_int = 2;  // они идентичны"

#. type: Plain text
#: cbot-help/this.txt:33
#, no-wrap
#, fuzzy, 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 ""
"В методе класса <code><a cbot|object>object</a></code>, вы можете "
"использовать <code>this.</code> перед именем поля."

#. type: \s; block (usually verbatim code)
#: cbot-help/this.txt:40
#, no-wrap
#, fuzzy, 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); // тоже самое, но\n"
"\t                           // более четко\n"
"}"

#. type: Plain text
#: cbot-help/this.txt:42
#, no-wrap
#, fuzzy, 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 ""
"Однако, если имя поля неизвестно, то объявление параметра или переменной "
"необходимо использовать вместе с <code>this</code>. В следущем примере имя "
"параметра <code>value</code> такое же, как и имя поля <code>value</code> <a "
"cbot|class>класса</a> <code>MyClass</code>, поэтому мы должны написать "
"<code>this.value</code> для того, чтобы отличить поле от параметра."

#. type: \s; block (usually verbatim code)
#: cbot-help/this.txt:51
#, no-wrap
#, fuzzy, 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 MyClass\n"
"{\n"
"\tint  value;\n"
"\tvoid Put( int value )\n"
"\t{\n"
"\t\tthis.value = value;\n"
"\t}\n"
"}"

#. type: Plain text
#: cbot-help/this.txt:54
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> et <a "
"cbot|category>catégories</a>."
msgstr ""
"<code><a cbot|class>class</a></code>\n"
"<a cbot>Программирование</a>, |l:типы\\u cbot<type/> и <a cbot\\"
"category>категории</a>."

#. type: \b; header
#: cbot-help/thump.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>thump</code>"
msgstr "Инструкция <code>thump</code>"

#. type: \s; block (usually verbatim code)
#: cbot-help/thump.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>thump ( );<n/>"
msgstr "<c/>thump ( );<n/>"

#. type: Plain text
#: cbot-help/thump.txt:6
#, no-wrap
#, fuzzy, 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 ""
"Активизирует системы вооружения <a object|bottump>тампера</a>, которые "
"заставляют мучиться пауков и муравьев, что делает их на некоторое время "
"совершенно безвредными."

#. type: Plain text
#: cbot-help/thump.txt:11
#, no-wrap
#, fuzzy, 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 ""
"Если все нормально, то значение будет равно нулю, если же оно не равно нулю, "
"то это значит, что возникла ошибка.\n"
"<code>== 0 </code>Удар нанесен\n"
"<code>!= 0 </code>Операция невозможна"

#. type: \b; header
#: cbot-help/topo.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>topo</code>"
msgstr "Инструкция <code>topo</code>"

#. type: \s; block (usually verbatim code)
#: cbot-help/topo.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>topo ( position );<n/>"
msgstr "<c/>topo ( положение );<n/>"

#. type: Plain text
#: cbot-help/topo.txt:6
#, no-wrap
#, fuzzy, 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 ""
"Возвращает высоту земли в указанной точке. Высота, равная нулю, "
"соответствует уровню моря. Отрицательное значение показывает, что к этой "
"точке земля покрыта водой."

#. type: Plain text
#: cbot-help/topo.txt:9
#, no-wrap
#, fuzzy, no-wrap
msgid "Coordinates of the position whose altitude you want to know. "
msgstr "Координаты точки, высоту которой вам нужно узнать."

#. type: Plain text
#: cbot-help/topo.txt:12
#, no-wrap
#, fuzzy, no-wrap
msgid "Altitude of the ground at the given position."
msgstr "Высота земли в указанной точке."

#. type: \b; header
#: cbot-help/true.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Type <code>true</code>"
msgstr "Тип <code>true</code>"

#. type: Plain text
#: cbot-help/true.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Это значение означает, что условие выполняется; это одно из двух значений, "
"которые может принимать <a cbot|bool>булевая</a> <a cbot|var>переменная</a>."

#. type: \b; header
#: cbot-help/turn.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>turn</code>"
msgstr "Инструкция <code>turn</code>"

#. type: Plain text
#: cbot-help/turn.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Используйте инструкцию <c/>turn();<n/> для того, чтобы выполнять вращение на "
"определенное количество градусов."

#. type: Plain text
#: cbot-help/turn.txt:6
#, no-wrap
#, fuzzy, 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 градусов означают поворот на четверть круга, 180 означают поворот на "
"половину круга. Положительный угол приведет к вращению против часовой "
"стрелки, а отрицательный угол приведет к вращению по часовой стрелке. Вот "
"несколько примеров использования <c/>turn();<n/>:"

#. type: Plain text
#: cbot-help/turn.txt:10
#, no-wrap
#, fuzzy, 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/>  поворот на четверть круга налево\n"
"<c/>turn(-90);<n/> поворот на четверть круга направо (отрицательный угол)\n"
"<c/>turn(180);<n/> половина оборота"

#. type: Plain text
#: cbot-help/turn.txt:12
#, no-wrap
#, fuzzy, 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 ""
"Для того, чтобы повернуть бота в направлении объекта, который был обнаружен "
"с помощью инструкции <c/><a cbot|radar>radar</a>();<n/>, вы должны вычислить "
"угол поворота с помощью инструкции <code><a "
"cbot|direct>direction</a>()</code>:"

#. type: \s; block (usually verbatim code)
#: cbot-help/turn.txt:15
#, no-wrap
#, fuzzy, 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
#: cbot-help/turn.txt:17
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"After these lines, just fire the cannon, and there is one hostile element "
"less."
msgstr ""
"После выполнения этих строк просто стреляйте из пушки и у вас будет на "
"одного врага меньше."

#. type: \s; block (usually verbatim code)
#: cbot-help/turn.txt:21
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>turn ( angle );<n/>"
msgstr "<c/>turn ( угол );<n/>"

#. type: Plain text
#: cbot-help/turn.txt:23
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Turns the bot with a given angle, right or left, without moving either "
"forward or backward. "
msgstr ""
"Поворачивает бота на указанный угол направо или налево, при этом не "
"передвигая его ни вперед, ни назад."

#. type: Plain text
#: cbot-help/turn.txt:26
#, no-wrap
#, fuzzy, 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 ""
"Угол требуемого поворота в градусах. Положительное значение означает поворот "
"налево, а отрицательное направо. <code>turn(180)</code> повернет вас на "
"половину круга."

#. type: Plain text
#: cbot-help/turn.txt:31
#, no-wrap
#, fuzzy, 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 ""
"Если все нормально, то значение будет равно нулю, если же возникла ошибка, "
"то оно будет отлично от нуля.\n"
"<code>== 0 </code>вращение выполнено\n"
"<code>!= 0 </code>вращение невозможно"

#. type: \b; header
#: cbot-help/type.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Variable types"
msgstr "Типы переменных"

#. type: Plain text
#: cbot-help/type.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid "When you define a <a cbot|var>variable</a>, you must give two elements: "
msgstr ""
"Когда вы определяете <a cbot|var>переменную</a>, вы должны дать ей два "
"атрибута:"

#. type: Bullet: '1)'
#: cbot-help/type.txt:4
#, no-wrap
#, fuzzy, no-wrap
msgid "a name"
msgstr "имя"

#. type: Bullet: '2)'
#: cbot-help/type.txt:5
#, no-wrap
#, fuzzy, no-wrap
msgid "a type"
msgstr "и тип"

#. type: Plain text
#: cbot-help/type.txt:8
#, no-wrap
#, fuzzy, 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 ""
"После того, как вы определили переменную, вы можете использовать ее для "
"хранения информации. Тем не менее информация, которую может хранить "
"переменная, должна быть правильного типа: переменная типа <a "
"cbot|float>float</a> не может содержать и так далее."

#. type: Plain text
#: cbot-help/type.txt:10
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"In a program, the name of a type is always written on <format type>green "
"background</format>. If the name of a type is not colored, 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 ""
"В программе имя типа всегда пишется на <format type>зеленом фоне</format>. "
"Если имя типа не окрашено, то это означает, что оно неправильно написано. "
"Имя типа всегда пишется маленькими буквами. Вот список различных типов:"

#. type: \s; block (usually verbatim code)
#: cbot-help/type.txt:12
#, no-wrap
#, fuzzy, no-wrap
msgid "<code><a cbot|int>int</a></code>"
msgstr "<code><a cbot|int>int</a></code>"

#. type: Plain text
#: cbot-help/type.txt:13
#, no-wrap
#, fuzzy, no-wrap
msgid "For a whole number (12, -500, etc.)."
msgstr "Для целых чисел (12, -500 и так далее.)."

#. type: \s; block (usually verbatim code)
#: cbot-help/type.txt:15
#, no-wrap
#, fuzzy, no-wrap
msgid "<code><a cbot|float>float</a></code>"
msgstr "<code><a cbot|float>float</a></code>"

#. type: Plain text
#: cbot-help/type.txt:16
#, no-wrap
#, fuzzy, no-wrap
msgid "For a real number (12, 3.14, 0.2, -99.98, etc.)."
msgstr "Для дробных чисел (12, 3.14, 0.2, -99.98 и так далее.)."

#. type: \s; block (usually verbatim code)
#: cbot-help/type.txt:18
#, no-wrap
#, fuzzy, no-wrap
msgid "<code><a cbot|bool>bool</a></code>"
msgstr "<code><a cbot|bool>bool</a></code>"

#. type: Plain text
#: cbot-help/type.txt:19
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"For a boolean variable, that can only take the values <code>true</code> or "
"<code>false</code>."
msgstr ""
"Для булевых переменных, которые могут принимать только два значения "
"<code>true</code> или <code>false</code>, то есть правда или ложь."

#. type: \s; block (usually verbatim code)
#: cbot-help/type.txt:21
#, no-wrap
#, fuzzy, no-wrap
msgid "<code><a cbot|string>string</a></code>"
msgstr "<code><a cbot|string>string</a></code>"

#. type: Plain text
#: cbot-help/type.txt:22
#, no-wrap
#, fuzzy, no-wrap
msgid "For texts (\"Hello!\", \"No object found\", etc.)"
msgstr "Для текста (\"Привет!\", \"Объект не найден\" и так далее.)"

#. type: \s; block (usually verbatim code)
#: cbot-help/type.txt:24
#, no-wrap
#, fuzzy, no-wrap
msgid "<code><a cbot|point>point</a></code>"
msgstr "<code><a cbot|point>point</a></code>"

#. type: Plain text
#: cbot-help/type.txt:25
#, no-wrap
#, fuzzy, 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 ""
"Для координат точки в пространстве; переменная этого типа состоит из трех "
"частей с именами x, y и z."

#. type: \s; block (usually verbatim code)
#: cbot-help/type.txt:27
#, no-wrap
#, fuzzy, no-wrap
msgid "<code><a cbot|object>object</a></code>"
msgstr "<code><a cbot|object>object</a></code>"

#. type: Plain text
#: cbot-help/type.txt:28
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"A variable of this type contains the information about an object (bot, "
"building, enemy, etc.)."
msgstr ""
"Переменная этого типа содержит информацию об объекте (боте, здании, враге и "
"так далее.)."

#. type: \s; block (usually verbatim code)
#: cbot-help/type.txt:30
#, no-wrap
#, fuzzy, no-wrap
msgid "<code><a cbot|void>void</a></code>"
msgstr "<code><a cbot|void>void</a></code>"

#. type: Plain text
#: cbot-help/type.txt:31
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"This type is an \"empty type\", that you use when you do not want to specify "
"a type."
msgstr ""
"Этот тип это \"пустой тип\", который используется тогда, когда вы не хотите "
"определять тип."

#. type: \b; header
#: cbot-help/var.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Variables"
msgstr "Переменные"

#. type: Plain text
#: cbot-help/var.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Переменная похожа на ящик, куда вы можете положить какую-то информацию. Во "
"время выполнения программы содержимое переменной может меняться."

#. type: Plain text
#: cbot-help/var.txt:5
#, no-wrap
#, fuzzy, 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 ""
"Например вы можете использовать переменную для того, чтобы сосчитать "
"количество единиц титановой руды, которое сборщик собрал и отнес в "
"переработчик. Вначале вы должны придумать для нее имя: имя должно быть не "
"очень длинным и при этом говорить о том, для чего используется эта "
"переменная. Давайте назовем ее <code>countTit</code>. Эта переменная может "
"содержать только целые числа, поэтому выберем тип <code>int</code>. "
"Переменную нужно объявить в начале программы. Затем нужно сохранить в "
"переменной значение <code>0</code> и каждый раз, когда вы будете подбирать "
"титановую руду, увеличивать ее значение на <code>1</code>. В каждый момент "
"времени переменная будет содержать количество единиц титановой руды, которую "
"собрал сборщик."

#. type: Plain text
#: cbot-help/var.txt:8
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"For the declaration of the variable, write the following line: \n"
"<c/><s/>\tint  countTit;<n/>"
msgstr ""
"Для объявления переменной напишите следующую строку:\n"
"<c/><s/>\tint  countTit;<n/>"

#. type: Plain text
#: cbot-help/var.txt:11
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"To put <code>0</code> into the variable, write:\n"
"<c/><s/>\tcountTit = 0;<n/>"
msgstr ""
"Чтобы записать в переменную <code>0</code>, напишите:\n"
"<c/><s/>\tcountTit = 0;<n/>"

#. type: Plain text
#: cbot-help/var.txt:14
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"At every titanium ore grabbed, write:\n"
"<c/><s/>\tcountTit = countTit + 1<n/>"
msgstr ""
"При каждом поднятии титановой руды пишите:\n"
"<c/><s/>\tcountTit = countTit + 1<n/>"

#. type: Plain text
#: cbot-help/var.txt:18
#, no-wrap
#, fuzzy, 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 ""
"В выборе имени для переменной у вас есть довольно много возможностей, вы "
"можете называть их как угодно, например: <code>dist</code>, "
"<code>direct</code>, <code>p2</code>, <code>a</code>, <code>x</code>, "
"<code>nothing_2_shoot_at</code> и так далее.\n"
"Имя всегда должно начинаться с латинской буквы. За ней может следовать любая "
"комбинация латинских букв, символов или символа подчеркивания <code>_</code>"
". Вы конечно не можете использовать для их названий ключевые слова языка "
"CBOT, как например <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> и так далее.\n"
"При выборе имен для переменных вы должны быть осторожны; написание программы "
"может стать очень сложным, если вы забудете имена переменных или если вы не "
"сможете вспомнить для чего они используются. Разработайте свою собственную "
"систему для придумывания имен переменных, но не используйте такие имена как "
"<code>Bmo45</code>, <code>a</code> или <code>tgBinX</code>."

#. type: Plain text
#: cbot-help/var.txt:20
#, no-wrap
#, fuzzy, 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 ""
"В приведенном выше примере ключевое слово <code>int</code> показывает, что "
"эта переменная может содержать только целые числа, которые соответствуют "
"подсчитываемым объектам. Если вы хотите измерить расстояние, то лучше "
"используйте переменную, которая может содержать и дробные числа с дробной "
"частью (например 3.45 или 0.034): в этом случае используйте тип "
"<code>float</code>."

#. type: Plain text
#: cbot-help/var.txt:22
#, no-wrap
#, fuzzy, no-wrap
msgid "In fact, a variable is made up of three parts:\n"
msgstr "Фактически переменная состоит из трех частей:\n"

#. type: Bullet: '1)'
#: cbot-help/var.txt:22
#, no-wrap
#, fuzzy, no-wrap
msgid "the name,"
msgstr "имени"

#. type: Bullet: '2)'
#: cbot-help/var.txt:23
#, no-wrap
#, fuzzy, no-wrap
msgid "the type of the information stored inside,"
msgstr "типа хранимой в ней информации"

#. type: Bullet: '3)'
#: cbot-help/var.txt:24
#, no-wrap
#, fuzzy, no-wrap
msgid "the content, i.e. the information itself."
msgstr "и содержимого, то есть самой информации"

#. type: \t; header
#: cbot-help/var.txt:26
#, no-wrap
#, fuzzy, no-wrap
msgid "the name"
msgstr "имя"

#. type: Plain text
#: cbot-help/var.txt:28
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"You need the name to be able to distinguish the different variables from "
"each other."
msgstr "Имя вам нужно для того, чтобы различать разнообразные переменные."

#. type: \t; header
#: cbot-help/var.txt:29
#, no-wrap
#, fuzzy, no-wrap
msgid "the type"
msgstr "тип"

#. type: Plain text
#: cbot-help/var.txt:32
#, no-wrap
#, fuzzy, 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:\n"
msgstr ""
"<a cbot|type>Тип</a> определяет какой вид информации может содержать "
"переменная. В зависимости от типа переменная может содержать целое число, "
"дробное число, строку, координаты точки, информацию об объекте и так далее.\n"
"Вот список наиболее часто используемых типов переменных:\n"

#. type: Bullet: 'o'
#: cbot-help/var.txt:32
#, no-wrap
#, fuzzy, 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> для целого числа (12, -500 и так далее.)"

#. type: Bullet: 'o'
#: cbot-help/var.txt:33
#, no-wrap
#, fuzzy, 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> для дробного числа (3.14, 0.2, -99.98 и "
"так далее.)"

#. type: Bullet: 'o'
#: cbot-help/var.txt:34
#, no-wrap
#, fuzzy, 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> для строки символов (\"Привет!\", \""
"Объект не найден\" и так далее.)"

#. type: Bullet: 'o'
#: cbot-help/var.txt:35
#, no-wrap
#, fuzzy, 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> для x,y и z-координат в пространстве"

#. type: Bullet: 'o'
#: cbot-help/var.txt:36
#, no-wrap
#, fuzzy, 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> для информации об объекте (бот, "
"здание и так далее.)"

#. type: \t; header
#: cbot-help/var.txt:38
#, no-wrap
#, fuzzy, no-wrap
msgid "The content"
msgstr "Содержимое"

#. type: Plain text
#: cbot-help/var.txt:40
#, no-wrap
#, fuzzy, 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 ""
"Содержимое переменной это информация того вида, который определен в типе. Во "
"время выполнения программы оно может меняться."

#. type: Plain text
#: cbot-help/var.txt:43
#, no-wrap
#, fuzzy, 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 ""
"После того, как вы объявили переменную, она еще не содержит никакого "
"значения. Что вы смогли ее использовать, нужно поместить в нее значение:\n"
"<c/><s/>\tint  i, j;"

#. type: \s; block (usually verbatim code)
#: cbot-help/var.txt:45
#, no-wrap
#, fuzzy, 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 принимает значение, равное 25\n"
"\tj = i;   // так писать нельзя, так как i еще ничего не содержит."

#. type: Plain text
#: cbot-help/var.txt:48
#, no-wrap
#, fuzzy, 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 ""
"Вы также можете в одной строке одновременно объявить переменную и записать в "
"нее значение, написав:\n"
"<c/><s/>\tint  countTit = 0;"

#. type: Plain text
#: cbot-help/var.txt:51
#, no-wrap
#, fuzzy, 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 ""
"Когда вы присваиваете значение переменной с помощью знака равенства "
"<code>=</code>, значение с правой стороны копируется в переменную с левой "
"стороны. Изучите следующий пример:\n"
"<c/><s/>\tint  i, j;"

#. type: \s; block (usually verbatim code)
#: cbot-help/var.txt:54
#, no-wrap
#, fuzzy, 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 принимает значение, равное 7\n"
"\tj = i+6;  // j принимает значение i плюс 6, то есть 13\n"
"\ti = j;    // i принимает значение j, то есть 13"

#. type: Plain text
#: cbot-help/var.txt:56
#, no-wrap
#, fuzzy, 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 ""
"В конце этого примера обе переменные <code>i</code> и <code>j</code> "
"содержат значение <code>13</code>."

#. type: Plain text
#: cbot-help/var.txt:59
#, no-wrap
#, fuzzy, 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 ""
"Последующее присвоение неправильно, так как с левой стороны знака равенства "
"<code>=</code>, может быть только имя переменной:\n"
"<c/><s/>\ti+2 = j;  // невозможно"

#. type: Plain text
#: cbot-help/var.txt:62
#, no-wrap
#, fuzzy, 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 ""
"Если вы хотите поменять местами значения двух переменных, то вы должны "
"использовать третью переменную. Вот пример обмена содержимого двух "
"переменных, <code>a</code> и <code>b</code> :\n"
"<c/><s/>\tint temp;"

#. type: \s; block (usually verbatim code)
#: cbot-help/var.txt:65
#, no-wrap
#, fuzzy, 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 ""
"\ttemp = a;  // temp принимает значение a\n"
"\ta = b;     // содержимое b копируется в a\n"
"\tb = temp;  // содержимое temp копируется в b"

#. type: \b; header
#: cbot-help/void.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Type <code>void</code>"
msgstr "Тип <code>void</code>"

#. type: Plain text
#: cbot-help/void.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid "Use this type when you want to declare a function that returns nothing."
msgstr ""
"Используйте этот тип, когда вы не хотите определять тип переменной, например "
"когда функция ничего не возвращает."

#. type: Plain text
#: cbot-help/void.txt:6
#, no-wrap
msgid ""
"Example:\n"
"<c/><s/>void MyFunction(int a)"
msgstr ""

#. type: \s; block (usually verbatim code)
#: cbot-help/void.txt:9
#, no-wrap
msgid ""
"{\n"
"\t...\n"
"}"
msgstr ""

#. type: \b; header
#: cbot-help/wait.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>wait</code>"
msgstr "Инструкция <code>wait</code>"

#. type: Plain text
#: cbot-help/wait.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"The instruction <c/>wait();<n/> instructs the bot to wait for some seconds, "
"according to the value written in brackets."
msgstr ""
"Инструкция <c/>wait();<n/> заставляет бота ждать несколько секунд, в "
"соответствии со значением, написанным внутри скобок."

#. type: Plain text
#: cbot-help/wait.txt:6
#, no-wrap
#, fuzzy, 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 ""
"Для того, чтобы подождать, пока на энергетической станции зарядится <a "
"object|power>энергетическая ячейка</a>, подождите 5 секунд с помощью команды "
"<c/>wait(5);<n/>."

#. type: Plain text
#: cbot-help/wait.txt:8
#, no-wrap
#, fuzzy, 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 ""
"Чтобы подождать, пока <a object|convert>преобразователь</a> закончит "
"преобразовывать <a object|titanore>титановую руду</a> в <a object|titan>"
"титановый куб</a>, подождите 15 секунд с помощью команды <c/>wait(15);<n/>."

#. type: \s; block (usually verbatim code)
#: cbot-help/wait.txt:12
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>wait ( time );<n/>"
msgstr "<c/>wait ( время );<n/>"

#. type: Plain text
#: cbot-help/wait.txt:14
#, no-wrap
#, fuzzy, no-wrap
msgid "Waits for a moment."
msgstr "Ждет некоторое время."

#. type: Plain text
#: cbot-help/wait.txt:17
#, no-wrap
#, fuzzy, no-wrap
msgid "Specifies the time that the bot must wait."
msgstr "Определяет время, которое должен ждать бот."

#. type: \b; header
#: cbot-help/while.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>while</code>"
msgstr "Инструкция <code>while</code>"

#. type: Plain text
#: cbot-help/while.txt:3
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"The instruction <code>while () {}</code> is used to repeat a set of "
"instructions several times."
msgstr ""
"Инструкция <code>while () {}</code> используется для того, чтобы несколько "
"раз повторять один и тот же набор инструкций."

#. type: Plain text
#: cbot-help/while.txt:6
#, no-wrap
#, fuzzy, 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:\n"
msgstr ""
"Наиболее часто <code>while</code> используется для того, чтобы снова и снова "
"повторять набор инструкций. Для того, чтобы добиться этого, напишите <code>"
"while (true) {}</code> и впишите инструкции, которые нужно повторять, в "
"скобки <code>{}</code>. Как пример здесь представлена программа, которая "
"снова и снова повторяет следующие действия:\n"

#. type: Bullet: 'o'
#: cbot-help/while.txt:6
#, no-wrap
#, fuzzy, no-wrap
msgid "look for a spider,"
msgstr "ищет паука,"

#. type: Bullet: 'o'
#: cbot-help/while.txt:7
#, no-wrap
#, fuzzy, no-wrap
msgid "turn towards it,"
msgstr "поворачивается к нему,"

#. type: Bullet: 'o'
#: cbot-help/while.txt:8
#, no-wrap
#, fuzzy, no-wrap
msgid "shoot."
msgstr "стреляет."

#. type: \s; block (usually verbatim code)
#: cbot-help/while.txt:16
#, no-wrap
#, fuzzy, 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
#: cbot-help/while.txt:18
#, no-wrap
#, fuzzy, no-wrap
msgid "Just execute this program once, and it will kill all spiders around it."
msgstr ""
"Запустите эту программу один раз и с ее помощью вы убьете всех пауков вокруг "
"вас."

#. type: \s; block (usually verbatim code)
#: cbot-help/while.txt:25
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"<code>while ( condition )\n"
"{\n"
"\t</code>Instructions ...<c/>\n"
"}"
msgstr ""
"<code>while ( условие )\n"
"{\n"
"\t</code>Инструкции ...<c/>\n"
"}"

#. type: Plain text
#: cbot-help/while.txt:27
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"This instruction allows you to perform the instructions inside the <a "
"cbot|bloc>block</a> several times."
msgstr ""
"Эта инструкция позволит вам выполнять инструкции внутри <a "
"cbot|bloc>блока</a> несколько раз."

#. type: Plain text
#: cbot-help/while.txt:29
#, no-wrap
#, fuzzy, 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 ""
"Будьте внимательны и не путайте инструкцию <code>while( ) { }</code> с "
"инструкцией <c/><a cbot|do>do</a> { } while( );<n/>; последняя проверяет "
"условие только после того, как инструкции внутри блока были один раз "
"выполнены."

#. type: \s; block (usually verbatim code)
#: cbot-help/while.txt:40
#, no-wrap
#, fuzzy, 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/>Инструкцияs ...<c/>\n"
"\ti = i+1;\n"
"}"

#. type: Plain text
#: cbot-help/while.txt:43
#, no-wrap
#, fuzzy, no-wrap
msgid ""
"Do not put a <a cbot|term>semicolon</a> at the end of the line <code>while ( "
")</code>."
msgstr ""
"Не вставляйте <a cbot|term>точку с запятой</a> в конец строки <code>while ( "
")</code>."

#. type: Plain text
#: cbot-help/while.txt:45
#, no-wrap
#, fuzzy, 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 ""
"Внутри блока, следующего за инструкцией <code>while { }<a cbot|break> могут "
"быть полезны инструкции </a></code>break<code><a cbot|continue> и "
"</a></code>continue<code></code>."

#. type: \b; header
#: cbot-help/writeln.txt:1
#, no-wrap
#, fuzzy, no-wrap
msgid "Instruction <code>writeln</code>"
msgstr "Инструкция <code>writeln</code>"

#. type: Plain text
#: cbot-help/writeln.txt:3
#, no-wrap
#, fuzzy, 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 ""
"Написать одну строку текаста в файл. Это метод класса <code><a "
"cbot|file>file</a></code>. Это причина, по которой мы пишем так - "
"<code>handle.writeln()</code>¦:"

#. type: \s; block (usually verbatim code)
#: cbot-help/writeln.txt:5
#, no-wrap
#, fuzzy, no-wrap
msgid "\thandle.writeln(\"abc\");"
msgstr "\thandle.writeln(\"abc\");"

#. type: Plain text
#: cbot-help/writeln.txt:7
#, no-wrap
#, fuzzy, 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 ""
"Файл должен быть открыт для записи (<code>\"w\"</code>) с помощью инструкции "
"<code><a cbot|open>open</a></code>. Линия автоматически заканчивается "
"сиволами 0x0D (CR) и 0x0A (LF)."

#. type: \s; block (usually verbatim code)
#: cbot-help/writeln.txt:10
#, no-wrap
#, fuzzy, no-wrap
msgid "<c/>handle.writeln ( string );<n/>"
msgstr "<c/>handle.writeln ( string );<n/>"

#. type: \s; block (usually verbatim code)
#: cbot-help/writeln.txt:14
#, no-wrap
#, fuzzy, no-wrap
msgid "\twriteln(\"Line of text\");"
msgstr "\twriteln(\"Line of text\");"

#. type: \s; block (usually verbatim code)
#: cbot-help/writeln.txt:18
#, no-wrap
#, fuzzy, 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
#: cbot-help/writeln.txt:21
#, no-wrap
#, fuzzy, 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> "
"and <code><a cbot|eof>eof</a></code>.\n"
"<a cbot>Программирование</a>, <a cbot|type>типы</a> и <a "
"cbot|category>категории</a>."