File: cbot.pot

package info (click to toggle)
colobot 0.2.2-3
links: PTS, VCS
area: main
in suites: forky, sid
size: 415,536 kB
sloc: cpp: 129,246; ansic: 8,872; python: 2,158; sh: 672; awk: 91; xml: 35; makefile: 31
file content (8228 lines) | stat: -rw-r--r-- 233,775 bytes
parent folder | download | duplicates (3)
# 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.
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"POT-Creation-Date: DATE\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: \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#. type: \b; header
#: ../E/abstime.txt:1
#, no-wrap
msgid "Instruction <code>abstime</code>"
msgstr ""

#. type: Plain text
#: ../E/abstime.txt:2 ../E/deletef.txt:6 ../E/delinfo.txt:2 ../E/errmode.txt:5 ../E/flatgrnd.txt:2 ../E/readln.txt:8 ../E/send.txt:2 ../E/strfind.txt:4 ../E/strleft.txt:4 ../E/strlen.txt:4 ../E/strlower.txt:4 ../E/strmid.txt:4 ../E/strright.txt:4 ../E/strupper.txt:4 ../E/strval.txt:8 ../E/testinfo.txt:2 ../E/writeln.txt:8
#, no-wrap
msgid "Syntax:"
msgstr ""

#. type: Source code
#: ../E/abstime.txt:3
#, no-wrap
msgid "<c/>abstime ( );<n/>"
msgstr ""

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

#. type: \t; header
#: ../E/abstime.txt:7
#, no-wrap
msgid "Return: <code><a cbot|float>float</a></code>"
msgstr ""

#. type: Plain text
#: ../E/abstime.txt:8
#, no-wrap
msgid "Time in seconds."
msgstr ""

#. type: \t; header
#: ../E/abstime.txt:10 ../E/acos.txt:11 ../E/aim.txt:23 ../E/array.txt:41 ../E/asin.txt:11 ../E/atan.txt:11 ../E/atan2.txt:16 ../E/bloc.txt:48 ../E/bool.txt:4 ../E/break.txt:24 ../E/build.txt:25 ../E/buildingenabled.txt:22 ../E/canbuild.txt:22 ../E/canresearch.txt:14 ../E/category.txt:119 ../E/ceil.txt:12 ../E/class.txt:120 ../E/close.txt:6 ../E/cond.txt:4 ../E/continue.txt:24 ../E/cos.txt:11 ../E/deflag.txt:12 ../E/deletef.txt:9 ../E/delinfo.txt:13 ../E/destroy.txt:15 ../E/detect.txt:27 ../E/direct.txt:13 ../E/dist.txt:29 ../E/dist2d.txt:13 ../E/do.txt:27 ../E/drop.txt:28 ../E/eof.txt:13 ../E/errmode.txt:32 ../E/expr.txt:198 ../E/extends.txt:105 ../E/extern.txt:29 ../E/factory.txt:61 ../E/false.txt:4 ../E/file.txt:16 ../E/fire.txt:30 ../E/flag.txt:19 ../E/flatgrnd.txt:16 ../E/flatspace.txt:25 ../E/float.txt:24 ../E/floor.txt:12 ../E/for.txt:51 ../E/function.txt:165 ../E/goto.txt:34 ../E/grab.txt:28 ../E/if.txt:39 ../E/int.txt:18 ../E/isbusy.txt:14 ../E/jet.txt:14 ../E/message.txt:24 ../E/motor.txt:38 ../E/move.txt:21 ../E/nan.txt:14 ../E/new.txt:20 ../E/null.txt:4 ../E/object.txt:83 ../E/open.txt:19 ../E/openfile.txt:11 ../E/pencolor.txt:14 ../E/pendown.txt:17 ../E/penup.txt:11 ../E/penwidth.txt:14 ../E/point.txt:35 ../E/pointer.txt:51 ../E/pow.txt:14 ../E/private.txt:19 ../E/produce.txt:30 ../E/protected.txt:26 ../E/public.txt:49 ../E/radar.txt:80 ../E/radarall.txt:19 ../E/rand.txt:8 ../E/readln.txt:18 ../E/receive.txt:16 ../E/recycle.txt:12 ../E/research.txt:18 ../E/researched.txt:14 ../E/researches.txt:29 ../E/retobj.txt:13 ../E/return.txt:29 ../E/round.txt:12 ../E/search.txt:25 ../E/send.txt:17 ../E/shield.txt:18 ../E/sin.txt:11 ../E/sizeof.txt:21 ../E/sniff.txt:16 ../E/space.txt:22 ../E/sqrt.txt:11 ../E/static.txt:20 ../E/strfind.txt:18 ../E/string.txt:32 ../E/strleft.txt:14 ../E/strlen.txt:12 ../E/strlower.txt:10 ../E/strmid.txt:18 ../E/strright.txt:14 ../E/strupper.txt:10 ../E/strval.txt:17 ../E/super.txt:45 ../E/switch.txt:70 ../E/synchro.txt:23 ../E/takeoff.txt:15 ../E/tan.txt:11 ../E/term.txt:30 ../E/testinfo.txt:16 ../E/this.txt:52 ../E/thump.txt:12 ../E/topo.txt:13 ../E/true.txt:4 ../E/trunc.txt:12 ../E/turn.txt:32 ../E/type.txt:32 ../E/var.txt:66 ../E/void.txt:10 ../E/wait.txt:21 ../E/while.txt:46 ../E/writeln.txt:19
#, no-wrap
msgid "See also"
msgstr ""

#. type: Plain text
#: ../E/abstime.txt:11 ../E/aim.txt:24 ../E/array.txt:42 ../E/bool.txt:5 ../E/break.txt:25 ../E/cond.txt:5 ../E/continue.txt:25 ../E/deflag.txt:13 ../E/deletef.txt:10 ../E/destroy.txt:16 ../E/detect.txt:28 ../E/direct.txt:14 ../E/dist.txt:30 ../E/dist2d.txt:14 ../E/drop.txt:29 ../E/errmode.txt:33 ../E/expr.txt:199 ../E/extern.txt:30 ../E/false.txt:5 ../E/fire.txt:31 ../E/flag.txt:20 ../E/flatgrnd.txt:17 ../E/flatspace.txt:26 ../E/float.txt:25 ../E/for.txt:52 ../E/function.txt:166 ../E/goto.txt:35 ../E/grab.txt:29 ../E/if.txt:40 ../E/int.txt:19 ../E/isbusy.txt:15 ../E/jet.txt:15 ../E/message.txt:25 ../E/move.txt:22 ../E/nan.txt:15 ../E/object.txt:84 ../E/openfile.txt:12 ../E/pencolor.txt:15 ../E/pendown.txt:18 ../E/penup.txt:12 ../E/penwidth.txt:15 ../E/point.txt:36 ../E/produce.txt:31 ../E/recycle.txt:13 ../E/retobj.txt:14 ../E/return.txt:30 ../E/search.txt:26 ../E/shield.txt:19 ../E/sizeof.txt:22 ../E/sniff.txt:17 ../E/space.txt:23 ../E/string.txt:33 ../E/switch.txt:71 ../E/takeoff.txt:16 ../E/term.txt:31 ../E/thump.txt:13 ../E/topo.txt:14 ../E/true.txt:5 ../E/turn.txt:33 ../E/type.txt:33 ../E/var.txt:67 ../E/void.txt:11 ../E/wait.txt:22
#, no-wrap
msgid "<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/aim.txt:1
#, no-wrap
msgid "Instruction <code>aim</code>"
msgstr ""

#. type: Plain text
#: ../E/break.txt:2 ../E/continue.txt:2 ../E/direct.txt:2 ../E/motor.txt:15 ../E/while.txt:20
#, no-wrap
msgid "Syntax :"
msgstr ""

#. type: Bullet: 'o'
#: ../E/aim.txt:6 ../E/fire.txt:14
#, no-wrap
msgid "<a object|botfr>Shooter</a>"
msgstr ""

#. type: Bullet: 'o'
#: ../E/aim.txt:7 ../E/fire.txt:15
#, no-wrap
msgid "<a object|botor>Orga shooter</a>"
msgstr ""

#. type: Bullet: 'o'
#: ../E/aim.txt:8 ../E/fire.txt:16
#, no-wrap
msgid "<a object|botphaz>Phazer shooter</a>"
msgstr ""

#. type: Plain text
#: ../E/fire.txt:18
#, no-wrap
msgid "When controlling the robot through programming, the only way to turn the gun left or right is to turn the whole robot with the instruction <code><a cbot|turn>turn</a></code>."
msgstr ""

#. type: \t; header
#: ../E/cos.txt:5 ../E/sin.txt:5 ../E/tan.txt:5 ../E/turn.txt:24
#, no-wrap
msgid "angle: <code><a cbot|float>float</a></code>"
msgstr ""

#. type: Plain text
#: ../E/aim.txt:13
#, no-wrap
msgid "Angle in degrees of the gun relative to the robot. A positive value orients the gun upward. For shooters and orga shooters, the angle must range from <code>-20</code> to <code>+20</code> degrees. For phazer shooters, the angle must range from <code>-20</code> to <code>45</code> degrees."
msgstr ""

#. type: \t; header
#: ../E/aim.txt:18 ../E/build.txt:20 ../E/deflag.txt:7 ../E/destroy.txt:10 ../E/drop.txt:23 ../E/factory.txt:16 ../E/fire.txt:25 ../E/flag.txt:14 ../E/goto.txt:29 ../E/grab.txt:23 ../E/move.txt:16 ../E/pencolor.txt:9 ../E/pendown.txt:12 ../E/penup.txt:6 ../E/penwidth.txt:9 ../E/recycle.txt:7 ../E/research.txt:13 ../E/sniff.txt:11 ../E/takeoff.txt:10 ../E/thump.txt:7 ../E/turn.txt:27
#, no-wrap
msgid "Return value: <code><a cbot|int>int</a></code>"
msgstr ""

#. type: Plain text
#: ../E/aim.txt:19
#, no-wrap
msgid ""
"Zero if everything is OK, a value different from zero if the rotation could not be performed: \n"
"<code>== 0 </code>The gun has now got the desired orientation\n"
"<code>!= 0 </code>rotation impossible"
msgstr ""

#. type: \b; header
#: ../E/array.txt:1
#, no-wrap
msgid "Arrays"
msgstr ""

#. type: Plain text
#: ../E/array.txt:2
#, no-wrap
msgid "An array is basically a collection of variables of the same type or class. You can use N dimensionnal arrays in the CBOT language. Each dimension is limited to 9999 elements. You must use square brackets <code>[]</code> after the type name or the variable name to declare an array."
msgstr ""

#. type: Plain text
#: ../E/array.txt:9
#, no-wrap
msgid "Actually when the CBOT interpreter encounters an array declaration, it just creates a <code><a cbot|null>null</a></code> <a cbot|pointer>reference</a>:"
msgstr ""

#. type: Source code
#: ../E/array.txt:11
#, no-wrap
msgid "int a[5];  // a is now a null reference"
msgstr ""

#. type: Plain text
#: ../E/array.txt:13
#, no-wrap
msgid "As soon as you put values into the array, the elements are created and the reference is initialized:"
msgstr ""

#. type: Source code
#: ../E/array.txt:15
#, no-wrap
msgid ""
"a[2] = 213;  // a points to\n"
"             // 3 elements [0], [1] et [2]"
msgstr ""

#. type: Plain text
#: ../E/array.txt:18
#, no-wrap
msgid "After this operation, <code>a</code> contains a reference to the elements of the array. Elements <code>[0]</code> and <code>[1]</code> are created but not initialized because an array cannot contain empty elements. The <code><a cbot|sizeof>sizeof</a></code> instruction allows you to obtain the number of elements contained in an array."
msgstr ""

#. type: Plain text
#: ../E/array.txt:20
#, no-wrap
msgid "When an array is declared with a maximum size, the program will stop as soon as there is an access beyond the maximum array size. No error is signalled during compilation even if the error is obvious:"
msgstr ""

#. type: Source code
#: ../E/array.txt:22
#, no-wrap
msgid ""
"{\n"
"\tint a[5];\n"
"\ta[7] = 123;  // no error at compile time\n"
"\t             // but error at run time\n"
"}"
msgstr ""

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

#. type: \b; header
#: ../E/bloc.txt:1
#, no-wrap
msgid "Blocks"
msgstr ""

#. type: Plain text
#: ../E/bloc.txt:2
#, no-wrap
msgid "You can use braces <code>{ }</code> to group a number of instructions together in order to make one single block out of them, for example: "
msgstr ""

#. type: Source code
#: ../E/bloc.txt:4
#, no-wrap
msgid ""
"\t{\n"
"\t\tfloat  t;\n"
"\t\tt = a;\n"
"\t\ta = b;\n"
"\t\tb = t;  // switches round a and b\n"
"\t}"
msgstr ""

#. type: Plain text
#: ../E/bloc.txt:11
#, no-wrap
msgid ""
"Every instruction in the block is followed by a <a cbot|term>semicolon</a>, but the block itself is not. \n"
"Let us take the following example with the instruction <code><a cbot|if>if</a></code> to illustrate the use of blocks in a program:"
msgstr ""

#. type: Source code
#: ../E/bloc.txt:14
#, no-wrap
msgid ""
"\tif ( a < b )\n"
"\t\t<n/>instruction 1<c/>;\n"
"\t\t<n/>instruction 2<c/>;\n"
"\t<n/>instruction 3<c/>;"
msgstr ""

#. type: Plain text
#: ../E/bloc.txt:19
#, no-wrap
msgid ""
"If the <a cbot|cond>condition</a> is true, instructions 1, 2 and 3 are performed. If the condition is false, only instruction 1 is ignored, instructions 2 and 3 are performed. The fact that instruction 2 is lined up with instruction 1 does not matter. \n"
"If you want to perform instructions 1 and 2 only if the condition is true, you have to bracket them together in a block: "
msgstr ""

#. type: Source code
#: ../E/bloc.txt:22
#, no-wrap
msgid ""
"\tif ( a < b )\n"
"\t{\n"
"\t\t<n/>instruction 1<c/>;\n"
"\t\t<n/>instruction 2<c/>;\n"
"\t}\n"
"\t<n/>instruction 3<c/>;"
msgstr ""

#. type: Plain text
#: ../E/bloc.txt:29
#, no-wrap
msgid ""
"Blocks may be needed with instructions <code><a cbot|if>if</a></code>, <code><a cbot|while>while</a></code> and <code><a cbot|for>for</a></code>, in order to group several instructions that should be performed only if a condition is true, or repeated several times. \n"
"You can fit blocks into other blocks, on as many levels as you need. Here is an example of imbrication on two levels :"
msgstr ""

#. type: Source code
#: ../E/bloc.txt:32
#, no-wrap
msgid ""
"\tif ( a > b )\n"
"\t{\n"
"\t\tint  i = 0;\n"
"\t\twhile ( i < 18 )\n"
"\t\t{\n"
"\t\t\tmove(10);\n"
"\t\t\tturn(5);\n"
"\t\t\ti = i+1;\n"
"\t\t}\n"
"\t}"
msgstr ""

#. type: Plain text
#: ../E/bloc.txt:43
#, no-wrap
msgid "You had better line up the open brace <code>{</code> with the closing brace <code>}</code> in order to improve readability, but it is not compulsory. The following example takes less space, is equivalent to the previous example, but it is not advisable to write your programs in the following style : "
msgstr ""

#. type: Source code
#: ../E/bloc.txt:45
#, no-wrap
msgid ""
"\tif(a>b) { int i=0; while(i<18) {\n"
"\tmove(10);turn(5);i=i+1; }}"
msgstr ""

#. type: Plain text
#: ../E/bloc.txt:49 ../E/do.txt:28 ../E/motor.txt:39 ../E/while.txt:47
#, no-wrap
msgid "<a cbot>Instructions</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/bool.txt:1
#, no-wrap
msgid "Type <code>bool</code>"
msgstr ""

#. type: Plain text
#: ../E/bool.txt:2
#, no-wrap
msgid "In a variable of this type you can put a boolean value, that is a value that can take only two states: true or false. "
msgstr ""

#. type: \b; header
#: ../E/break.txt:1
#, no-wrap
msgid "Instruction <code>break</code>"
msgstr ""

#. type: Source code
#: ../E/break.txt:3
#, no-wrap
msgid ""
"<c/>while ( condition )\n"
"{\n"
"\tbreak;\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/break.txt:8
#, no-wrap
msgid "With this instruction, you can get out immediately of a <code><a cbot|while>while</a></code> or <code><a cbot|for>for</a></code> loop."
msgstr ""

#. type: Plain text
#: ../E/break.txt:10 ../E/continue.txt:10
#, no-wrap
msgid "Here is an example:"
msgstr ""

#. type: Source code
#: ../E/break.txt:11
#, no-wrap
msgid ""
"<c/>int i = 0;\n"
"while ( true )\n"
"{\n"
"\t<n/>Instructions ...<c/>\n"
"\ti = i+1;\n"
"\tif ( i >= 10 )\n"
"\t{\n"
"\t\tbreak;\n"
"\t}\n"
"\t<n/>more instructions ...<c/>\n"
"}"
msgstr ""

#. type: \b; header
#: ../E/category.txt:1
#, no-wrap
msgid "Value <code>Categories</code>"
msgstr ""

#. type: Plain text
#: ../E/category.txt:2
#, no-wrap
msgid "Categories represent the names of objects in the CBOT language. Everything in COLOBOT is an object: robots, buildings, raw materials, etc., even yourself."
msgstr ""

#. type: Plain text
#: ../E/category.txt:34
#, no-wrap
msgid ""
"       <code><a object|titanore>TitaniumOre</a>          </code>Titanium Ore\n"
"       <code><a object|uranore>UraniumOre</a>           </code>Uranium Ore\n"
"       <code><a object|titan>Titanium</a>             </code>Cube of converted Titanium\n"
"       <code><a object|power>PowerCell</a>            </code>Regular Power Cell\n"
"       <code><a object|atomic>NuclearCell</a>          </code>Nuclear Power Cell\n"
"       <code><a object|bullet>OrgaMatter</a>           </code>Organic Matter\n"
"       <code><a object|bbox>BlackBox</a>             </code>Black Box\n"
"       <code><a object|tnt>TNT</a>                  </code>Explosive device\n"
"       <code><a object|key>KeyA..D</a>              </code>Keys A, B, C and D"
msgstr ""

#. type: Plain text
#: ../E/category.txt:47
#, no-wrap
msgid ""
"<button 158/>   <code><a object|bottr>PracticeBot</a>            </code>Practice Bot\n"
"<button 173/>   <code><a object|bottarg>TargetBot</a>              </code>Target Bot"
msgstr ""

#. type: Plain text
#: ../E/category.txt:50
#, no-wrap
msgid ""
"<button 137/>   <code><a object|botgr>WheeledGrabber</a>         </code>Wheeled Grabber\n"
"<button 138/>   <code><a object|botgc>TrackedGrabber</a>         </code>Tracked Grabber\n"
"<button 139/>   <code><a object|botgj>WingedGrabber</a>          </code>Winged Grabber\n"
"<button 150/>   <code><a object|botgs>LeggedGrabber</a>          </code>Legged Grabber"
msgstr ""

#. type: Plain text
#: ../E/category.txt:55
#, no-wrap
msgid ""
"<button 140/>   <code><a object|botsr>WheeledSniffer</a>         </code>Wheeled Sniffer\n"
"<button 141/>   <code><a object|botsc>TrackedSniffer</a>         </code>Tracked Sniffer\n"
"<button 142/>   <code><a object|botsj>WingedSniffer</a>          </code>Winged Sniffer\n"
"<button 152/>   <code><a object|botss>LeggedSniffer</a>          </code>Legged Sniffer"
msgstr ""

#. type: Plain text
#: ../E/category.txt:60
#, no-wrap
msgid ""
"<button 143/>   <code><a object|botfr>WheeledShooter</a>         </code>Wheeled Shooter\n"
"<button 144/>   <code><a object|botfc>TrackedShooter</a>         </code>Tracked Shooter\n"
"<button 145/>   <code><a object|botfj>WingedShooter</a>          </code>Winged Shooter\n"
"<button 151/>   <code><a object|botfs>LeggedShooter</a>          </code>Legged Shooter"
msgstr ""

#. type: Plain text
#: ../E/category.txt:65
#, no-wrap
msgid ""
"<button 153/>   <code><a object|botor>WheeledOrgaShooter</a>     </code>Wheeled Orga Shooter\n"
"<button 154/>   <code><a object|botoc>TrackedOrgaShooter</a>     </code>Tracked Orga Shooter\n"
"<button 155/>   <code><a object|botoj>WingedOrgaShooter</a>      </code>Winged Orga Shooter\n"
"<button 156/>   <code><a object|botos>LeggedOrgaShooter</a>      </code>Legged Orga Shooter"
msgstr ""

#. type: Plain text
#: ../E/category.txt:75
#, no-wrap
msgid ""
"<button 149/>   <code><a object|botsub>Subber</a>                 </code>Subber\n"
"<button 148/>   <code><a object|botrecy>Recycler</a>               </code>Recycler\n"
"<button 157/>   <code><a object|botshld>Shielder</a>               </code>Shielder\n"
"<button 146/>   <code><a object|bottump>Thumper</a>                </code>Thumper\n"
"<button 147/>   <code><a object|botphaz>PhazerShooter</a>          </code>Phazer Shooter"
msgstr ""

#. type: Plain text
#: ../E/category.txt:84
#, no-wrap
msgid ""
"       <code><a object|mother>AlienQueen</a>         </code>Alien Queen\n"
"       <code><a object|egg>AlienEgg</a>           </code>Alien Egg\n"
"       <code><a object|ant>AlienAnt</a>           </code>Ant\n"
"       <code><a object|spider>AlienSpider</a>        </code>Spider\n"
"       <code><a object|wasp>AlienWasp</a>          </code>Wasp\n"
"       <code><a object|worm>AlienWorm</a>          </code>Worm"
msgstr ""

#. type: Plain text
#: ../E/category.txt:120
#, no-wrap
msgid "<a cbot>CBOT Language</a> and <a cbot|type>Variables</a>."
msgstr ""

#. type: \b; header
#: ../E/class.txt:1
#, no-wrap
msgid "Instruction <code>class</code>"
msgstr ""

#. type: Source code
#: ../E/class.txt:4
#, no-wrap
msgid ""
"public class ClassName\n"
"{\n"
"\tdeclarations;\n"
"}"
msgstr ""

#. type: \b; header
#: ../E/close.txt:1
#, no-wrap
msgid "Instruction <code>close</code>"
msgstr ""

#. type: Plain text
#: ../E/close.txt:2
#, no-wrap
msgid "Close a file opened previously with <code><a cbot|open>open</a></code>. This is a method of the <code><a cbot|file>file</a></code> class; therefore you cannot write  <code>close()</code> but only <code>handle.close()</code>:"
msgstr ""

#. type: Source code
#: ../E/close.txt:4
#, no-wrap
msgid "\thandle.close();"
msgstr ""

#. type: Plain text
#: ../E/close.txt:7
#, no-wrap
msgid ""
"<code><a cbot|file>file</a></code>, <code><a cbot|open>open</a></code>, <code><a cbot|readln>readln</a></code>, <code><a cbot|writeln>writeln</a></code> and <code><a cbot|eof>eof</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/cond.txt:1
#, no-wrap
msgid "Conditions"
msgstr ""

#. type: Plain text
#: ../E/expr.txt:117
#, 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 ""

#. type: Plain text
#: ../E/expr.txt:125
#, 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 ""

#. type: Plain text
#: ../E/expr.txt:133
#, 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 ""

#. type: Plain text
#: ../E/expr.txt:135
#, 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 ""

#. type: \b; header
#: ../E/continue.txt:1
#, no-wrap
msgid "Instruction <code>continue</code>"
msgstr ""

#. type: Source code
#: ../E/continue.txt:3
#, no-wrap
msgid ""
"<c/>while ( condition )\n"
"{\n"
"\tcontinue;\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/continue.txt:8
#, no-wrap
msgid "With this instruction, you can jump over the rest of instructions in the <code><a cbot|bloc>bloc</a></code> of a <code><a cbot|while>while</a></code> or <code><a cbot|for>for</a></code> loop: The execution will resume at the beginning of the bloc, the next time the loop is repeated."
msgstr ""

#. type: Source code
#: ../E/continue.txt:11
#, no-wrap
msgid ""
"<c/>int i = 0;\n"
"while ( i < 5 )\n"
"{\n"
"\ti = i+1;\n"
"\tif ( i == 3 )\n"
"\t{\n"
"\t\tcontinue;\n"
"\t}\n"
"\t<n/>Instructions ...<c/>\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/continue.txt:22
#, no-wrap
msgid "The instructions will only be executed for the values of <code>i</code> 1, 2, 4 and 5."
msgstr ""

#. type: \b; header
#: ../E/deletef.txt:1
#, no-wrap
msgid "Instruction <code>deletefile</code>"
msgstr ""

#. type: Plain text
#: ../E/deletef.txt:2
#, no-wrap
msgid "The deletefile instruction deletes an existing file in the files/ folder. "
msgstr ""

#. type: Plain text
#: ../E/deletef.txt:4
#, no-wrap
msgid "Files can only be deleted in the files/ folder which is located in the folder inside Colobot save directory. You cannot not delete files that are located elsewhere than in the files/ folder."
msgstr ""

#. type: Source code
#: ../E/deletef.txt:7
#, no-wrap
msgid "<c/>deletefile ( filename );<n/>"
msgstr ""

#. type: \b; header
#: ../E/delinfo.txt:1
#, no-wrap
msgid "Instruction <code>deleteinfo</code>"
msgstr ""

#. type: Source code
#: ../E/delinfo.txt:3
#, no-wrap
msgid "<c/>deleteinfo ( name, power );<n/>"
msgstr ""

#. type: Plain text
#: ../E/delinfo.txt:5
#, no-wrap
msgid "Delete an existing information in the closest <a object|exchange>information exchange post</a>."
msgstr ""

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

#. type: Plain text
#: ../E/delinfo.txt:8
#, no-wrap
msgid "Name of the information to be deleted. This name is a string: it must be written in quotation marks \"\"."
msgstr ""

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

#. type: Plain text
#: ../E/delinfo.txt:11
#, no-wrap
msgid "Power of the transmitter, which corresponds to the maximal distance between the sender and the exchange post. If the distance is longer, the information won't be deleted. Default value is 10 metres."
msgstr ""

#. type: Plain text
#: ../E/delinfo.txt:14
#, no-wrap
msgid ""
"<code><a cbot|receive>receive</a></code>, <code><a cbot|send>send</a></code> and <code><a cbot|testinfo>testinfo</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/direct.txt:1
#, no-wrap
msgid "Instruction <code>direction</code>"
msgstr ""

#. type: Source code
#: ../E/direct.txt:3
#, no-wrap
msgid "<c/>direction ( pos );<n/>"
msgstr ""

#. type: Plain text
#: ../E/direct.txt:5
#, no-wrap
msgid "Calculates the rotation that a robot must perform in order to point towards a given position. "
msgstr ""

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

#. type: Plain text
#: ../E/direct.txt:8
#, no-wrap
msgid "Position towards which the robot must point."
msgstr ""

#. type: \t; header
#: ../E/acos.txt:8 ../E/asin.txt:8 ../E/atan.txt:8 ../E/atan2.txt:13 ../E/ceil.txt:9 ../E/cos.txt:8 ../E/direct.txt:10 ../E/dist.txt:26 ../E/dist2d.txt:10 ../E/flatgrnd.txt:13 ../E/floor.txt:9 ../E/pow.txt:11 ../E/rand.txt:5 ../E/receive.txt:13 ../E/round.txt:9 ../E/sin.txt:8 ../E/sqrt.txt:8 ../E/tan.txt:8 ../E/topo.txt:10 ../E/trunc.txt:9
#, no-wrap
msgid "Return value: <code><a cbot|float>float</a></code>"
msgstr ""

#. type: Plain text
#: ../E/direct.txt:11
#, no-wrap
msgid "Angle of the rotation that must be performed. -90 means f. ex. a rotation of 90 degrees to the right. "
msgstr ""

#. type: \b; header
#: ../E/dist.txt:1
#, no-wrap
msgid "Instruction <code>distance</code>"
msgstr ""

#. type: Plain text
#: ../E/dist.txt:2
#, no-wrap
msgid "With the instruction <code>distance( , )</code> you can calculate the distance between two positions."
msgstr ""

#. type: \b; header
#: ../E/build.txt:4 ../E/buildingenabled.txt:4 ../E/canbuild.txt:4 ../E/dist.txt:4 ../E/drop.txt:4 ../E/fire.txt:4 ../E/function.txt:16 ../E/goto.txt:4 ../E/grab.txt:4 ../E/if.txt:4 ../E/motor.txt:4 ../E/move.txt:4 ../E/radar.txt:4 ../E/switch.txt:4 ../E/turn.txt:4 ../E/wait.txt:4 ../E/while.txt:4
#, no-wrap
msgid "Basic use"
msgstr ""

#. type: Plain text
#: ../E/dist.txt:5
#, no-wrap
msgid "If you write <code>position</code> alone, this gives you the position of the bot that executes the program. If you write the name of a variable followed by <code>.position</code>, this gives you the position of the object described in the variable."
msgstr ""

#. type: Plain text
#: ../E/dist.txt:7
#, no-wrap
msgid "Here is a program that moves forward, covering exactly the distance between the bot and the closest ant:"
msgstr ""

#. type: Source code
#: ../E/dist.txt:9
#, no-wrap
msgid ""
"\titem = <a cbot|radar>radar</a>(AlienAnt);\n"
"\t<a cbot|move>move</a>(distance(position, item.position));"
msgstr ""

#. type: Plain text
#: ../E/dist.txt:12
#, no-wrap
msgid "This is of course pure suicide. Better to stop 40 meters before, in order to be at shooting range:"
msgstr ""

#. type: Source code
#: ../E/dist.txt:14
#, no-wrap
msgid ""
"\titem = radar(AlienAnt);\n"
"\tmove(distance(position, item.position) - 40);"
msgstr ""

#. type: \b; header, \t; header
#: ../E/build.txt:11 ../E/buildingenabled.txt:12 ../E/canbuild.txt:12 ../E/detect.txt:4 ../E/dist.txt:17 ../E/drop.txt:11 ../E/errmode.txt:4 ../E/file.txt:10 ../E/fire.txt:9 ../E/float.txt:19 ../E/goto.txt:11 ../E/grab.txt:11 ../E/if.txt:22 ../E/int.txt:13 ../E/motor.txt:14 ../E/move.txt:7 ../E/radar.txt:13 ../E/radarall.txt:11 ../E/return.txt:9 ../E/switch.txt:46 ../E/turn.txt:18 ../E/wait.txt:9 ../E/while.txt:19
#, no-wrap
msgid "For specialists"
msgstr ""

#. type: Plain text, \t; header
#: ../E/abstime.txt:2 ../E/acos.txt:2 ../E/aim.txt:2 ../E/asin.txt:2 ../E/atan.txt:2 ../E/atan2.txt:2 ../E/build.txt:12 ../E/buildingenabled.txt:13 ../E/canbuild.txt:13 ../E/canresearch.txt:2 ../E/ceil.txt:2 ../E/cos.txt:2 ../E/deflag.txt:2 ../E/deletef.txt:6 ../E/delinfo.txt:2 ../E/destroy.txt:2 ../E/detect.txt:5 ../E/dist.txt:18 ../E/dist2d.txt:2 ../E/do.txt:2 ../E/drop.txt:12 ../E/errmode.txt:5 ../E/factory.txt:2 ../E/fire.txt:10 ../E/flag.txt:2 ../E/flatgrnd.txt:2 ../E/flatspace.txt:2 ../E/floor.txt:2 ../E/for.txt:2 ../E/goto.txt:12 ../E/grab.txt:12 ../E/if.txt:23 ../E/isbusy.txt:2 ../E/jet.txt:2 ../E/message.txt:2 ../E/move.txt:8 ../E/pencolor.txt:2 ../E/pendown.txt:2 ../E/penup.txt:2 ../E/penwidth.txt:2 ../E/pow.txt:2 ../E/produce.txt:2 ../E/radar.txt:14 ../E/radarall.txt:12 ../E/rand.txt:2 ../E/readln.txt:8 ../E/receive.txt:2 ../E/recycle.txt:2 ../E/research.txt:2 ../E/researched.txt:2 ../E/retobj.txt:2 ../E/round.txt:2 ../E/search.txt:2 ../E/send.txt:2 ../E/shield.txt:2 ../E/sin.txt:2 ../E/sniff.txt:2 ../E/space.txt:2 ../E/sqrt.txt:2 ../E/strfind.txt:4 ../E/strleft.txt:4 ../E/strlen.txt:4 ../E/strlower.txt:4 ../E/strmid.txt:4 ../E/strright.txt:4 ../E/strupper.txt:4 ../E/strval.txt:8 ../E/switch.txt:47 ../E/takeoff.txt:2 ../E/tan.txt:2 ../E/testinfo.txt:2 ../E/thump.txt:2 ../E/topo.txt:2 ../E/trunc.txt:2 ../E/turn.txt:19 ../E/wait.txt:10 ../E/writeln.txt:8
#, no-wrap
msgid "Syntax:"
msgstr ""

#. type: Source code
#: ../E/dist.txt:19
#, no-wrap
msgid "<c/>distance ( pos1, pos2 );<n/>"
msgstr ""

#. type: Plain text
#: ../E/dist.txt:21
#, no-wrap
msgid "Calculates the distance between two positions. "
msgstr ""

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

#. type: Plain text
#: ../E/dist.txt:24 ../E/dist2d.txt:8
#, no-wrap
msgid "Coordinates of the two positions. "
msgstr ""

#. type: Plain text
#: ../E/dist.txt:27 ../E/dist2d.txt:11
#, no-wrap
msgid "Distance between the two positions."
msgstr ""

#. type: \b; header
#: ../E/dist2d.txt:1
#, no-wrap
msgid "Instruction <code>distance2d</code>"
msgstr ""

#. type: Source code
#: ../E/dist2d.txt:3
#, no-wrap
msgid "<c/>distance2d ( pos1, pos2 );<n/>"
msgstr ""

#. type: Plain text
#: ../E/dist2d.txt:5
#, no-wrap
msgid "Calculates the distance between two positions (ignores the z coordinate)."
msgstr ""

#. type: \b; header
#: ../E/do.txt:1
#, no-wrap
msgid "Instruction <code>do - while</code>"
msgstr ""

#. type: Source code
#: ../E/do.txt:3
#, no-wrap
msgid ""
"<code>do\n"
"{\n"
"\t</code>Instructions ...<c/>\n"
"}\n"
"while ( condition );"
msgstr ""

#. type: Plain text
#: ../E/do.txt:9
#, no-wrap
msgid ""
"This instruction allows you to perform several times the instructions inside the <a cbot|bloc>block</a>. The instructions are executed at least once, because the condition is tested only afterwards.\n"
"Be careful not to confuse the instruction <c/>do { } while ( );<n/> with the instruction <code><a cbot|while>while</a> ( ) { }</code>; the latter tests the condition before the instructions in the block are executed. "
msgstr ""

#. type: \t; header
#: ../E/do.txt:12 ../E/for.txt:13 ../E/while.txt:30
#, no-wrap
msgid "<code>condition</code>"
msgstr ""

#. type: Plain text
#: ../E/do.txt:13 ../E/while.txt:31
#, no-wrap
msgid "The instructions in the block are performed over and over again, as long as the <a cbot|cond>condition</a> is true. "
msgstr ""

#. type: Plain text
#: ../E/do.txt:15 ../E/while.txt:33
#, no-wrap
msgid "Here is an example :"
msgstr ""

#. type: Source code
#: ../E/do.txt:16
#, no-wrap
msgid ""
"<c/>do\n"
"{\n"
"\tp = radar(TitaniumOre);\n"
"}\n"
"while ( p == null );"
msgstr ""

#. type: \t; header
#: ../E/do.txt:22 ../E/float.txt:11 ../E/for.txt:33 ../E/if.txt:36 ../E/int.txt:10 ../E/switch.txt:67 ../E/while.txt:41
#, no-wrap
msgid "Attention"
msgstr ""

#. type: Plain text
#: ../E/do.txt:23
#, no-wrap
msgid "Always put a <a cbot|term>semicolon</a> at the end of the line <code>while ( )</code>."
msgstr ""

#. type: Plain text
#: ../E/do.txt:25
#, no-wrap
msgid "The instructions <code><a cbot|break>break</a></code> and <code><a cbot|continue>continue</a></code> can be useful inside a block following the instruction <code>do { }</code>."
msgstr ""

#. type: \b; header
#: ../E/drop.txt:1
#, no-wrap
msgid "Instruction <code>drop</code>"
msgstr ""

#. type: Plain text
#: ../E/drop.txt:2
#, no-wrap
msgid "The instruction <c/>drop();<n/> instructs the bot to drop whatever the operating arm is carrying on the ground, on the platform of a building or on the power cell location of a bot."
msgstr ""

#. type: Plain text
#: ../E/drop.txt:5
#, no-wrap
msgid "The instruction <c/>drop();<n/> written in this form drops the object in front of the bot. Here is a short program that grabs an object in front of the bot and drops it 5 meters further:"
msgstr ""

#. type: Source code
#: ../E/drop.txt:7
#, no-wrap
msgid ""
"\t<a cbot|grab>grab</a>();\n"
"\t<a cbot|move>move</a>(5);\n"
"\tdrop();"
msgstr ""

#. type: Source code
#: ../E/drop.txt:13
#, no-wrap
msgid "<c/>drop ( oper );<n/>"
msgstr ""

#. type: Plain text
#: ../E/drop.txt:15
#, no-wrap
msgid "This instruction appeals to the operating arm of a <a object|botgr>grabber bot</a>, in order to drop what it is holding."
msgstr ""

#. type: \t; header
#: ../E/drop.txt:17 ../E/grab.txt:17
#, no-wrap
msgid "oper: <code><a cbot|int>int</a></code> (default value<code>InFront</code>)"
msgstr ""

#. type: Plain text
#: ../E/drop.txt:18
#, no-wrap
msgid ""
"Oper indicates where the robot should drop the object. If no indication is given, the object is dropped in front of the bot. \n"
"<code>InFront   </code>  Drops in front (default value).\n"
"<code>Behind    </code>  Drops behind.\n"
"<code>EnergyCell</code>  Drops on the bot's own power cell location."
msgstr ""

#. type: Plain text
#: ../E/drop.txt:24
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <c/>drop();<n/>.\n"
"<code>== 0 </code>object was dropped\n"
"<code>!= 0 </code>error, no object was dropped"
msgstr ""

#. type: \b; header
#: ../E/eof.txt:1
#, no-wrap
msgid "Instruction <code>eof</code>"
msgstr ""

#. type: Plain text
#: ../E/eof.txt:2
#, no-wrap
msgid "Test the end of file condition of an open file. This is a method of the <code><a cbot|file>file</a></code> class; therefore you cannot write  <code>eof()</code> but only <code>handle.eof()</code>:"
msgstr ""

#. type: Source code
#: ../E/eof.txt:4
#, no-wrap
msgid "\tif ( handle.eof() )  "
msgstr ""

#. type: Plain text
#: ../E/eof.txt:6 ../E/readln.txt:11
#, no-wrap
msgid "Example:"
msgstr ""

#. type: Source code
#: ../E/eof.txt:8
#, no-wrap
msgid ""
"\twhile ( not handle.eof() )\n"
"\t{\n"
"\t\ts = handle.readln();\n"
"\t}"
msgstr ""

#. type: Plain text
#: ../E/eof.txt:14
#, no-wrap
msgid ""
"<code><a cbot|file>file</a></code>, <code><a cbot|open>open</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|readln>readln</a></code> and <code><a cbot|writeln>writeln</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/errmode.txt:1
#, no-wrap
msgid "Instruction <code>errmode</code>"
msgstr ""

#. type: Plain text
#: ../E/errmode.txt:2
#, no-wrap
msgid "The <c/>errmode();<n/> instruction allows you to chose if the program should stop when an error occurs in one of the following instructions: <code><a cbot|goto>goto</a></code>, <code><a cbot|move>move</a></code>, <code><a cbot|grab>grab</a></code>, <code><a cbot|drop>drop</a></code>, etc."
msgstr ""

#. type: Source code
#: ../E/errmode.txt:6
#, no-wrap
msgid "<c/>errmode ( mode );<n/>"
msgstr ""

#. type: Plain text
#: ../E/errmode.txt:8
#, no-wrap
msgid "Normally the program is stopped when an error occurs. If you use the instruction <c/>errmode(0);<n/> at the beginning of the program, the instructions listed above return a value different from zero if the instruction could not be performed."
msgstr ""

#. type: \t; header
#: ../E/errmode.txt:10
#, no-wrap
msgid "mode: <code><a cbot|float>float</a></code> (<code>1</code> per default)"
msgstr ""

#. type: Plain text
#: ../E/errmode.txt:11
#, no-wrap
msgid ""
"Error treatment mode.\n"
"<code>0</code> -> continues program execution and returns a non zero value\n"
"<code>1</code> -> stops the program (default behavior)"
msgstr ""

#. type: Plain text
#: ../E/errmode.txt:15
#, no-wrap
msgid "Example 1:"
msgstr ""

#. type: Source code
#: ../E/errmode.txt:16
#, no-wrap
msgid ""
"<c/>errmode(0);\n"
"while ( goto(pos) != 0 )\n"
"{\n"
"\twait(2);\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/errmode.txt:22
#, no-wrap
msgid "Example 2:"
msgstr ""

#. type: Source code
#: ../E/errmode.txt:23
#, no-wrap
msgid ""
"<c/>errmode(0);\n"
"int err;\n"
"err = goto(pos);\n"
"if ( err != 0 )\n"
"{\n"
"\t<n/>goto did not perform correctly ...<code>\n"
"\t</code>take some appropriate action ...<c/>\n"
"}"
msgstr ""

#. type: \b; header
#: ../E/expr.txt:1
#, no-wrap
msgid "Expressions"
msgstr ""

#. type: Plain text
#: ../E/expr.txt:87
#, no-wrap
msgid "is equivalent to"
msgstr ""

#. type: Plain text
#: ../E/expr.txt:179
#, 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: \b; header
#: ../E/extern.txt:1
#, no-wrap
msgid "Instruction <code>extern</code>"
msgstr ""

#. type: Plain text
#: ../E/extern.txt:2
#, no-wrap
msgid "The <code>extern</code> instruction  determines the <a cbot|function>function</a> that acts as main program of a robot. The name of the function declared with <code>extern</code> will apear in the program list in the lower left corner of the screen."
msgstr ""

#. type: Source code
#: ../E/extern.txt:4
#, no-wrap
msgid ""
"extern void object::MowDown( )\n"
"{\n"
"\twhile ( true )\n"
"\t{\n"
"\t\tfire(1);\n"
"\t\tturn(10);\n"
"\t}\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/extern.txt:13
#, no-wrap
msgid "If the program contains other functions, only the main function must be preceded by <code>extern</code>."
msgstr ""

#. type: Source code
#: ../E/extern.txt:15
#, no-wrap
msgid ""
"extern void object::Square( )\n"
"{\n"
"\tfor ( int i=0 ; i<4 ; i++ )\n"
"\t{\n"
"\t\tLine(10);\n"
"\t}\n"
"}\n"
"\n"
"void object::Line(float dist)\n"
"{\n"
"\tmove(dist);\n"
"\tturn(90);\n"
"}"
msgstr ""

#. type: \b; header
#: ../E/false.txt:1
#, no-wrap
msgid "Type <code>false</code>"
msgstr ""

#. type: Plain text
#: ../E/false.txt:2
#, no-wrap
msgid "This value means that a condition is not true; it is one of the two values that a <a cbot|bool>boolean</a> <a cbot|var>variable</a> can take."
msgstr ""

#. type: \b; header
#: ../E/file.txt:1
#, no-wrap
msgid "Type <code>file</code>"
msgstr ""

#. type: Plain text
#: ../E/file.txt:2
#, no-wrap
msgid "This type is used for accessing files in the files/ folder."
msgstr ""

#. type: Source code
#: ../E/file.txt:4
#, no-wrap
msgid "\tfile handle();"
msgstr ""

#. type: Plain text
#: ../E/file.txt:6
#, no-wrap
msgid "Use the syntax above for declaring a file handle. You must use () to create an instance of the <code>file</code> class. Without the () the handle would have the value <code><a cbot|null>null</a></code>."
msgstr ""

#. type: Plain text
#: ../E/file.txt:8
#, no-wrap
msgid "Files can only be created and opened in the files/ folder which is located in the folder inside Colobot save directory. You cannot not create or open files elsewhere than in the files/ folder."
msgstr ""

#. type: Plain text
#: ../E/file.txt:11
#, no-wrap
msgid "<code>file</code> is actually not a simple type but a class. <code>open</code>, <code>close</code>, <code>writeln</code> etc. are methods of the <code>file</code> class. This is the reason why we always write <code>handle.method()</code>:"
msgstr ""

#. type: Source code
#: ../E/file.txt:13
#, no-wrap
msgid ""
"\thandle.open(\"test.txt\", \"w\");\n"
"\thandle.close();"
msgstr ""

#. type: Plain text
#: ../E/file.txt:17
#, no-wrap
msgid ""
"<code><a cbot|open>open</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|readln>readln</a></code>, <code><a cbot|writeln>writeln</a></code> and <code><a cbot|eof>eof</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/fire.txt:1
#, no-wrap
msgid "Instruction <code>fire</code>"
msgstr ""

#. type: Plain text
#: ../E/fire.txt:2
#, no-wrap
msgid "The instruction <c/>fire();<n/> fires the bot's onboard cannon."
msgstr ""

#. type: Plain text
#: ../E/fire.txt:5
#, no-wrap
msgid "Generally this instruction is used to shoot one-second bursts:"
msgstr ""

#. type: Source code
#: ../E/fire.txt:7
#, no-wrap
msgid "\tfire(1);"
msgstr ""

#. type: Source code
#: ../E/fire.txt:11
#, no-wrap
msgid "<c/>fire ( time );<n/>"
msgstr ""

#. type: Plain text
#: ../E/fire.txt:20
#, no-wrap
msgid "In order to move the gun upward or downward, use the instruction <code><a cbot|aim>aim</a></code>."
msgstr ""

#. type: \t; header
#: ../E/fire.txt:22 ../E/wait.txt:15
#, no-wrap
msgid "time: <code><a cbot|float>float</a></code>"
msgstr ""

#. type: Plain text
#: ../E/fire.txt:23
#, no-wrap
msgid "Duration of the burst. Generally, the value given is 1. Shorter bursts can also be performed in order to spare time and energy."
msgstr ""

#. type: Plain text
#: ../E/fire.txt:26
#, no-wrap
msgid ""
"Zero if OK, or a value different from zero if an error occurred.\n"
"<code>== 0 </code>the cannon has been fired\n"
"<code>!= 0 </code>error, the cannon could not be fired"
msgstr ""

#. type: \b; header
#: ../E/flatgrnd.txt:1
#, no-wrap
msgid "Instruction <code>flatground</code>"
msgstr ""

#. type: Source code
#: ../E/flatgrnd.txt:3
#, no-wrap
msgid "<c/>flatground ( center, rmax );<n/>"
msgstr ""

#. type: Plain text
#: ../E/flatgrnd.txt:5
#, no-wrap
msgid "Calculates the maximal radius of a flat zone on which a building ca be built."
msgstr ""

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

#. type: Plain text
#: ../E/flatgrnd.txt:8
#, no-wrap
msgid "Center of the circlular zone."
msgstr ""

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

#. type: Plain text
#: ../E/flatgrnd.txt:11
#, no-wrap
msgid "Maximal radius."
msgstr ""

#. type: Plain text
#: ../E/flatgrnd.txt:14
#, no-wrap
msgid "Radius of the flat zone (always between 0 and rmax)."
msgstr ""

#. type: \b; header
#: ../E/float.txt:1
#, no-wrap
msgid "Type <code>float</code>"
msgstr ""

#. type: Plain text
#: ../E/float.txt:2
#, no-wrap
msgid "Use this type for most variables that contains numbers. Variables of this type can contain positive and negative numbers, whole or real numbers, for example: "
msgstr ""

#. type: Source code
#: ../E/float.txt:4
#, no-wrap
msgid ""
"\t12.9\n"
"\t1.125\n"
"\t0.002\n"
"\t-4.1"
msgstr ""

#. type: Plain text
#: ../E/float.txt:9
#, no-wrap
msgid "If you need only whole numbers (f. ex. 12 or -5000), you should rather use the type <code><a cbot|int>int</a></code>."
msgstr ""

#. type: Plain text
#: ../E/float.txt:12
#, no-wrap
msgid "Do not insert space or colon characters into a number. To separate the whole part from the fractional part, use a dot. "
msgstr ""

#. type: Source code
#: ../E/float.txt:14
#, no-wrap
msgid ""
"   Write       and not\n"
"   12.56       12 . 56\n"
"  -54.34       -54,34\n"
"12895.69    12,895.69"
msgstr ""

#. type: Plain text
#: ../E/float.txt:20
#, no-wrap
msgid ""
"Floating point numbers are represented in Colobot with 32 bits.\n"
"The highest value that can be represented is 3.4E+38.\n"
"The smallest value that can be represented is 3.4E-38."
msgstr ""

#. type: \b; header
#: ../E/for.txt:1
#, no-wrap
msgid "Instruction <code>for</code>"
msgstr ""

#. type: Source code
#: ../E/for.txt:3
#, no-wrap
msgid ""
"<c/>for ( before ; condition ; end )\n"
"{\n"
"\t<n/>Instructions ...<c/>\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/for.txt:8
#, no-wrap
msgid "This instruction allows you to execute a certain number of times the instructions contained in the <a cbot|bloc>block</a>."
msgstr ""

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

#. type: Plain text
#: ../E/for.txt:14
#, no-wrap
msgid "This <a cbot|cond>condition</a> determines if another instance of the loop must be executed. It is tested before every instance of the loop. "
msgstr ""

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

#. type: Source code
#: ../E/for.txt:21
#, no-wrap
msgid ""
"{\n"
"\tmessage(i) ;\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/for.txt:25
#, no-wrap
msgid "The following example is strictly equivalent to a <code>for</code>-loop, but it uses the instruction <code><a cbot|while>while</a></code>:"
msgstr ""

#. type: Source code
#: ../E/for.txt:26
#, no-wrap
msgid ""
"<c/>before;\n"
"while ( condition )\n"
"{\n"
"\t<n/>Instructions ...<c/>\n"
"\tend;\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/for.txt:34
#, no-wrap
msgid "Do not put a <a cbot|term>semicolon</a> at the end of the line <code>for ( )</code>."
msgstr ""

#. type: Plain text
#: ../E/for.txt:36
#, no-wrap
msgid "The instructions <code><a cbot|break>break</a></code> and <code><a cbot|continue>continue</a></code> can be useful inside a block following the instruction <code>for </code>."
msgstr ""

#. type: \b; header
#: ../E/function.txt:1
#, no-wrap
msgid "Functions"
msgstr ""

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

#. type: \b; header
#: ../E/goto.txt:1
#, no-wrap
msgid "Instruction <code>goto</code>"
msgstr ""

#. type: Plain text
#: ../E/goto.txt:2
#, no-wrap
msgid "The instruction <c/>goto();<n/> instructs the bot to reach a given position."
msgstr ""

#. type: Plain text
#: ../E/goto.txt:5
#, no-wrap
msgid "The most current use consists in moving the bot to an object located with the instruction <c/><a cbot|radar>radar</a>();<n/>. If the information returned by the <c/><a cbot|radar>radar</a>();<n/> has been stored in a certain variable, write the name of the variable followed by <code>.position</code> in order to get the position of the object. Here is an example of a program that looks for a <a object|titan>titanium cube</a>, goes to the position and grabs it:"
msgstr ""

#. type: Source code
#: ../E/goto.txt:7
#, no-wrap
msgid ""
"\titem = <a cbot|radar>radar</a>(Titanium);\n"
"\tgoto(item.position);\n"
"\t<a cbot|grab>grab</a>();"
msgstr ""

#. type: Source code
#: ../E/goto.txt:13
#, no-wrap
msgid "<c/>goto ( position, altitude, goal, crash );<n/>"
msgstr ""

#. type: Plain text
#: ../E/goto.txt:15
#, no-wrap
msgid "Tells the robot to go to the given position, avoiding all the obstacles if this is possible. "
msgstr ""

#. type: Plain text
#: ../E/goto.txt:18
#, no-wrap
msgid "Coordinates of the goal position."
msgstr ""

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

#. type: Plain text
#: ../E/goto.txt:21
#, no-wrap
msgid "Flight altitude for <a object|botgj>winged bots</a>. The altitude is useful only for <a object|botgj>winged bots</a>. From the initial altitude, the bot climbs higher until it reaches the specified hight. When arriving close to destination, it goes down to touch the ground at the given position. If no value is given, an altitude of 10 meters is the default value. On very short moves, even winged bot stay on the ground. For all bot except winged bots, this parameter is ignored. "
msgstr ""

#. type: \t; header
#: ../E/goto.txt:23
#, no-wrap
msgid "goal: <code><a cbot|int>int</a></code> (default value <code>0</code>)"
msgstr ""

#. type: Plain text
#: ../E/goto.txt:24
#, no-wrap
msgid ""
"This parameter tells the bot how it must reach the goal: \n"
"<code>0</code>  stops exactly at the goal position\n"
"<code>1</code>  goes close to the goal position, without stopping.\n"
"If no value is given, <code>0</code> (precision) is the default value."
msgstr ""

#. type: Plain text
#: ../E/goto.txt:30
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <code>goto()</code>.\n"
"<code>== 0 </code>Goal position reached\n"
"<code>!= 0 </code>Goal position impossible to reach"
msgstr ""

#. type: \b; header
#: ../E/grab.txt:1
#, no-wrap
msgid "Instruction <code>grab</code>"
msgstr ""

#. type: Plain text
#: ../E/grab.txt:2
#, no-wrap
msgid "The instruction <c/>grab();<n/> instructs the bot to use the operating arm to grab an object located on the ground, on the platform of a building or on the power cell location of a bot."
msgstr ""

#. type: Plain text
#: ../E/grab.txt:5
#, no-wrap
msgid "The instruction <c/>grab();<n/> written in this form grabs the object located in front of the bot. Here is a short program that grabs an object in front of the bot and drops it 5 meters further:"
msgstr ""

#. type: Source code
#: ../E/grab.txt:7
#, no-wrap
msgid ""
"\tgrab();\n"
"\t<a cbot|move>move</a>(5);\n"
"\t<a cbot|drop>drop</a>();"
msgstr ""

#. type: Source code
#: ../E/grab.txt:13
#, no-wrap
msgid "<c/>grab ( oper );<n/>"
msgstr ""

#. type: Plain text
#: ../E/grab.txt:15
#, no-wrap
msgid "This instruction appeals to the operating arm of a <a object|botgr>grabber bot</a>, in order to grab the closest object."
msgstr ""

#. type: Plain text
#: ../E/grab.txt:18
#, no-wrap
msgid ""
"Oper indicates where the bot should look for an object to grab. If no indication is given, the object is picked up in front of the bot.\n"
"<code>InFront   </code>  Grabs in front (default value).\n"
"<code>Behind    </code>  Grabs behind.\n"
"<code>EnergyCell</code>  Grabs the bot's own power cell."
msgstr ""

#. type: Plain text
#: ../E/grab.txt:24
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <c/>grab();<n/>.\n"
"<code>== 0 </code>an object was grabbed\n"
"<code>!= 0 </code>error, no object was grabbed"
msgstr ""

#. type: \b; header
#: ../E/if.txt:1
#, no-wrap
msgid "Instructions <code>if</code> and <code>else</code>"
msgstr ""

#. type: Plain text
#: ../E/if.txt:2
#, no-wrap
msgid "With the instruction <code>if() {}</code> you can execute a set of instructions only if a certain condition is true. Write the condition in brackets <code>()</code>, and the instructions in braces <code>{}</code>."
msgstr ""

#. type: Plain text
#: ../E/if.txt:5
#, no-wrap
msgid "Here is a concrete example: The bot will shoot only if the target is closer than 40 meters:"
msgstr ""

#. type: Source code
#: ../E/if.txt:7
#, no-wrap
msgid ""
"\titem = <a cbot|radar>radar</a>(AlienAnt);\n"
"\tif (<a cbot|dist>distance</a>(position, item.position) < 40)\n"
"\t{\n"
"\t\tfire(1);\n"
"\t}"
msgstr ""

#. type: Plain text
#: ../E/if.txt:13
#, no-wrap
msgid "You can also test if an object exists at all. If the instruction <c/><a cbot|radar>radar</a>();<n/> does not find the requested object, it returns the value <code>null</code>. So you can test if an object does not exists with the condition  <code>(item == null)</code>, or test if it exists with  <code>(item != null)</code>. Two equal signs <code>==</code> test equality, an exclamation mark followed by an equal sign <code>!=</code> test inequality. Here is a test that will go to rechage the <a object|power>power cell</a> only if there is a <a object|station>power station</a>:"
msgstr ""

#. type: Source code
#: ../E/if.txt:15
#, no-wrap
msgid ""
"\titem = <a cbot|radar>radar</a>(PowerStation);\n"
"\tif (item != null)\n"
"\t{\n"
"\t\t<a cbot|goto>goto</a>(item.position);\n"
"\t\t<a cbot|wait>wait</a>(5);\n"
"\t}"
msgstr ""

#. type: Source code
#: ../E/if.txt:24
#, no-wrap
msgid ""
"<code>if ( condition )\n"
"{\n"
"\t</code>Instructions A ...<code>\n"
"}\n"
"else\n"
"{\n"
"\t</code>Instructions B ...<c/>\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/if.txt:33
#, no-wrap
msgid ""
"With this conditional structure you can execute a <a cbot|bloc>bloc</a> A or a <a cbot|bloc>bloc</a> B depending on a <a cbot|cond>condition</a>. If the condition is true, bloc A is executed. If the condition is false, bloc B is executed. \n"
"Part <code>else { }</code> is not compulsory. "
msgstr ""

#. type: Plain text
#: ../E/if.txt:37
#, no-wrap
msgid "Do not put a <a cbot|term>semicolon</a> at the end of the line <code>if ( )</code>."
msgstr ""

#. type: \b; header
#: ../E/int.txt:1
#, no-wrap
msgid "Type <code>int</code>"
msgstr ""

#. type: Plain text
#: ../E/int.txt:2
#, no-wrap
msgid "Use this type for variables that contain only whole numbers, negative or positive. For example: "
msgstr ""

#. type: Source code
#: ../E/int.txt:4
#, no-wrap
msgid ""
"\t12\n"
"\t1000\n"
"\t-4"
msgstr ""

#. type: Plain text
#: ../E/int.txt:8
#, no-wrap
msgid "To represent real numbers like 12.05 or -0.005, use the type <code><a cbot|float>float</a></code>."
msgstr ""

#. type: Plain text
#: ../E/int.txt:11
#, no-wrap
msgid "Do not put space or colon signs inside a number. "
msgstr ""

#. type: Plain text
#: ../E/int.txt:14
#, no-wrap
msgid ""
"Numbers of the type <code>int</code> are represented with 32 bits.\n"
"The highest number that can be represented is (2^31)-1, that is 2'147'483'647.\n"
"The smallest number that can be represented is -(2^31), that is -2'147'483'648."
msgstr ""

#. type: \b; header
#: ../E/jet.txt:1
#, no-wrap
msgid "Instruction <code>jet</code>"
msgstr ""

#. type: Source code
#: ../E/jet.txt:3
#, no-wrap
msgid "<c/>jet ( power );<n/>"
msgstr ""

#. type: Plain text
#: ../E/jet.txt:5
#, no-wrap
msgid "Direct control of the jet of a <a object|botgj>winged bot</a>. The jet is what makes the bot fly. Use this instruction in order to take off, climb, descend or land."
msgstr ""

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

#. type: Plain text
#: ../E/jet.txt:8
#, no-wrap
msgid "Power of the jet, ranges between <code>-1</code> and <code>+1</code>. <c/>jet(1);<n/> instructs the bot to climb as fast as possible, <c/>jet(-1);<n/> descends as fast as possible, <c/>jet(0);<n/> stabilizes the altitude. In order to get slower altitude changes, use intermediate values, for example <c/>jet(0.3);<n/>."
msgstr ""

#. type: \t; header
#: ../E/jet.txt:11 ../E/message.txt:21 ../E/motor.txt:35 ../E/shield.txt:15 ../E/wait.txt:18
#, no-wrap
msgid "Return value: <code><a cbot|void>void</a></code>"
msgstr ""

#. type: Plain text
#: ../E/jet.txt:12 ../E/message.txt:22 ../E/motor.txt:36 ../E/shield.txt:16 ../E/wait.txt:19
#, no-wrap
msgid "None."
msgstr ""

#. type: \b; header
#: ../E/message.txt:1
#, no-wrap
msgid "Instruction <code>message</code>"
msgstr ""

#. type: Source code
#: ../E/message.txt:3
#, no-wrap
msgid "<c/>message ( text, type );<n/>"
msgstr ""

#. type: Plain text
#: ../E/message.txt:5
#, no-wrap
msgid "Prints a message on top of the screen. After a few seconds, the message disappears automatically. "
msgstr ""

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

#. type: Plain text
#: ../E/message.txt:8
#, no-wrap
msgid ""
"Text that is to be displayed. It is possible to append several texts and/or values with the operator <code>+</code>:\n"
"<c/>message(\"Not found\");<n/> \n"
"<c/>message(angle);<n/> \n"
"<c/>message(n + \" object(s) found\");<n/> \n"
"<c/>message(\"Distance = \" + dist + \" meters\");<n/> "
msgstr ""

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

#. type: Bullet: 'o'
#: ../E/message.txt:16
#, no-wrap
msgid "<code>DisplayMessage</code>  Standard message on yellow background."
msgstr ""

#. type: Bullet: 'o'
#: ../E/message.txt:17
#, no-wrap
msgid "<code>DisplayInfo   </code>  Information on green background."
msgstr ""

#. type: Bullet: 'o'
#: ../E/message.txt:18
#, no-wrap
msgid "<code>DisplayWarning</code>  Warning on blue background."
msgstr ""

#. type: Bullet: 'o'
#: ../E/message.txt:19
#, no-wrap
msgid "<code>DisplayError  </code>  Error on red background."
msgstr ""

#. type: \b; header
#: ../E/motor.txt:1
#, no-wrap
msgid "Instruction <code>motor</code>"
msgstr ""

#. type: Plain text
#: ../E/motor.txt:2
#, no-wrap
msgid "The instruction <c/>motor( , );<n/> sets the speed for the left-hand and the right-hand motor of the bot."
msgstr ""

#. type: Plain text
#: ../E/motor.txt:5
#, no-wrap
msgid "The speed given to the motors will remain constant during the execution of the following instructions. Thanks to this characteristic it is possible to perform a rotation during the instruction <c/><a cbot|fire>fire</a>();<n/>. This will sweep a whole zone with only one burst. Here is an example that will sweep the zone in front of the bot:"
msgstr ""

#. type: Source code
#: ../E/motor.txt:7
#, no-wrap
msgid ""
"\t<a cbot|turn>turn</a>(45);         // turns 45 degrees left\n"
"\tmotor(0.5, -0.5); // slow rotation to the right\n"
"\t<a cbot|fire>fire</a>(2);          // fire\n"
"\tmotor(0,0);       // stops the rotation"
msgstr ""

#. type: Plain text
#: ../E/motor.txt:12
#, no-wrap
msgid "With the left-hand motor turning half-speed forward and the right-hand motor turning half-speed backward, the bot will turn slowly on itself during the 2-second-burst."
msgstr ""

#. type: Source code
#: ../E/motor.txt:16
#, no-wrap
msgid "<c/>motor ( left, right );<n/>"
msgstr ""

#. type: Plain text
#: ../E/motor.txt:18
#, no-wrap
msgid "Gives speed instructions to the right and left motors of the robot. The motors will keep this speed until a new motor instruction is performed, or until a <code><a cbot|move>move</a></code>, <code><a cbot|turn>turn</a></code> or <code><a cbot|goto>goto</a></code> instruction is performed."
msgstr ""

#. type: \t; header
#: ../E/motor.txt:20
#, no-wrap
msgid "left: <code><a cbot|float>float</a></code>"
msgstr ""

#. type: Plain text
#: ../E/motor.txt:21
#, no-wrap
msgid "Speed instruction for the left motor; the value must range between -1 and 1. "
msgstr ""

#. type: \t; header
#: ../E/motor.txt:23
#, no-wrap
msgid "right: <code><a cbot|float>float</a></code>"
msgstr ""

#. type: Plain text
#: ../E/motor.txt:24
#, no-wrap
msgid "Speed instruction for the right motor; the value must range between -1 and 1. "
msgstr ""

#. type: Plain text
#: ../E/motor.txt:26
#, no-wrap
msgid ""
"Examples :\n"
"<c/>motor(1, 1);<n/> moves forward with highest possible speed.\n"
"<c/>motor(-0.5, -0.5);<n/> moves backward with half speed.\n"
"<c/>motor(1, -1);<n/> turns right as fast as possible. "
msgstr ""

#. type: Plain text
#: ../E/motor.txt:31
#, no-wrap
msgid ""
"Note :\n"
"<c/>motor(2, 2);<n/> will not move forward any faster than <code>motor(1, 1)</code> \n"
"<c/>motor(-2, -2);<n/> will not move backward any faster than <code>motor(-1, -1)</code>"
msgstr ""

#. type: \b; header
#: ../E/move.txt:1
#, no-wrap
msgid "Instruction <code>move</code>"
msgstr ""

#. type: Plain text
#: ../E/move.txt:2
#, no-wrap
msgid "The instruction <c/>move();<n/> instructs the bot to move forward or backward while keeping the same orientation. In brackets you must specify the length of the move in meters."
msgstr ""

#. type: Plain text
#: ../E/move.txt:5
#, no-wrap
msgid "If you want the bot to move forward 30 meters, write <c/>move(30);<n/>. In order to move the bot backward after it dropped a chunk of <a object|titanore>titanium ore</a> on the <a object|convert>converter</a>, write <c/>move(-2.5);<n/>."
msgstr ""

#. type: Source code
#: ../E/move.txt:9
#, no-wrap
msgid "<c/>move ( length );<n/>"
msgstr ""

#. type: Plain text
#: ../E/move.txt:11
#, no-wrap
msgid "Moves forward or backward of a given distance, always keeping the current orientation of the bot. "
msgstr ""

#. type: \t; header
#: ../E/move.txt:13
#, no-wrap
msgid "length: <code><a cbot|float>float</a></code>"
msgstr ""

#. type: Plain text
#: ../E/move.txt:14
#, no-wrap
msgid "Length of the move, in meters. A negative value makes the bot move backward. "
msgstr ""

#. type: Plain text
#: ../E/move.txt:17
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <code>move()</code>.\n"
"<code>== 0 </code>Move executed\n"
"<code>!= 0 </code>error, the instruction was not performed correctly"
msgstr ""

#. type: \b; header
#: ../E/nan.txt:1
#, no-wrap
msgid "Type <code>nan</code>"
msgstr ""

#. type: Plain text
#: ../E/nan.txt:2
#, no-wrap
msgid ""
"This special value indicates that a <a cbot|var>variable</a> of type <code><a cbot|int>int</a></code> or <code><a cbot|float>float</a></code> contains no number, but \"nothing\". \n"
"For example, if the instruction <code><a cbot|receive>receive</a></code> can not get the requested information, it returns <code>nan</code> :"
msgstr ""

#. type: Source code
#: ../E/nan.txt:5
#, no-wrap
msgid ""
"\tvalue = receive(\"Length\");\n"
"\tif ( value == nan )  // not found ?\n"
"\t{\n"
"\t\t\n"
"\t}"
msgstr ""

#. type: \t; header
#: ../E/nan.txt:11
#, no-wrap
msgid "Dictionnary"
msgstr ""

#. type: Plain text
#: ../E/nan.txt:12
#, no-wrap
msgid "<code>nan</code> = Not A Number "
msgstr ""

#. type: \b; header
#: ../E/new.txt:1
#, no-wrap
msgid "Instruction <code>new</code> (for specialists)"
msgstr ""

#. type: Plain text
#: ../E/new.txt:2
#, no-wrap
msgid ""
"The <code>new</code> operator creates a <a cbot|class>class</a> instance:\n"
"<c/><s/>\tMyClass item;    // now item is a null reference"
msgstr ""

#. type: Source code
#: ../E/new.txt:4
#, no-wrap
msgid ""
"\titem = new MyClass(); // now item is a reference\n"
"\t                      // to a new class instance"
msgstr ""

#. type: Plain text
#: ../E/new.txt:7
#, no-wrap
msgid "If you want to create a new instance at declaration time you can ommit the new <code>new</code> operator by putting () after the declaration:"
msgstr ""

#. type: Plain text
#: ../E/new.txt:9
#, no-wrap
msgid ""
"Instead of:\n"
"<c/><s/>\tMyClass item = new MyClass();\n"
"<n/>you can write:\n"
"<c/><s/>\tMyClass item();"
msgstr ""

#. type: Plain text
#: ../E/new.txt:14
#, no-wrap
msgid ""
"If your class has a constructor with parameters you can write:\n"
"<c/><s/>\tMyClass item = new MyClass(2, 3);\n"
"<n/>or:\n"
"<c/><s/>\tMyClass item(2, 3);"
msgstr ""

#. type: Plain text
#: ../E/new.txt:21
#, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>, <code><a cbot|pointer>reference</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/null.txt:1
#, no-wrap
msgid "Type <code>null</code>"
msgstr ""

#. type: Plain text
#: ../E/null.txt:2
#, no-wrap
msgid "This special value indicates that the variable containing it does not reference an instance."
msgstr ""

#. type: Plain text
#: ../E/null.txt:5
#, no-wrap
msgid ""
"<a cbot|pointer>References</a>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/object.txt:1
#, no-wrap
msgid "Type <code>object</code>"
msgstr ""

#. type: Source code
#: ../E/object.txt:22
#, no-wrap
msgid "<code>category</code>"
msgstr ""

#. type: Source code
#: ../E/object.txt:25
#, no-wrap
msgid "<code>position</code>"
msgstr ""

#. type: Plain text
#: ../E/object.txt:26
#, 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 ""

#. type: Source code
#: ../E/object.txt:28
#, no-wrap
msgid "<code>orientation</code>"
msgstr ""

#. type: Plain text
#: ../E/object.txt:29
#, 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 ""

#. type: Source code
#: ../E/object.txt:31
#, no-wrap
msgid "<code>pitch</code>"
msgstr ""

#. type: Plain text
#: ../E/object.txt:32
#, 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 ""

#. type: Source code
#: ../E/object.txt:34
#, no-wrap
msgid "<code>roll</code>"
msgstr ""

#. type: Plain text
#: ../E/object.txt:35
#, 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: Source code
#: ../E/object.txt:37
#, no-wrap
msgid "<code>energyLevel</code>"
msgstr ""

#. type: Plain text
#: ../E/object.txt:38
#, 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 ""

#. type: Source code
#: ../E/object.txt:40
#, no-wrap
msgid "<code>shieldLevel</code>"
msgstr ""

#. type: Plain text
#: ../E/object.txt:41
#, 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 ""

#. type: Source code
#: ../E/object.txt:44
#, no-wrap
msgid "<code>temperature</code>"
msgstr ""

#. type: Plain text
#: ../E/object.txt:45
#, 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 ""

#. type: Source code
#: ../E/object.txt:47
#, no-wrap
msgid "<code>altitude</code>"
msgstr ""

#. type: Plain text
#: ../E/object.txt:48
#, 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 ""

#. type: Source code
#: ../E/object.txt:50
#, no-wrap
msgid "<code>lifeTime</code>"
msgstr ""

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

#. type: Source code
#: ../E/object.txt:53
#, no-wrap
msgid "<code>energyCell</code>"
msgstr ""

#. type: Plain text
#: ../E/object.txt:54
#, 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 ""

#. type: Source code
#: ../E/object.txt:58
#, no-wrap
msgid "<code>load</code>"
msgstr ""

#. type: Plain text
#: ../E/object.txt:59
#, 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 ""

#. type: \t; header, \b; header
#: ../E/expr.txt:100 ../E/expr.txt:124 ../E/expr.txt:146 ../E/expr.txt:171 ../E/expr.txt:188 ../E/factory.txt:21 ../E/object.txt:70
#, no-wrap
msgid "Examples"
msgstr ""

#. type: Plain text
#: ../E/object.txt:71
#, 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 ""

#. type: Source code
#: ../E/object.txt:73
#, 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 ""

#. type: \b; header
#: ../E/open.txt:1
#, no-wrap
msgid "Instruction <code>open</code>"
msgstr ""

#. type: Plain text
#: ../E/open.txt:2
#, no-wrap
msgid "Open a text file in the files/ folder. This is a method of the <code><a cbot|file>file</a></code> class. This is the reason why we always write <code>handle.open()</code>:"
msgstr ""

#. type: Source code
#: ../E/open.txt:4
#, no-wrap
msgid "\thandle.open(\"test.txt\", \"w\");"
msgstr ""

#. type: Plain text
#: ../E/open.txt:6
#, no-wrap
msgid "To open a file, proceed as follows:"
msgstr ""

#. type: Source code
#: ../E/open.txt:8
#, no-wrap
msgid ""
"\tfile handle();\n"
"\thandle.open(\"filename\", \"w\");\n"
"\thandle.writeln(\"abc\");\n"
"\thandle.close();"
msgstr ""

#. type: Plain text
#: ../E/open.txt:17
#, no-wrap
msgid "Files can only be created and opened in the files/ folder which is located in the folder inside Colobot save directory. You cannot not create or open files that are located elsewhere than in the files/ folder."
msgstr ""

#. type: Plain text
#: ../E/open.txt:20
#, no-wrap
msgid ""
"<code><a cbot|file>file</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|readln>readln</a></code>, <code><a cbot|writeln>writeln</a></code> and <code><a cbot|eof>eof</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/openfile.txt:1
#, no-wrap
msgid "Instruction <code>openfile</code>"
msgstr ""

#. type: Source code
#: ../E/openfile.txt:4
#, no-wrap
msgid "file handle = openfile(\"filename\", \"r\");"
msgstr ""

#. type: \b; header
#: ../E/point.txt:1
#, no-wrap
msgid "Type <code>point</code>"
msgstr ""

#. type: Plain text
#: ../E/point.txt:2
#, no-wrap
msgid ""
"Variables of this type contain the coordinates of a point in space. This type is made of three values that represent the <code>x</code>, <code>y</code> and <code>z</code> coordinates.\n"
"<code>x</code> and <code>y</code> correspond to the place on the ground. The positive <code>x</code> axis faces towards east, the positive <code>y</code> axis faces towards north. \n"
"The <code>z</code> value corresponds to the altitude above sea level. "
msgstr ""

#. type: Plain text
#: ../E/point.txt:6
#, no-wrap
msgid "If you want to declare a variable of type point, you can write: "
msgstr ""

#. type: Source code
#: ../E/point.txt:8
#, no-wrap
msgid "\tpoint a (10, 20, 30);"
msgstr ""

#. type: Plain text
#: ../E/point.txt:10
#, no-wrap
msgid "You can also set the variable taking one value after another:"
msgstr ""

#. type: Source code
#: ../E/point.txt:12
#, no-wrap
msgid ""
"\tpoint b;\n"
"\tb.x = 10;\n"
"\tb.y = 20;\n"
"\tb.z = 30;"
msgstr ""

#. type: Plain text
#: ../E/point.txt:17
#, no-wrap
msgid "With these examples, the following <a cbot|cond>condition</a> is true:"
msgstr ""

#. type: Source code
#: ../E/point.txt:19
#, no-wrap
msgid ""
"\tif ( a == b )\n"
"\t{\n"
"\t}"
msgstr ""

#. type: Plain text
#: ../E/point.txt:22
#, no-wrap
msgid ""
"<n/> \n"
"The following declaration :"
msgstr ""

#. type: Source code
#: ../E/point.txt:25
#, no-wrap
msgid "\tpoint c (4, 7);"
msgstr ""

#. type: Plain text
#: ../E/point.txt:27
#, no-wrap
msgid "Is equivalent to :"
msgstr ""

#. type: Source code
#: ../E/point.txt:29
#, no-wrap
msgid ""
"\tpoint c;\n"
"\tc.x = 4;\n"
"\tc.y = 7;\n"
"\tc.z = 0;"
msgstr ""

#. type: \b; header
#: ../E/pointer.txt:1
#, no-wrap
msgid "References (for specialists)"
msgstr ""

#. type: Plain text
#: ../E/pointer.txt:2
#, no-wrap
msgid "CBOT uses references for <a cbot|class>classes</a> and <a cbot|array>arrays</a>. Any class variable actually contains a reference to the instance. The instance actually contains the class fields. Several references can reference the same instance. A <code><a cbot|null>null</a></code> reference references nothing. You can compare an instance to a suitcase and a reference to a carrier. Each time we need a new suitcase we create a new instance with a carrier. But a suitcase can be carried by more than one carrier. A carrier who carries no suitcase is a <code><a cbot|null>null</a></code> reference."
msgstr ""

#. type: Plain text
#: ../E/pointer.txt:4
#, no-wrap
msgid ""
"Example:\n"
"<c/><s/>{"
msgstr ""

#. type: Source code
#: ../E/pointer.txt:6
#, no-wrap
msgid ""
"\tMyClass item1(); // create a new instance\n"
"\t                 // referenced by item1\n"
"\tMyClass item2;   // create a null reference\n"
"\titem2 = item1;   // copy the reference,\n"
"\t                 // item2 and item1 now reference\n"
"\t                 // the same instance\n"
"\titem1.a = 12;    // modifies the instance\n"
"\t                 // referenced by item1 (and item2)\n"
"\tmessage(item2.a);// displays 12\n"
"}"
msgstr ""

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

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

#. type: Source code
#: ../E/pointer.txt:20
#, no-wrap
msgid ""
"{\n"
"\titem.a = 12;          // modify the original instance\n"
"\titem = new MyClass(); // new local instance\n"
"\titem.a = 33;          // modifie the local instance\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/pointer.txt:26
#, no-wrap
msgid ""
"Calling the fucntion <code>Test()</code>:\n"
"<c/><s/>{"
msgstr ""

#. type: Source code
#: ../E/pointer.txt:28
#, no-wrap
msgid ""
"\tMyClass toto();\n"
"\tTest(toto);\n"
"\tmessage(toto.a);  // displays 12\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/pointer.txt:33
#, no-wrap
msgid "The instance containing the field <code>a = 33</code> is referenced only by the newly created instance <code>item</code> inside the fucntion <code>Test</code>. At the end of <code>Test</code> this newly created instance referenced by <code>item</code> is automatically deleted."
msgstr ""

#. type: Plain text
#: ../E/pointer.txt:35
#, no-wrap
msgid ""
"A function can return an instance:\n"
"<c/><s/>MyClass Test2( )"
msgstr ""

#. type: Plain text
#: ../E/pointer.txt:43
#, no-wrap
msgid ""
"Call the function like this:\n"
"<c/><s/>{"
msgstr ""

#. type: Source code
#: ../E/pointer.txt:45
#, no-wrap
msgid ""
"\tMyClass toto;\n"
"\ttoto = Test2(); // toto will contain a reference to\n"
"\t                // the instance created by Test2()\n"
"\tmessage(toto.a); // displays 33\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/pointer.txt:52
#, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>, <code><a cbot|new>new</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/private.txt:1
#, no-wrap
msgid "Instruction <code>private</code> (for specialists)"
msgstr ""

#. type: Source code
#: ../E/private.txt:6
#, no-wrap
msgid ""
"public class MyClass\n"
"{\n"
"\tint    b;                // public by default\n"
"\tpublic int a;            // also public \n"
"\tprivate point position;  // private\n"
"}\n"
"void Test()\n"
"{\n"
"\tMyClass item;\n"
"\titem.a = item.b = 12;      // ok\n"
"\tmessage( item.position );  // this is an error\n"
"}"
msgstr ""

#. type: \b; header
#: ../E/public.txt:1
#, no-wrap
msgid "Instruction <code>public</code> (for specialists)"
msgstr ""

#. type: Plain text
#: ../E/public.txt:2
#, no-wrap
msgid "This instruction has two distinct purposes:"
msgstr ""

#. type: Bullet: '1)'
#: ../E/public.txt:4
#, no-wrap
msgid "Make a function available to other bots."
msgstr ""

#. type: Bullet: '2)'
#: ../E/public.txt:5
#, no-wrap
msgid "Make a class member accessible from outside the class definition."
msgstr ""

#. type: \b; header
#: ../E/public.txt:7
#, no-wrap
msgid "Instruction <code>public</code> for functions"
msgstr ""

#. type: Plain text
#: ../E/public.txt:8
#, no-wrap
msgid "If you put <code>public</code> before a <a cbot|function>function</a> definition, you can make the function available to programs in other bots in the same mission."
msgstr ""

#. type: Plain text
#: ../E/public.txt:10
#, no-wrap
msgid "For example in the first bot we would have:"
msgstr ""

#. type: Source code
#: ../E/public.txt:12
#, no-wrap
msgid ""
"public void object::Segment(float dist, float angle)\n"
"{\n"
"\tmove(dist);\n"
"\tturn(angle);\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/public.txt:18
#, no-wrap
msgid "And in another bot we would have:"
msgstr ""

#. type: Source code
#: ../E/public.txt:20
#, no-wrap
msgid ""
"extern void object::Square( )\n"
"{\n"
"\tfor ( int i=0 ; i<4 ; i++ )\n"
"\t{\n"
"\t\tSegment(10, 90);\n"
"\t\tfire(1);\n"
"\t}\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/public.txt:29
#, no-wrap
msgid "If you have declared a function <code>public</code>, you cannot define a function with the same name and arguments in another bot of the same mission."
msgstr ""

#. type: Plain text
#: ../E/public.txt:31
#, no-wrap
msgid "If a bot containing a <code>public</code> function is destroyed, the other bots that make use of this function will be stopped with an error."
msgstr ""

#. type: \b; header
#: ../E/public.txt:33
#, no-wrap
msgid "Instruction <code>public</code> for classes"
msgstr ""

#. type: Source code
#: ../E/public.txt:36
#, no-wrap
msgid ""
"public class MyClass\n"
"{\n"
"\tint    b;                // public by default\n"
"\tpublic int a;            // also public \n"
"\tprivate point position;  // privat\n"
"}\n"
"void Test()\n"
"{\n"
"\tMyClass item;\n"
"\titem.a = item.b = 12;      // ok\n"
"\tmessage( item.position );  // this is an error\n"
"}"
msgstr ""

#. type: \b; header
#: ../E/radar.txt:1
#, no-wrap
msgid "Instruction <code>radar</code>"
msgstr ""

#. type: Plain text
#: ../E/radar.txt:5
#, no-wrap
msgid "Write in brackets the <a cbot|category>name of the object</a> that you look for. Put the result in a variable of the <a cbot|type>type</a> <code>object</code>. Here is an example that looks for the closest ant:"
msgstr ""

#. type: Source code
#: ../E/radar.txt:7
#, no-wrap
msgid ""
"// At the beginning of the program:\n"
"object  item; // variable declaration\n"
"\n"
"// Look for the closest ant\n"
"item = radar(AlienAnt);"
msgstr ""

#. type: Plain text
#: ../E/radar.txt:17
#, no-wrap
msgid "Detects an object according to several parameters. "
msgstr ""

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

#. type: Plain text
#: ../E/radar.txt:20
#, no-wrap
msgid "Seen from above, the purple zone corresponds to the zone where objects will be detected. "
msgstr ""

#. type: \t; header
#: ../E/produce.txt:15 ../E/search.txt:7
#, no-wrap
msgid "category: <code><a cbot|int>int</a></code>"
msgstr ""

#. type: Plain text
#: ../E/radar.txt:34
#, no-wrap
msgid ""
"Direction that the radar is facing, in degrees. \n"
"<code>  0</code> -> radar is facing straight ahead\n"
"<code>-90</code> -> radar is facing a quarter turn right\n"
"<code> 90</code> -> radar is facing a quarter turn left"
msgstr ""

#. type: Plain text
#: ../E/radar.txt:40
#, no-wrap
msgid "Opening angle of the radar, in degrees. "
msgstr ""

#. type: Plain text
#: ../E/radar.txt:43
#, no-wrap
msgid "Minimum detection distance, in meters. Objects that are closer than the minimum distance will not be detected. "
msgstr ""

#. type: Plain text
#: ../E/radar.txt:46
#, no-wrap
msgid "Maximum detection distance, in meters. Objects that are farther away than the maximum distance will not be detected. "
msgstr ""

#. type: Plain text
#: ../E/radar.txt:49
#, no-wrap
msgid "Determines which way the objects are detected. With value <code>1</code>, returns the closest object found in the specified zone. With value <code>-1</code>, the farthest object in the zone will be returned. "
msgstr ""

#. type: \t; header
#: ../E/radar.txt:65 ../E/retobj.txt:10 ../E/search.txt:22
#, no-wrap
msgid "Return value: <code><a cbot|object>object</a></code>"
msgstr ""

#. type: Plain text
#: ../E/radar.txt:66
#, no-wrap
msgid "Returns the first object found that corresponds to the specified category in the specified zone. If no object was found, returns the value <code><a cbot|null>null</a></code>."
msgstr ""

#. type: \t; header
#: ../E/expr.txt:132 ../E/radar.txt:68
#, no-wrap
msgid "Remark"
msgstr ""

#. type: Plain text
#: ../E/radar.txt:69
#, no-wrap
msgid "You do not have to give all the parameters. Here are two examples of instructions that are equivalent: "
msgstr ""

#. type: Source code
#: ../E/radar.txt:71
#, no-wrap
msgid ""
"\tradar(Titanium, 0, 360, 0, 1000);\n"
"\tradar(Titanium);  // equivalent"
msgstr ""

#. type: Source code
#: ../E/radar.txt:74
#, no-wrap
msgid ""
"\tradar(Titanium, 0, 90, 0, 1000);\n"
"\tradar(Titanium, 0, 90);  // equivalent"
msgstr ""

#. type: Plain text
#: ../E/radar.txt:77
#, no-wrap
msgid ""
"When one or more parameters are not specified, the default values indicated above are used instead; only the first parameter is compulsory.\n"
"Generally, only the first parameter is specified: f. ex. <code>radar (AlienAnt)</code> detects the closest ant, wherever it may be. "
msgstr ""

#. type: \b; header
#: ../E/readln.txt:1
#, no-wrap
msgid "Instruction <code>readln</code>"
msgstr ""

#. type: Plain text
#: ../E/readln.txt:2
#, no-wrap
msgid "Read one line from an open file in the files/ folder. This is a method of the <code><a cbot|file>file</a></code> class. This is the reason why we always write <code>handle.readln()</code>:"
msgstr ""

#. type: Source code
#: ../E/readln.txt:4
#, no-wrap
msgid "\ts = handle.readln();"
msgstr ""

#. type: Plain text
#: ../E/readln.txt:6
#, no-wrap
msgid "The file must have been opened for reading (<code>\"r\"</code>) with the <code><a cbot|open>open</a></code> instruction. <code>readln</code> returns the string containing the whole line but without the end of line characters 0x0D (CR) and 0x0A (LF)."
msgstr ""

#. type: Source code
#: ../E/readln.txt:9
#, no-wrap
msgid "<c/>string = handle.readln ( );<n/>"
msgstr ""

#. type: Source code
#: ../E/readln.txt:13
#, no-wrap
msgid ""
"\tstring s;\n"
"\ts = handle.readln();\n"
"\tif ( s == \"abc\" )\n"
"\t..."
msgstr ""

#. type: Plain text
#: ../E/readln.txt:19
#, no-wrap
msgid ""
"<code><a cbot|file>file</a></code>, <code><a cbot|open>open</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|writeln>writeln</a></code> and <code><a cbot|eof>eof</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/receive.txt:1
#, no-wrap
msgid "Instruction <code>receive</code>"
msgstr ""

#. type: Source code
#: ../E/receive.txt:3
#, no-wrap
msgid "<c/>receive ( name, power );<n/>"
msgstr ""

#. type: Plain text
#: ../E/receive.txt:5
#, no-wrap
msgid "Retrieves an information from the closest <a object|exchange>information exchange post</a>."
msgstr ""

#. type: Plain text
#: ../E/receive.txt:8
#, no-wrap
msgid "Name of the information required from the exchange post. This name is a string: it must be written in quotation marks \"\"."
msgstr ""

#. type: Plain text
#: ../E/receive.txt:11
#, no-wrap
msgid "Power of the receiver, which corresponds to maximal distance between the receiver and the exchange post. If the distance is longer, no information is received. Default value is 10 metres."
msgstr ""

#. type: Plain text
#: ../E/receive.txt:14
#, no-wrap
msgid "Value of the retrieved information. If no exchange post is close enough, or if the name of the requested information does not exist in the exchange post, the value <code>nan</code> is returned."
msgstr ""

#. type: Plain text
#: ../E/receive.txt:17
#, no-wrap
msgid ""
"<code><a cbot|send>send</a></code>, <code><a cbot|testinfo>testinfo</a></code> and <code><a cbot|delinfo>deleteinfo</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/recycle.txt:1
#, no-wrap
msgid "Instruction <code>recycle</code>"
msgstr ""

#. type: Source code
#: ../E/recycle.txt:3
#, no-wrap
msgid "<c/>recycle ( );<n/>"
msgstr ""

#. type: Plain text
#: ../E/recycle.txt:5
#, no-wrap
msgid "Recycles the derelict bot in front of the <a object|botrecy>recycler</a> into a <a object|titan>titanium cube</a>."
msgstr ""

#. type: Plain text
#: ../E/recycle.txt:8
#, no-wrap
msgid ""
"Zero if OK, or a value different from zero if an error occurred.\n"
"<code>== 0 </code>the derelict bot has been recycled\n"
"<code>!= 0 </code>error, no derelict bot could be recycled"
msgstr ""

#. type: \b; header
#: ../E/retobj.txt:1
#, no-wrap
msgid "Instruction <code>retobject</code>"
msgstr ""

#. type: Source code
#: ../E/retobj.txt:3
#, no-wrap
msgid "<c/>retobject ( number );<n/>"
msgstr ""

#. type: Plain text
#: ../E/retobj.txt:5
#, no-wrap
msgid "Returns the object corresponding to the given number."
msgstr ""

#. type: \t; header
#: ../E/retobj.txt:7
#, no-wrap
msgid "number: <code><a cbot|int>int</a></code>"
msgstr ""

#. type: Plain text
#: ../E/retobj.txt:8
#, no-wrap
msgid "Number of the object, between 0 and n. \"n\" represents the total number of objects in the scene. "
msgstr ""

#. type: Plain text
#: ../E/retobj.txt:11
#, no-wrap
msgid "Object corresponding to the number. The return value <code><a cbot|null>null</a></code> means that no object corresponds to this number, because the number was too high, and there are not so many objects in the scene. "
msgstr ""

#. type: \b; header
#: ../E/return.txt:1
#, no-wrap
msgid "Instruction <code>return</code>"
msgstr ""

#. type: Plain text
#: ../E/return.txt:2
#, no-wrap
msgid "Returns from a function. Syntax:"
msgstr ""

#. type: Source code
#: ../E/return.txt:4
#, no-wrap
msgid ""
"void function ( )\n"
"{\n"
"\treturn;\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/return.txt:10
#, no-wrap
msgid "If the <a cbot|function>function</a> has a return type, the <code>return</code> instruction must be followed by the value to be returned:"
msgstr ""

#. type: Source code
#: ../E/return.txt:12
#, no-wrap
msgid ""
"float Pi ( )\n"
"{\n"
"\treturn 3.1415;\n"
"}"
msgstr ""

#. type: Source code
#: ../E/return.txt:17
#, no-wrap
msgid ""
"float Mean (float a, float b)\n"
"{\n"
"\treturn (a+b)/2;\n"
"}"
msgstr ""

#. type: Source code
#: ../E/return.txt:22
#, no-wrap
msgid ""
"string Sign (float a)\n"
"{\n"
"\tif ( a > 0 )  return \"positive\";\n"
"\tif ( a < 0 )  return \"negative\";\n"
"\treturn \"null\";\n"
"}"
msgstr ""

#. type: \b; header
#: ../E/search.txt:1
#, no-wrap
msgid "Instruction <code>search</code>"
msgstr ""

#. type: Source code
#: ../E/search.txt:3
#, no-wrap
msgid "<c/>search ( category, position );<n/>"
msgstr ""

#. type: \t; header
#: ../E/produce.txt:9 ../E/topo.txt:7
#, no-wrap
msgid "position: <code><a cbot|point>point</a></code>"
msgstr ""

#. type: Plain text
#: ../E/search.txt:20
#, no-wrap
msgid "<code>search</code> returns the object of the given category that is closest to the position indicated here. "
msgstr ""

#. type: Plain text
#: ../E/search.txt:23
#, no-wrap
msgid "Characteristics of the object that has been found. The value <code><a cbot|null>null</a></code> means that no object of this category has been found. "
msgstr ""

#. type: \b; header
#: ../E/send.txt:1
#, no-wrap
msgid "Instruction <code>send</code>"
msgstr ""

#. type: Source code
#: ../E/send.txt:3
#, no-wrap
msgid "<c/>send ( name, value, power );<n/>"
msgstr ""

#. type: Plain text
#: ../E/send.txt:5
#, no-wrap
msgid "Sends an information to the closest <a object|exchange>information exchange post</a>."
msgstr ""

#. type: Plain text
#: ../E/send.txt:8
#, no-wrap
msgid ""
"Name of the information to be sent to the exchange post. This name is a string: it must be written in quotation marks \"\".\n"
"If there is any information having this name, a new entry is created, as far as the total number of entries does not exceed 10. If there is already an information having this name, value is simply replaced by the new."
msgstr ""

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

#. type: Plain text
#: ../E/send.txt:12
#, no-wrap
msgid "Value of the information to be sent."
msgstr ""

#. type: Plain text
#: ../E/send.txt:15
#, no-wrap
msgid "Power of the transmitter, which corresponds to the maximal distance to where information can be the sent. Default value is 10 metres."
msgstr ""

#. type: Plain text
#: ../E/send.txt:18
#, no-wrap
msgid ""
"<code><a cbot|receive>receive</a></code>, <code><a cbot|testinfo>testinfo</a></code> and <code><a cbot|delinfo>deleteinfo</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/shield.txt:1
#, no-wrap
msgid "Instruction <code>shield</code>"
msgstr ""

#. type: Source code
#: ../E/shield.txt:3
#, no-wrap
msgid "<c/>shield ( oper, radius );<n/>"
msgstr ""

#. type: Plain text
#: ../E/shield.txt:5
#, no-wrap
msgid "Activates or deactivates the shield of the <a object|botshld>shielder</a>. You can of course move the shielder when the shield is active. It protects all objects that are inside the shielded sphere from enemy fire. The radius of the sphere can range between 10 and 25 meters."
msgstr ""

#. type: \t; header
#: ../E/shield.txt:7
#, no-wrap
msgid "oper: <code><a cbot|float>float</a></code>"
msgstr ""

#. type: Plain text
#: ../E/shield.txt:8
#, no-wrap
msgid ""
"<code>1</code> activates the shield.\n"
"<code>0</code> deactivates the shield\n"
"A normal <a object|power>power cell</a> fully charged can maintain the shield active during 20 seconds. When the cell is empty, the shield deactivates."
msgstr ""

#. type: \t; header
#: ../E/shield.txt:12
#, no-wrap
msgid "radius: <code><a cbot|float>float</a></code>"
msgstr ""

#. type: Plain text
#: ../E/shield.txt:13
#, no-wrap
msgid "Radius of the shield, ranging between 10 and 25 meters."
msgstr ""

#. type: \b; header
#: ../E/sizeof.txt:1
#, no-wrap
msgid "Instruction <code>sizeof</code>"
msgstr ""

#. type: Plain text
#: ../E/sizeof.txt:2
#, no-wrap
msgid ""
"The sizeof function lets you know the number of elements contained in an <a cbot|array>array</a>.\n"
"That is the index of the last element plus one (\"empty\" elements are counted)."
msgstr ""

#. type: Source code
#: ../E/sizeof.txt:5
#, no-wrap
msgid ""
"{\n"
"\tint a[12];\n"
"\ta[5] = 345;\n"
"\tmessage( sizeof(a) );  // will display 6\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/sizeof.txt:11
#, no-wrap
msgid "In this example we have 6 elements in the array after <code>a[5]=345</code>. The non initialized elements <code>[0]</code>, <code>[1]</code>, <code>[2]</code>, <code>[3]</code> and <code>[4]</code> will be counted."
msgstr ""

#. type: Plain text
#: ../E/sizeof.txt:13
#, no-wrap
msgid "With multidimensionnal arrays you can get the size of a sub array:"
msgstr ""

#. type: Source code
#: ../E/sizeof.txt:15
#, no-wrap
msgid ""
"float xy[][];  // 2 dimensionnal array\n"
"xy[5][10] = 67;\n"
"message( sizeof(xy)    );  // will display 6\n"
"message( sizeof(xy[5]) );  // will display 11\n"
msgstr ""

#. type: \b; header
#: ../E/sniff.txt:1
#, no-wrap
msgid "Instruction <code>sniff</code>"
msgstr ""

#. type: Source code
#: ../E/sniff.txt:3
#, no-wrap
msgid "<c/>sniff ( );<n/>"
msgstr ""

#. type: Plain text
#: ../E/sniff.txt:5
#, no-wrap
msgid "Sounds the underground in front of the <a object|botsr>sniffer</a>. According to what raw materials were detected, the following objects will be created: "
msgstr ""

#. type: Plain text
#: ../E/sniff.txt:7
#, no-wrap
msgid ""
"<code>TitaniumSpot</code>  ->  <a object|stonspot>Red cross</a>\n"
"<code>UraniumSpot </code>  ->  <a object|uranspot>Yellow circle</a>\n"
"<code>PowerSpot   </code>  ->  <a object|enerspot>Green cross</a>"
msgstr ""

#. type: Plain text
#: ../E/sniff.txt:12
#, no-wrap
msgid ""
"Zero if everything is OK, or a value different from zero if an error occurred. \n"
"<code>== 0 </code>sounding performed\n"
"<code>!= 0 </code>sounding impossible"
msgstr ""

#. type: \b; header
#: ../E/space.txt:1
#, no-wrap
msgid "Instruction <code>space</code>"
msgstr ""

#. type: Source code
#: ../E/space.txt:3
#, no-wrap
msgid "<c/>space ( center, rmin, rmax, dist );<n/>"
msgstr ""

#. type: Plain text
#: ../E/space.txt:5
#, no-wrap
msgid "Determines the position of the nearest free space around a given position."
msgstr ""

#. type: \t; header
#: ../E/space.txt:7
#, no-wrap
msgid "center: <code><a cbot|point>point</a></code> (default: bot position)"
msgstr ""

#. type: Plain text
#: ../E/flatspace.txt:8 ../E/space.txt:8
#, no-wrap
msgid "Desired position of the free space."
msgstr ""

#. type: \t; header
#: ../E/flatspace.txt:13 ../E/space.txt:10
#, no-wrap
msgid "rmin: <code><a cbot|float>float</a></code> (default value: <code>8</code>)"
msgstr ""

#. type: Plain text
#: ../E/flatspace.txt:14 ../E/space.txt:11
#, no-wrap
msgid "Minimum distance from the desired position."
msgstr ""

#. type: \t; header
#: ../E/flatspace.txt:16 ../E/space.txt:13
#, no-wrap
msgid "rmax: <code><a cbot|float>float</a></code> (default value: <code>50</code>)"
msgstr ""

#. type: Plain text
#: ../E/flatspace.txt:17 ../E/space.txt:14
#, no-wrap
msgid "Maximum distance from the desired position."
msgstr ""

#. type: \t; header
#: ../E/flatspace.txt:19 ../E/space.txt:16
#, no-wrap
msgid "dist: <code><a cbot|float>float</a></code> (default value: <code>4</code>)"
msgstr ""

#. type: Plain text
#: ../E/flatspace.txt:20 ../E/space.txt:17
#, no-wrap
msgid "Required distance between two free spaces."
msgstr ""

#. type: \t; header
#: ../E/flatspace.txt:22 ../E/space.txt:19
#, no-wrap
msgid "Return: <code><a cbot|point>point</a></code>"
msgstr ""

#. type: Plain text
#: ../E/flatspace.txt:23 ../E/space.txt:20
#, no-wrap
msgid "Position of the free space."
msgstr ""

#. type: \b; header
#: ../E/static.txt:1
#, no-wrap
msgid "Instruction <code>static</code> (for specialists)"
msgstr ""

#. type: Plain text
#: ../E/static.txt:2
#, no-wrap
msgid "<a cbot|class>Class</a> members declared with <code>static</code> are shared between all instances of the class."
msgstr ""

#. type: Source code
#: ../E/static.txt:4
#, no-wrap
msgid ""
"public class MyClass\n"
"{\n"
"\tstatic int nb = 1;\n"
"\tstatic string [ ] list = null;\n"
"}\n"
"void Test ()\n"
"{\n"
"\tMyClasse item1();\n"
"\tMyClasse item2();\n"
"\titem1.nb = 3;\n"
"\titem1.list[item1.nb] = \"Hello\";\n"
"\tmessage( item2.list[item2.nb] ); // display \"Hello\"\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/static.txt:18
#, no-wrap
msgid "<code>Static</code> members can be declared <code><a cbot|private>private</a></code> so they will be only acessible from within class members (including constructors and destructors)."
msgstr ""

#. type: Plain text
#: ../E/static.txt:21
#, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>, <code><a cbot|synchro>synchronized</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/strfind.txt:1
#, no-wrap
msgid "Instruction <code>strfind</code>"
msgstr ""

#. type: Plain text
#: ../E/strfind.txt:2
#, no-wrap
msgid "Find a substring in a string and returns the position of the first substring found or <a cbot|nan>nan</a> if the substring has not been found."
msgstr ""

#. type: Source code
#: ../E/strfind.txt:5
#, no-wrap
msgid "<c/>strfind ( string, sub );<n/>"
msgstr ""

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

#. type: Plain text
#: ../E/strfind.txt:8
#, no-wrap
msgid "String we are searching in."
msgstr ""

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

#. type: Plain text
#: ../E/strfind.txt:11
#, no-wrap
msgid "Substring we are searching for."
msgstr ""

#. type: Plain text
#: ../E/array.txt:35 ../E/strfind.txt:13 ../E/strleft.txt:10 ../E/strlen.txt:7 ../E/strlower.txt:7 ../E/strmid.txt:13 ../E/strright.txt:10 ../E/strupper.txt:7 ../E/strval.txt:4 ../E/strval.txt:11 ../E/writeln.txt:11
#, no-wrap
msgid "Examples:"
msgstr ""

#. type: Source code
#: ../E/strfind.txt:14
#, no-wrap
msgid ""
"<c/>\tint pos = strfind(\"abcdef\", \"ab\"); // pos will be 0\n"
"\tint pos = strfind(\"abcdef\", \"de\"); // pos will be 3\n"
"\tint pos = strfind(\"abcdef\", \"xy\"); // pos will be <a cbot|nan>nan</a>"
msgstr ""

#. type: Plain text
#: ../E/strfind.txt:19
#, no-wrap
msgid ""
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/string.txt:1
#, no-wrap
msgid "Type <code>string</code>"
msgstr ""

#. type: Plain text
#: ../E/string.txt:2
#, no-wrap
msgid "Use a variable of this type for storing characters or strings."
msgstr ""

#. type: Plain text
#: ../E/string.txt:4
#, no-wrap
msgid "For example: "
msgstr ""

#. type: Source code
#: ../E/string.txt:5
#, no-wrap
msgid ""
"<c/>\t\"Hello!\"\n"
"\t\"This is a string\"\n"
"\t\"x\"\n"
"\t\"\"  // empty string"
msgstr ""

#. type: Plain text
#: ../E/string.txt:10
#, no-wrap
msgid "You can append two strings with the <code>+</code> operator :"
msgstr ""

#. type: Source code
#: ../E/string.txt:11
#, no-wrap
msgid "<c/>\t\"Good morning,\" + \" \" + \"Sir\""
msgstr ""

#. type: Plain text
#: ../E/string.txt:13
#, no-wrap
msgid "Returns the string:"
msgstr ""

#. type: Source code
#: ../E/string.txt:14
#, no-wrap
msgid "<c/>\t\"Good morning, Sir\""
msgstr ""

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

#. type: Source code
#: ../E/string.txt:17
#, no-wrap
msgid "<c/>\"This is \\\"very\\\" important\""
msgstr ""

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

#. type: Source code
#: ../E/string.txt:19
#, no-wrap
msgid "<c/>\"%user%\\\\ant.txt\""
msgstr ""

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

#. type: Plain text
#: ../E/string.txt:22
#, no-wrap
msgid ""
"Following instructions can be used with strings:\n"
"<code><a cbot|strlen>strlen</a>     </code>Get string length\n"
"<code><a cbot|strleft>strleft</a>    </code>Extract left part\n"
"<code><a cbot|strright>strright</a>   </code>Extract right part\n"
"<code><a cbot|strmid>strmid</a>     </code>Extract center part\n"
"<code><a cbot|strfind>strfind</a>    </code>Find a substring.\n"
"<code><a cbot|strval>strval</a>     </code>Convert string to number\n"
"<code><a cbot|strupper>strupper</a>   </code>Convert to upper case\n"
"<code><a cbot|strlower>strlower</a>   </code>Convert to lower case"
msgstr ""

#. type: \b; header
#: ../E/strleft.txt:1
#, no-wrap
msgid "Instruction <code>strleft</code>"
msgstr ""

#. type: Plain text
#: ../E/strleft.txt:2
#, no-wrap
msgid "Extracts the first (that is, leftmost) characters from a string."
msgstr ""

#. type: Source code
#: ../E/strleft.txt:5
#, no-wrap
msgid "<c/>strleft ( string, len );<n/>"
msgstr ""

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

#. type: Plain text
#: ../E/strleft.txt:8 ../E/strmid.txt:11 ../E/strright.txt:8
#, no-wrap
msgid "Number of characters to be extracted."
msgstr ""

#. type: Source code
#: ../E/strleft.txt:11
#, no-wrap
msgid ""
"<c/>\tstring s = strleft(\"abcdef\", 2);  // s is \"ab\"\n"
"\tstring s = strleft(\"abc\", 10);  // s is \"abc\""
msgstr ""

#. type: Plain text
#: ../E/strleft.txt:15
#, no-wrap
msgid ""
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/strlen.txt:1
#, no-wrap
msgid "Instruction <code>strlen</code>"
msgstr ""

#. type: Plain text
#: ../E/strlen.txt:2
#, no-wrap
msgid "Get the length of a string."
msgstr ""

#. type: Source code
#: ../E/strlen.txt:5
#, no-wrap
msgid "<c/>strlen ( string );<n/>"
msgstr ""

#. type: Source code
#: ../E/strlen.txt:8
#, no-wrap
msgid ""
"<c/>\tint len = strlen(\"abc\");  // len is 3\n"
"\tint len = strlen(\"\");  // len is 0\n"
"\tif ( strlen(s) == 0 )  // is string empty ?"
msgstr ""

#. type: Plain text
#: ../E/strlen.txt:13
#, no-wrap
msgid ""
"<code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/strlower.txt:1
#, no-wrap
msgid "Instruction <code>strlower</code>"
msgstr ""

#. type: Plain text
#: ../E/strlower.txt:2
#, no-wrap
msgid "Convert all characters in a string to lowercase."
msgstr ""

#. type: Source code
#: ../E/strlower.txt:5
#, no-wrap
msgid "<c/>strlower ( string );<n/>"
msgstr ""

#. type: Source code
#: ../E/strlower.txt:8
#, no-wrap
msgid "<c/>\tstring s = strlower(\"Abc\");  // s is \"abc\""
msgstr ""

#. type: Plain text
#: ../E/strlower.txt:11
#, no-wrap
msgid ""
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/strmid.txt:1
#, no-wrap
msgid "Instruction <code>strmid</code>"
msgstr ""

#. type: Plain text
#: ../E/strmid.txt:2
#, no-wrap
msgid "Extracts a substring of a given length starting at a given position from a string."
msgstr ""

#. type: Source code
#: ../E/strmid.txt:5
#, no-wrap
msgid "<c/>strmid ( string, pos, len );<n/>"
msgstr ""

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

#. type: Plain text
#: ../E/strmid.txt:8
#, no-wrap
msgid "The index of the first character that is to be included in the extracted substring."
msgstr ""

#. type: Source code
#: ../E/strmid.txt:14
#, no-wrap
msgid ""
"<c/>\tstring s = strmid(\"abcdef\", 1, 2);  // s is \"bc\"\n"
"\tstring s = strmid(\"abcdef\", 4, 5);  // s is \"ef\"\n"
"\tstring s = strmid(\"abcdef\", 9, 2);  // s is \"\""
msgstr ""

#. type: Plain text
#: ../E/strmid.txt:19
#, no-wrap
msgid ""
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/strright.txt:1
#, no-wrap
msgid "Instruction <code>strright</code>"
msgstr ""

#. type: Plain text
#: ../E/strright.txt:2
#, no-wrap
msgid "Extracts the last (that is, rightmost) characters from a string."
msgstr ""

#. type: Source code
#: ../E/strright.txt:5
#, no-wrap
msgid "<c/>strright ( string, len );<n/>"
msgstr ""

#. type: Source code
#: ../E/strright.txt:11
#, no-wrap
msgid ""
"<c/>\tstring s = strright(\"abcdef\", 2);  // s is \"ef\"\n"
"\tstring s = strright(\"abc\", 10);  // s is \"abc\""
msgstr ""

#. type: Plain text
#: ../E/strright.txt:15
#, no-wrap
msgid ""
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/strupper.txt:1
#, no-wrap
msgid "Instruction <code>strupper</code>"
msgstr ""

#. type: Plain text
#: ../E/strupper.txt:2
#, no-wrap
msgid "Convert all characters in a string to uppercase."
msgstr ""

#. type: Source code
#: ../E/strupper.txt:5
#, no-wrap
msgid "<c/>strupper ( string );<n/>"
msgstr ""

#. type: Source code
#: ../E/strupper.txt:8
#, no-wrap
msgid "<c/>\tstring s = strupper(\"Abc\");  // s is \"ABC\""
msgstr ""

#. type: Plain text
#: ../E/strupper.txt:11
#, no-wrap
msgid ""
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/strval.txt:1
#, no-wrap
msgid "Instruction <code>strval</code>"
msgstr ""

#. type: Plain text
#: ../E/strval.txt:2
#, no-wrap
msgid "Convert a string to a number. Don't confuse the string <code>\"45\"</code> that contains actually the two characters <code>4</code> and <code>5</code> and the number <code>45</code>."
msgstr ""

#. type: Source code
#: ../E/strval.txt:5
#, no-wrap
msgid ""
"<c/>\tstring s = \"45\"+\"12\";  // s contains \"4512\"\n"
"\tfloat  n =  45 + 12;   // n contains 67"
msgstr ""

#. type: Source code
#: ../E/strval.txt:9
#, no-wrap
msgid "<c/>strval ( string );<n/>"
msgstr ""

#. type: Source code
#: ../E/strval.txt:12
#, no-wrap
msgid ""
"<c/>\tfloat n = strval(\"1.23\");     // n is 1.23\n"
"\tfloat n = strval(\"12abc45\");  // n is 12\n"
"\tfloat n = strval(\"abc\");      // n is 0\n"
"\tfloat n = strval(\"100\")+2;    // n is 102"
msgstr ""

#. type: Plain text
#: ../E/strval.txt:18
#, no-wrap
msgid ""
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/synchro.txt:1
#, no-wrap
msgid "Instruction <code>synchronized</code> (for specialists)"
msgstr ""

#. type: Plain text
#: ../E/synchro.txt:2
#, no-wrap
msgid "A <a cbot|class>class</a> method can be declared <code>synchronized</code>. This is to make sure that the method is never being executed by more than one bot at the same time."
msgstr ""

#. type: Plain text
#: ../E/synchro.txt:4
#, no-wrap
msgid "The following example illustrates the problem:"
msgstr ""

#. type: Source code
#: ../E/synchro.txt:6
#, no-wrap
msgid ""
"class blocking\n"
"{\n"
"\tstatic int nb = 33;\n"
"\tsynchronized int inc( )\n"
"\t{\n"
"\t\tint val = nb;\n"
"\t\twait ( 2 );  // wait 2 sec.\n"
"\t\tnb = nb + 1;\n"
"\t\treturn val;\n"
"\t}\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/synchro.txt:18
#, no-wrap
msgid ""
"What happens if two bots execute the <code>inc</code> method at the same time?\n"
"Both of them will execute <code>val=nb</code> and wait 2 seconds so both of them will have <code>val=33</code>. With <code>synchronized</code> the first bot starts execution with <code>val=33</code> and then waits 2 seconds and returns. Only once the first bot has returned from the <code>inc</code> method, the second bot will be allowed to enter the <code>inc</code> method and therefore the second bot will always have <code>val=34</code>."
msgstr ""

#. type: Plain text
#: ../E/synchro.txt:21
#, no-wrap
msgid "You can have more than one synchronized method in your <a cbot|class>class</a> in order to prevent simultaneous execution across more than one method. In other words: as long as a bot's program is inside a synchronized method, no other bot can enter any synchronized method of the same class."
msgstr ""

#. type: Plain text
#: ../E/synchro.txt:24
#, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>, <code><a cbot|static>static</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/term.txt:1
#, no-wrap
msgid "Semicolon"
msgstr ""

#. type: Plain text
#: ../E/term.txt:2
#, no-wrap
msgid "Always use a semicolon <c/>;<n/> after a simple expression. For example: "
msgstr ""

#. type: Source code
#: ../E/term.txt:4
#, no-wrap
msgid "\tint counter = 0;"
msgstr ""

#. type: Plain text
#: ../E/term.txt:6
#, no-wrap
msgid "However, after a <a cbot|bloc>bloc</a>, never put a semicolon:"
msgstr ""

#. type: Source code
#: ../E/term.txt:8
#, no-wrap
msgid ""
"\t{\n"
"\t\tfloat dist;\n"
"\t\tdist = distance(p1, p2);\n"
"\t} <n/>// no semicolon here!<c/>"
msgstr ""

#. type: Plain text
#: ../E/term.txt:13
#, no-wrap
msgid "Do not use a semicolon either immediately after the instructions <code><a cbot|while>while</a></code>, <code><a cbot|if>if</a></code> or <code><a cbot|for>for</a></code>:"
msgstr ""

#. type: Source code
#: ../E/term.txt:15
#, no-wrap
msgid ""
"\tif ( a < b ) <n/>// no semicolon here!<c/>\n"
"\t{\n"
"\t\tb = 100-a;\n"
"\t}"
msgstr ""

#. type: Plain text
#: ../E/term.txt:20
#, no-wrap
msgid "An instruction is always ended by a semicolon, and not by the end of the line. So you can very well put several instructions on the same line: "
msgstr ""

#. type: Source code
#: ../E/term.txt:22
#, no-wrap
msgid ""
"\tint d=20;\n"
"\tmove(d);\n"
"\tturn(90);"
msgstr ""

#. type: Plain text
#: ../E/term.txt:26
#, no-wrap
msgid "Is equivalent to:"
msgstr ""

#. type: Source code
#: ../E/term.txt:28
#, no-wrap
msgid "\tint d=20; move(d); turn(90);"
msgstr ""

#. type: \b; header
#: ../E/testinfo.txt:1
#, no-wrap
msgid "Instruction <code>testinfo</code>"
msgstr ""

#. type: Source code
#: ../E/testinfo.txt:3
#, no-wrap
msgid "<c/>testinfo ( name, power );<n/>"
msgstr ""

#. type: Plain text
#: ../E/testinfo.txt:5
#, no-wrap
msgid "Tests if an information exists in the closest <a object|exchange>information exchange post</a>."
msgstr ""

#. type: Plain text
#: ../E/testinfo.txt:8
#, no-wrap
msgid "Name of the information to be tested in the exchange post. This name is a string: it must be written in quotation marks \"\"."
msgstr ""

#. type: Plain text
#: ../E/testinfo.txt:11
#, no-wrap
msgid "Power of the transmitter, which corresponds to the maximal distance between the transmitter and the exchange post. If the distance is longer, the function returns <code>false</code>. Default value is 10 metres."
msgstr ""

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

#. type: Plain text
#: ../E/testinfo.txt:14
#, no-wrap
msgid "Return <code>true</code> if the information exists. Return and <code>false</code> if the information does not exist or if the receiver is too far away from the exchange post."
msgstr ""

#. type: Plain text
#: ../E/testinfo.txt:17
#, no-wrap
msgid ""
"<code><a cbot|receive>receive</a></code>, <code><a cbot|send>send</a></code> and <code><a cbot|delinfo>deleteinfo</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/this.txt:1
#, no-wrap
msgid "Instruction <code>this</code>"
msgstr ""

#. type: Plain text
#: ../E/this.txt:2
#, no-wrap
msgid "Occasionally, a <a cbot|class>class</a> method needs to know the reference to the instance it is acting upon. For example the instance might want to pass it's own reference to another function. An implicit reference name <code>this</code> is available to methods and <code>this</code> is a reference to the current instance."
msgstr ""

#. type: Source code
#: ../E/this.txt:4
#, no-wrap
msgid ""
"public class MyClass\n"
"{\n"
"\tint    m_int;\n"
"\tstring m_str;\n"
"\tvoid MyFunction()\n"
"\t{\n"
"\t\tOtherFunction(this);\n"
"\t\tm_int = 2;\n"
"\t}\n"
"}\n"
"\n"
"void OtherFunction(MyClass obj)\n"
"{\n"
"\tmessage(obj.m_str);\n"
"}\n"
"\n"
"extern void object::Test()\n"
"{\n"
"\tMyClass item();\n"
"\titem.m_str = \"Hello\";\n"
"\titem.MyFunction();  // display \"Hello\"\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/this.txt:27
#, no-wrap
msgid "You can also put <code>this</code> before a field name in a method but this is not necessary. In the example above in the method <code>MyFunction()</code> following two lines have strictly the same meaning:"
msgstr ""

#. type: Source code
#: ../E/this.txt:29
#, no-wrap
msgid ""
"\tm_int = 2;\n"
"\tthis.m_int = 2;  // identical"
msgstr ""

#. type: Plain text
#: ../E/this.txt:32
#, no-wrap
msgid "In a method of the <code><a cbot|object>object</a></code> class, you can also use <code>this.</code> before a fieldname."
msgstr ""

#. type: Source code
#: ../E/this.txt:34
#, no-wrap
msgid ""
"extern void object::Display()\n"
"{\n"
"\tmessage(orientation);\n"
"\tmessage(this.orientation); // same thing but\n"
"\t                           // more explicit\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/this.txt:41
#, no-wrap
msgid "However if a field name is hidden by a parameter declaration or a variable declaration you must use <code>this</code>. In the following example the name <code>value</code> of the parameter is the same as the name of the field <code>value</code> of the <a cbot|class>class</a> <code>MyClass</code>, we must therefore write <code>this.value</code> in order to distinguish the field from the parameter."
msgstr ""

#. type: Source code
#: ../E/this.txt:43
#, no-wrap
msgid ""
"public class MyClass\n"
"{\n"
"\tint  value;\n"
"\tvoid Put( int value )\n"
"\t{\n"
"\t\tthis.value = value;\n"
"\t}\n"
"}"
msgstr ""

#. type: \b; header
#: ../E/thump.txt:1
#, no-wrap
msgid "Instruction <code>thump</code>"
msgstr ""

#. type: Source code
#: ../E/thump.txt:3
#, no-wrap
msgid "<c/>thump ( );<n/>"
msgstr ""

#. type: Plain text
#: ../E/thump.txt:5
#, no-wrap
msgid "Activates the weapon system of the <a object|bottump>thumper</a>, that turns ants and spiders belly up and makes them completely harmless for a while."
msgstr ""

#. type: Plain text
#: ../E/thump.txt:8
#, no-wrap
msgid ""
"Zero if everything is OK, a value different from zero if an error occurred. \n"
"<code>== 0 </code>Thumping performed\n"
"<code>!= 0 </code>Operation impossible"
msgstr ""

#. type: \b; header
#: ../E/topo.txt:1
#, no-wrap
msgid "Instruction <code>topo</code>"
msgstr ""

#. type: Source code
#: ../E/topo.txt:3
#, no-wrap
msgid "<c/>topo ( position );<n/>"
msgstr ""

#. type: Plain text
#: ../E/topo.txt:5
#, no-wrap
msgid "Returns the altitude of the ground at a give position. The altitude zero corresponds to sea level. A negative value indicates that at this position ground is covered with water. "
msgstr ""

#. type: Plain text
#: ../E/topo.txt:8
#, no-wrap
msgid "Coordinates of the position whose altitude you want to know. "
msgstr ""

#. type: Plain text
#: ../E/topo.txt:11
#, no-wrap
msgid "Altitude of the ground at the given position."
msgstr ""

#. type: \b; header
#: ../E/true.txt:1
#, no-wrap
msgid "Type <code>true</code>"
msgstr ""

#. type: Plain text
#: ../E/true.txt:2
#, no-wrap
msgid "This value means that a condition is true; it is one of the two values that a <a cbot|bool>boolean</a> <a cbot|var>variable</a> can take."
msgstr ""

#. type: \b; header
#: ../E/turn.txt:1
#, no-wrap
msgid "Instruction <code>turn</code>"
msgstr ""

#. type: Plain text
#: ../E/turn.txt:2
#, no-wrap
msgid "Use the instruction <c/>turn();<n/> to instruct the bot to perform a rotation on itself of a certain number of degrees."
msgstr ""

#. type: Plain text
#: ../E/turn.txt:5
#, no-wrap
msgid "90 degreed means a quarter turn, 180 degrees means a half turn. A positive angle will perform a counterclockwise rotation, a negative angle means a clockwise rotation. Here are some examples with <c/>turn();<n/>:"
msgstr ""

#. type: Plain text
#: ../E/turn.txt:7
#, no-wrap
msgid ""
"<c/>turn(90);<n/>  quarter turn to the left\n"
"<c/>turn(-90);<n/> quarter turn to the right (negative angle)\n"
"<c/>turn(180);<n/> half turn"
msgstr ""

#. type: Plain text
#: ../E/turn.txt:11
#, no-wrap
msgid "In order to turn the bot towards an object found with the instruction <c/><a cbot|radar>radar</a>();<n/>, you must calculate the rotation angle with the instruction <code><a cbot|direct>direction</a>()</code>:"
msgstr ""

#. type: Source code
#: ../E/turn.txt:13
#, no-wrap
msgid ""
"\titem = <a cbot|radar>radar</a>(AlienSpider);\n"
"\tturn(<a cbot|direct>direction</a>(item.position));"
msgstr ""

#. type: Plain text
#: ../E/turn.txt:16
#, no-wrap
msgid "After these lines, just fire the cannon, and there is one hostile element less."
msgstr ""

#. type: Source code
#: ../E/turn.txt:20
#, no-wrap
msgid "<c/>turn ( angle );<n/>"
msgstr ""

#. type: Plain text
#: ../E/turn.txt:22
#, no-wrap
msgid "Turns the bot with a given angle, right or left, without moving either forward or backward. "
msgstr ""

#. type: Plain text
#: ../E/turn.txt:25
#, no-wrap
msgid "Angle of the required rotation, in degrees. A positive value turns left, a negative value turns right. <code>turn(180)</code> turns round completely. "
msgstr ""

#. type: Plain text
#: ../E/turn.txt:28
#, no-wrap
msgid ""
"Zero if everything is OK, or a value different from zero if an error occurred. \n"
"<code>== 0 </code>rotation performed\n"
"<code>!= 0 </code>rotation impossible"
msgstr ""

#. type: \b; header
#: ../E/type.txt:1
#, no-wrap
msgid "Variable types"
msgstr ""

#. type: Plain text
#: ../E/type.txt:2
#, no-wrap
msgid "When you define a <a cbot|var>variable</a>, you must give two elements: "
msgstr ""

#. type: Bullet: '1)'
#: ../E/type.txt:4
#, no-wrap
msgid "a name"
msgstr ""

#. type: Bullet: '2)'
#: ../E/type.txt:5
#, no-wrap
msgid "a type"
msgstr ""

#. type: Plain text
#: ../E/type.txt:7
#, no-wrap
msgid "Once you defined a variable, you can use it to put information in it. However, the information that a variable can contain must always be of the correct type: a variable of type <a cbot|float>float</a> can not contain a string, etc."
msgstr ""

#. type: Source code
#: ../E/type.txt:11
#, no-wrap
msgid "<code><a cbot|int>int</a></code>"
msgstr ""

#. type: Plain text
#: ../E/type.txt:12
#, no-wrap
msgid "For a whole number (12, -500, etc.)."
msgstr ""

#. type: Source code
#: ../E/type.txt:14
#, no-wrap
msgid "<code><a cbot|float>float</a></code>"
msgstr ""

#. type: Plain text
#: ../E/type.txt:15
#, no-wrap
msgid "For a real number (12, 3.14, 0.2, -99.98, etc.)."
msgstr ""

#. type: Source code
#: ../E/type.txt:17
#, no-wrap
msgid "<code><a cbot|bool>bool</a></code>"
msgstr ""

#. type: Plain text
#: ../E/type.txt:18
#, no-wrap
msgid "For a boolean variable, that can only take the values <code>true</code> or <code>false</code>."
msgstr ""

#. type: Source code
#: ../E/type.txt:20
#, no-wrap
msgid "<code><a cbot|string>string</a></code>"
msgstr ""

#. type: Plain text
#: ../E/type.txt:21
#, no-wrap
msgid "For texts (\"Hello!\", \"No object found\", etc.)"
msgstr ""

#. type: Source code
#: ../E/type.txt:23
#, no-wrap
msgid "<code><a cbot|point>point</a></code>"
msgstr ""

#. type: Plain text
#: ../E/type.txt:24
#, no-wrap
msgid "For the coordinates of a point in space; a variable of this type consists of three parts named x, y and z."
msgstr ""

#. type: Source code
#: ../E/type.txt:26
#, no-wrap
msgid "<code><a cbot|object>object</a></code>"
msgstr ""

#. type: Plain text
#: ../E/type.txt:27
#, no-wrap
msgid "A variable of this type contains the information about an object (bot, building, enemy, etc.)."
msgstr ""

#. type: Source code
#: ../E/type.txt:29
#, no-wrap
msgid "<code><a cbot|void>void</a></code>"
msgstr ""

#. type: Plain text
#: ../E/type.txt:30
#, no-wrap
msgid "This type is an \"empty type\", that you use when you do not want to specify a type."
msgstr ""

#. type: \b; header
#: ../E/var.txt:1
#, no-wrap
msgid "Variables"
msgstr ""

#. type: Plain text
#: ../E/var.txt:2
#, no-wrap
msgid "A variable is like a box, where you can put some information. The content of the variable can change during the execution of the program."
msgstr ""

#. type: Plain text
#: ../E/var.txt:4
#, no-wrap
msgid "For example, you can use a variable to count the number of titanium ore units that the grabber has collected and carried to the converter. First, you must find a name for it: the name should not be too long, but explain by itself what the variable is used for. Let's call it <code>countTit</code>. This variable must contain only whole numbers, so choose the type <code>int</code>. At the beginning of the program, you must declare the variable. Then you put the value <code>0</code> into the variable, and every time you grab a titanium ore, you increase the variable by <code>1</code>. At every moment, the variable contains the number of titanium ore units that the grabber collected."
msgstr ""

#. type: Plain text
#: ../E/var.txt:6
#, no-wrap
msgid ""
"For the declaration of the variable, write the following line: \n"
"<c/><s/>\tint  countTit;<n/>"
msgstr ""

#. type: Plain text
#: ../E/var.txt:9
#, no-wrap
msgid ""
"To put <code>0</code> into the variable, write:\n"
"<c/><s/>\tcountTit = 0;<n/>"
msgstr ""

#. type: Plain text
#: ../E/var.txt:12
#, no-wrap
msgid ""
"At every titanium ore grabbed, write:\n"
"<c/><s/>\tcountTit = countTit + 1<n/>"
msgstr ""

#. type: Plain text
#: ../E/var.txt:15
#, no-wrap
msgid ""
"You have much freedom in the choice of the name for a variable, you can call them by any name, f. ex.: <code>dist</code>, <code>direct</code>, <code>p2</code>, <code>a</code>, <code>x</code>, <code>nothing_2_shoot_at</code>, etc.\n"
"A variable name must always begin with a letter. It can be followed by any combination of letters, digits or the underscore character <code>_</code>. You can of course not use the keywords of the CBOT language like <code><a cbot|for>for</a></code>, <code><a cbot|while>while</a></code>, <code><a cbot|break>break</a></code>, <code><a cbot|continue>continue</a></code>, <code>do</code>, etc.\n"
"You should be careful about the choice of the names that you give to variables; writing a program can become very difficult if you forget the names of variables or if you do not remember what they are used for. Elaborate your own system to find variable names, and do not use names like <code>Bmo45</code>, <code>a</code> or <code>tgBinX</code>."
msgstr ""

#. type: Plain text
#: ../E/var.txt:19
#, no-wrap
msgid "In the example above, the keyword <code>int</code> indicates that this variable can contain only whole numbers, which is adequate to counting objects. If you want to measure a distance, better use a variable that can contain also real numbers, with a fractional part (like 3.45 or 0.034): in this case, use the type <code>float</code>."
msgstr ""

#. type: Bullet: '1)'
#: ../E/var.txt:22
#, no-wrap
msgid "the name,"
msgstr ""

#. type: Bullet: '2)'
#: ../E/var.txt:23
#, no-wrap
msgid "the type of the information stored inside,"
msgstr ""

#. type: Bullet: '3)'
#: ../E/var.txt:24
#, no-wrap
msgid "the content, i.e. the information itself."
msgstr ""

#. type: \t; header
#: ../E/var.txt:26
#, no-wrap
msgid "the name"
msgstr ""

#. type: Plain text
#: ../E/var.txt:27
#, no-wrap
msgid "You need the name to be able to distinguish the different variables from each other."
msgstr ""

#. type: \t; header
#: ../E/var.txt:29
#, no-wrap
msgid "the type"
msgstr ""

#. type: Bullet: 'o'
#: ../E/var.txt:32
#, no-wrap
msgid "<code><a cbot|int>int</a></code> for a whole number (12, -500, etc.)"
msgstr ""

#. type: Bullet: 'o'
#: ../E/var.txt:33
#, no-wrap
msgid "<code><a cbot|float>float</a></code> for a real number (3.14, 0.2, -99.98, etc.)"
msgstr ""

#. type: Bullet: 'o'
#: ../E/var.txt:34
#, no-wrap
msgid "<code><a cbot|string>string</a></code> for a character string (\"Hello!\", \"No object found\", etc.)"
msgstr ""

#. type: Bullet: 'o'
#: ../E/var.txt:35
#, no-wrap
msgid "<code><a cbot|point>point</a></code> for a x,y,z-coordinate in space"
msgstr ""

#. type: Bullet: 'o'
#: ../E/var.txt:36
#, no-wrap
msgid "<code><a cbot|object>object</a></code> for information about an object (bot, building, etc.)"
msgstr ""

#. type: \t; header
#: ../E/var.txt:38
#, no-wrap
msgid "The content"
msgstr ""

#. type: Plain text
#: ../E/var.txt:39
#, no-wrap
msgid "The content of a variable is an information of the kind specified in the type. It can change during the execution of the program. "
msgstr ""

#. type: Plain text
#: ../E/var.txt:41
#, no-wrap
msgid ""
"Once you declared a variable, it still does not contain any value. Before you can use it, you must put a value inside: \n"
"<c/><s/>\tint  i, j;"
msgstr ""

#. type: Source code
#: ../E/var.txt:43
#, no-wrap
msgid ""
"\tj = 25;  // j takes the value 25\n"
"\tj = i;   // can not write this, because i has got no content yet."
msgstr ""

#. type: Plain text
#: ../E/var.txt:46
#, no-wrap
msgid ""
"You can also declare a variable and put a value inside in the same line, writing: \n"
"<c/><s/>\tint  countTit = 0;"
msgstr ""

#. type: Plain text
#: ../E/var.txt:49
#, no-wrap
msgid ""
"When you assign a value to a variable with the equals sign <code>=</code>, the value on the right side is copied into the value on the left side. Consider the following example: \n"
"<c/><s/>\tint  i, j;"
msgstr ""

#. type: Source code
#: ../E/var.txt:51
#, no-wrap
msgid ""
"\ti = 5+2;  // i takes the value 7\n"
"\tj = i+6;  // j takes the value of i plus 6, this is 13\n"
"\ti = j;    // i takes the value of j, this is 13"
msgstr ""

#. type: Plain text
#: ../E/var.txt:55
#, no-wrap
msgid "At the end of this example, both variables <code>i</code> and <code>j</code> contain the value <code>13</code>."
msgstr ""

#. type: Plain text
#: ../E/var.txt:57
#, no-wrap
msgid ""
"The following assignment is not correct, because on the left side of the equals sign <code>=</code>, there can be only a variable name:\n"
"<c/><s/>\ti+2 = j;  // impossible"
msgstr ""

#. type: Plain text
#: ../E/var.txt:60
#, no-wrap
msgid ""
"If you want to exchange the values of two variables, you must use a third variable. Here is an example to exchange the content of two variables <code>a</code> and <code>b</code> :\n"
"<c/><s/>\tint temp;"
msgstr ""

#. type: Source code
#: ../E/var.txt:62
#, no-wrap
msgid ""
"\ttemp = a;  // temp takes the value of a\n"
"\ta = b;     // the content of b is copied into a\n"
"\tb = temp;  // the content of temp is copied into b"
msgstr ""

#. type: \b; header
#: ../E/void.txt:1
#, no-wrap
msgid "Type <code>void</code>"
msgstr ""

#. type: Plain text
#: ../E/void.txt:2
#, no-wrap
msgid "Use this type when you want to declare a function that returns nothing."
msgstr ""

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

#. type: Source code
#: ../E/void.txt:6
#, no-wrap
msgid ""
"{\n"
"\t...\n"
"}"
msgstr ""

#. type: \b; header
#: ../E/wait.txt:1
#, no-wrap
msgid "Instruction <code>wait</code>"
msgstr ""

#. type: Plain text
#: ../E/wait.txt:2
#, no-wrap
msgid "The instruction <c/>wait();<n/> instructs the bot to wait for some seconds, according to the value written in brackets."
msgstr ""

#. type: Plain text
#: ../E/wait.txt:5
#, no-wrap
msgid "In order to wait until the <a object|power>power cell</a> is recharged on a power station, wait 5 seconds with <c/>wait(5);<n/>."
msgstr ""

#. type: Plain text
#: ../E/wait.txt:7
#, no-wrap
msgid "In order to wait until the <a object|convert>converter</a> finished transforming some <a object|titanore>titanium ore</a> in a <a object|titan>titanium cube</a>, wait 15 seconds with <c/>wait(15);<n/>."
msgstr ""

#. type: Source code
#: ../E/wait.txt:11
#, no-wrap
msgid "<c/>wait ( time );<n/>"
msgstr ""

#. type: Plain text
#: ../E/wait.txt:13
#, no-wrap
msgid "Waits for a moment."
msgstr ""

#. type: Plain text
#: ../E/wait.txt:16
#, no-wrap
msgid "Specifies the time that the bot must wait."
msgstr ""

#. type: \b; header
#: ../E/while.txt:1
#, no-wrap
msgid "Instruction <code>while</code>"
msgstr ""

#. type: Plain text
#: ../E/while.txt:2
#, no-wrap
msgid "The instruction <code>while () {}</code> is used to repeat a set of instructions several times."
msgstr ""

#. type: Bullet: 'o'
#: ../E/while.txt:6
#, no-wrap
msgid "look for a spider,"
msgstr ""

#. type: Bullet: 'o'
#: ../E/while.txt:7
#, no-wrap
msgid "turn towards it,"
msgstr ""

#. type: Bullet: 'o'
#: ../E/while.txt:8
#, no-wrap
msgid "shoot."
msgstr ""

#. type: Source code
#: ../E/while.txt:10
#, no-wrap
msgid ""
"\twhile (true)\n"
"\t{\n"
"\t\titem = <a cbot|radar>radar</a>(AlienSpider);\n"
"\t\t<a cbot|turn>turn</a>(direction(item.position));\n"
"\t\t<a cbot|fire>fire</a>(1);\n"
"\t}"
msgstr ""

#. type: Plain text
#: ../E/while.txt:17
#, no-wrap
msgid "Just execute this program once, and it will kill all spiders around it."
msgstr ""

#. type: Source code
#: ../E/while.txt:21
#, no-wrap
msgid ""
"<code>while ( condition )\n"
"{\n"
"\t</code>Instructions ...<c/>\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/while.txt:26
#, no-wrap
msgid "This instruction allows you to perform the instructions inside the <a cbot|bloc>block</a> several times."
msgstr ""

#. type: Plain text
#: ../E/while.txt:28
#, no-wrap
msgid "Be careful not to confuse the instruction <code>while( ) { }</code> with the instruction <c/><a cbot|do>do</a> { } while( );<n/>; the latter tests the condition only after the instructions in the block have been performed a first time. "
msgstr ""

#. type: Source code
#: ../E/while.txt:34
#, no-wrap
msgid ""
"<c/>int i = 0;\n"
"while ( i < 10 )\n"
"{\n"
"\t<n/>Instructions ...<c/>\n"
"\ti = i+1;\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/while.txt:42
#, no-wrap
msgid "Do not put a <a cbot|term>semicolon</a> at the end of the line <code>while ( )</code>."
msgstr ""

#. type: Plain text
#: ../E/while.txt:44
#, no-wrap
msgid "The instructions <code><a cbot|break>break</a></code> and <code><a cbot|continue>continue</a></code> can be useful inside a block following the instruction <code>while { }</code>."
msgstr ""

#. type: \b; header
#: ../E/writeln.txt:1
#, no-wrap
msgid "Instruction <code>writeln</code>"
msgstr ""

#. type: Plain text
#: ../E/writeln.txt:2
#, no-wrap
msgid "Write one line of text to an open file in the files/ folder. This is a method of the <code><a cbot|file>file</a></code> class. This is the reason why we always write <code>handle.writeln()</code>:"
msgstr ""

#. type: Source code
#: ../E/writeln.txt:4
#, no-wrap
msgid "\thandle.writeln(\"abc\");"
msgstr ""

#. type: Plain text
#: ../E/writeln.txt:6
#, no-wrap
msgid "The file must have been opened for writing (<code>\"w\"</code>) with the <code><a cbot|open>open</a></code> instruction. The line will automatically be terminated by the end of line characters 0x0D (CR) and 0x0A (LF)."
msgstr ""

#. type: Source code
#: ../E/writeln.txt:9
#, no-wrap
msgid "<c/>handle.writeln ( string );<n/>"
msgstr ""

#. type: Source code
#: ../E/writeln.txt:13
#, no-wrap
msgid "\twriteln(\"Line of text\");"
msgstr ""

#. type: Source code
#: ../E/writeln.txt:15
#, no-wrap
msgid ""
"\tstring s1 = \"abc\";\n"
"\tstring s2 = \"def\";\n"
"\twriteln(s1 + \" \" + s2);"
msgstr ""

#. type: Plain text
#: ../E/writeln.txt:20
#, no-wrap
msgid ""
"<code><a cbot|file>file</a></code>, <code><a cbot|open>open</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|readln>readln</a></code> and <code><a cbot|eof>eof</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: Plain text
#: ../E/fire.txt:13
#, no-wrap
msgid "Fires the gun, with a burst that lasts a certain time. The longer the burst, the more energy it needs. This instruction can be used with the following bot types: "
msgstr ""

#. type: Plain text
#: ../E/message.txt:15
#, no-wrap
msgid "Type of the message, that determines the background color. "
msgstr ""

#. type: Plain text
#: ../E/var.txt:21
#, no-wrap
msgid "In fact, a variable is made up of three parts:"
msgstr ""

#. type: Plain text
#: ../E/var.txt:30
#, no-wrap
msgid ""
"The <a cbot|type>type</a> determines what kind of information the variable can contain. According to the type, a variable can contain a whole number, a real number, a string, the coordinates of a point, information about an object, etc. \n"
"Here is a list of the most common variable types:"
msgstr ""

#. type: Plain text
#: ../E/while.txt:5
#, no-wrap
msgid "The most frequent use of <code>while</code> consists in repeating a set of instructions again and again. In order to achieve this, write <code>while (true) {}</code> and put the instructions to be repeated in braces <code>{}</code>. As an example, here is a program that repeats again and again the following actions:"
msgstr ""

#. type: \b; header
#: ../E/acos.txt:1
#, no-wrap
msgid "Instruction <code>acos</code>"
msgstr ""

#. type: Source code
#: ../E/acos.txt:3
#, no-wrap
msgid "<c/>acos ( value );<n/>"
msgstr ""

#. type: \t; header
#: ../E/acos.txt:5 ../E/asin.txt:5 ../E/atan.txt:5 ../E/ceil.txt:6 ../E/floor.txt:6 ../E/round.txt:6 ../E/sqrt.txt:5 ../E/trunc.txt:6
#, no-wrap
msgid "value: <code><a cbot|float>float</a></code>"
msgstr ""

#. type: Plain text
#: ../E/acos.txt:6 ../E/asin.txt:6
#, no-wrap
msgid "Number between -1 and 1 (including both)."
msgstr ""

#. type: Plain text
#: ../E/acos.txt:9
#, no-wrap
msgid "Arcus cosine (in degrees) of the value."
msgstr ""

#. type: Plain text
#: ../E/acos.txt:12 ../E/asin.txt:12 ../E/atan.txt:12 ../E/atan2.txt:17 ../E/cos.txt:12 ../E/pow.txt:15 ../E/rand.txt:9 ../E/sin.txt:12 ../E/sqrt.txt:12 ../E/tan.txt:12
#, no-wrap
msgid "<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|expr>expressions</a>."
msgstr ""

#. type: Source code
#: ../E/aim.txt:3
#, no-wrap
msgid "<c/>aim ( y, x );<n/>"
msgstr ""

#. type: Plain text
#: ../E/aim.txt:5
#, no-wrap
msgid "This instruction sets the vertical and the horizontal angle of the cannon. The following robots are equipped with a cannon: "
msgstr ""

#. type: Plain text
#: ../E/aim.txt:10
#, no-wrap
msgid "When controlling the robot through programming, the gun can be also turned left or right by turning the whole robot with the instruction <code><a cbot|turn>turn</a></code>."
msgstr ""

#. type: \t; header
#: ../E/aim.txt:12 ../E/atan2.txt:7 ../E/pow.txt:8
#, no-wrap
msgid "y: <code><a cbot|float>float</a></code>"
msgstr ""

#. type: \t; header
#: ../E/aim.txt:15
#, no-wrap
msgid "x: <code><a cbot|float>float</a></code> (default value: <code>0</code>)"
msgstr ""

#. type: Plain text
#: ../E/aim.txt:16
#, no-wrap
msgid "Angle in degrees of the gun relative to the robot. A positive value orients the gun to the right. The angle must range from <code>-40</code> to <code>+40</code> degrees for all shooters."
msgstr ""

#. type: \b; header
#: ../E/asin.txt:1
#, no-wrap
msgid "Instruction <code>asin</code>"
msgstr ""

#. type: Source code
#: ../E/asin.txt:3
#, no-wrap
msgid "<c/>asin ( value );<n/>"
msgstr ""

#. type: Plain text
#: ../E/asin.txt:9
#, no-wrap
msgid "Arcus sine (in degrees) of the value."
msgstr ""

#. type: \b; header
#: ../E/atan.txt:1
#, no-wrap
msgid "Instruction <code>atan</code>"
msgstr ""

#. type: Source code
#: ../E/atan.txt:3
#, no-wrap
msgid "<c/>atan ( value );<n/>"
msgstr ""

#. type: Plain text
#: ../E/atan.txt:6 ../E/atan2.txt:8 ../E/atan2.txt:11 ../E/ceil.txt:7 ../E/floor.txt:7 ../E/round.txt:7 ../E/trunc.txt:7
#, no-wrap
msgid "Number."
msgstr ""

#. type: Plain text
#: ../E/atan.txt:9
#, no-wrap
msgid "Arcus tangent (in degrees) of the value."
msgstr ""

#. type: \b; header
#: ../E/atan2.txt:1
#, no-wrap
msgid "Instruction <code>atan2</code>"
msgstr ""

#. type: Source code
#: ../E/atan2.txt:3
#, no-wrap
msgid "<c/>atan2 ( y, x );<n/>"
msgstr ""

#. type: Plain text
#: ../E/atan2.txt:5
#, no-wrap
msgid "The purpose of using two arguments instead of one is to gather information on the signs of the inputs in order to return the appropriate quadrant of the computed angle, which is not possible for the single-argument <c/><a cbot|atan>atan();</a><n/> function. For example, consider a point <code>(-1, -1)</code>: <c/>atan(-1/-1);<n/> is <code>45.00</code> degrees, whereas <c/>atan2(-1, -1);<n/> is <code>-135.00</code> degrees, which is obviously more correct in this case."
msgstr ""

#. type: \t; header
#: ../E/atan2.txt:10 ../E/pow.txt:5
#, no-wrap
msgid "x: <code><a cbot|float>float</a></code>"
msgstr ""

#. type: Plain text
#: ../E/atan2.txt:14
#, no-wrap
msgid "Arcus tangent (in degrees) of <code>y/x</code>."
msgstr ""

#. type: \b; header
#: ../E/build.txt:1
#, no-wrap
msgid "Instruction <code>build</code>"
msgstr ""

#. type: Source code
#: ../E/build.txt:7
#, no-wrap
msgid ""
" <a cbot|object>object</a> item = <a cbot|radar>radar</a>(<a object|titan>Titanium</a>);\n"
" <a cbot|goto>goto</a>(item.position);\n"
" build(<a object|factory>BotFactory</a>);"
msgstr ""

#. type: Source code
#: ../E/build.txt:13
#, no-wrap
msgid "<c/>build ( cat );<n/>"
msgstr ""

#. type: \t; header
#: ../E/build.txt:17 ../E/buildingenabled.txt:16 ../E/canbuild.txt:16 ../E/detect.txt:11 ../E/factory.txt:7 ../E/radar.txt:22
#, no-wrap
msgid "cat: <code><a cbot|int>int</a></code>"
msgstr ""

#. type: Plain text
#: ../E/build.txt:18 ../E/buildingenabled.txt:17 ../E/canbuild.txt:17
#, no-wrap
msgid "<a cbot|category>Category</a> of a building."
msgstr ""

#. type: Plain text
#: ../E/build.txt:21
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <code>build()</code>.\n"
"<code>== 0 </code>Successfully built\n"
"<code>!= 0 </code>Impossible to build (for example, the nearest titanium cube is too far away or the specified building is not available in the mission)"
msgstr ""

#. type: \b; header
#: ../E/buildingenabled.txt:1
#, no-wrap
msgid "Instruction <code>buildingenabled</code>"
msgstr ""

#. type: Plain text
#: ../E/buildingenabled.txt:5
#, no-wrap
msgid "It is similar to the <c/><a cbot|canbuild>canbuild();</a><n/> instruction. However, it does not check if a required research has been done."
msgstr ""

#. type: Source code
#: ../E/buildingenabled.txt:7
#, no-wrap
msgid ""
" <a cbot|if>if</a> (buildingenabled(<a object|factory>BotFactory</a>))\n"
" {\n"
" \tbuild(<a object|factory>BotFactory</a>);\n"
" }"
msgstr ""

#. type: Source code
#: ../E/buildingenabled.txt:14
#, no-wrap
msgid "<c/>buildingenabled ( cat );<n/>"
msgstr ""

#. type: \t; header
#: ../E/buildingenabled.txt:19 ../E/canbuild.txt:19 ../E/canresearch.txt:10 ../E/detect.txt:23 ../E/isbusy.txt:10 ../E/researched.txt:10
#, no-wrap
msgid "Return value: <code><a cbot|bool>bool</a></code>"
msgstr ""

#. type: \t; header
#: ../E/destroy.txt:7 ../E/factory.txt:13 ../E/isbusy.txt:7 ../E/research.txt:10 ../E/takeoff.txt:7
#, no-wrap
msgid "<a cbot|object>object</a>"
msgstr ""

#. type: Plain text
#: ../E/isbusy.txt:8
#, no-wrap
msgid "Any building which can take some action (e.g. <a cbot|convert>Converter</a>)."
msgstr ""

#. type: Plain text
#: ../E/isbusy.txt:11
#, no-wrap
msgid ""
"<code><format const>true</format></code> if the object is doing something (e.g. converting)\n"
"<code><format const>false</format></code> if the object is not doing anything"
msgstr ""

#. type: \b; header
#: ../E/canbuild.txt:1
#, no-wrap
msgid "Instruction <code>canbuild</code>"
msgstr ""

#. type: Plain text
#: ../E/canbuild.txt:5
#, no-wrap
msgid "It helps to prevent errors in programs using the <c/><a cbot|build>build();</a><n/> instruction. Here is an example:"
msgstr ""

#. type: Source code
#: ../E/canbuild.txt:7
#, no-wrap
msgid ""
" <a cbot|if>if</a> (canbuild(<a object|factory>BotFactory</a>))\n"
" {\n"
" \tbuild(<a object|factory>BotFactory</a>);\n"
" }"
msgstr ""

#. type: Source code
#: ../E/canbuild.txt:14
#, no-wrap
msgid "<c/>canbuild ( cat );<n/>"
msgstr ""

#. type: Plain text
#: ../E/buildingenabled.txt:20 ../E/canbuild.txt:20
#, no-wrap
msgid "<code>true</code> if the building can be built, <code>false</code> otherwise."
msgstr ""

#. type: \b; header
#: ../E/canresearch.txt:1
#, no-wrap
msgid "Instruction <code>canresearch</code>"
msgstr ""

#. type: Source code
#: ../E/canresearch.txt:3
#, no-wrap
msgid "<c/>canresearch ( research );<n/>"
msgstr ""

#. type: \t; header
#: ../E/canresearch.txt:7 ../E/researched.txt:7
#, no-wrap
msgid "research: <code><a cbot|int>int</a></code>"
msgstr ""

#. type: Plain text
#: ../E/canresearch.txt:8 ../E/research.txt:8 ../E/researched.txt:8
#, no-wrap
msgid "<a cbot|researches>Research name</a>."
msgstr ""

#. type: Plain text
#: ../E/canresearch.txt:11
#, no-wrap
msgid ""
"<format const>true</format> if the research can be done (even if it is already done, to check that, use the <a cbot|researched>researched</a> instruction)\n"
"<format const>false</format> if the research cannot be done"
msgstr ""

#. type: Plain text
#: ../E/category.txt:6
#, no-wrap
msgid "Below are the different categories available:"
msgstr ""

#. type: \t; header
#: ../E/category.txt:8
#, no-wrap
msgid "Buildings:"
msgstr ""

#. type: \t; header
#: ../E/category.txt:32
#, no-wrap
msgid "Portable Objects:"
msgstr ""

#. type: \t; header
#: ../E/category.txt:45
#, no-wrap
msgid "Robots:"
msgstr ""

#. type: \t; header
#: ../E/category.txt:82
#, no-wrap
msgid "Enemies:"
msgstr ""

#. type: \t; header
#: ../E/category.txt:92
#, no-wrap
msgid "Miscellaneous:"
msgstr ""

#. type: \t; header
#: ../E/category.txt:106
#, no-wrap
msgid "Flags and Other Indicators:"
msgstr ""

#. type: \b; header
#: ../E/ceil.txt:1
#, no-wrap
msgid "Instruction <code>ceil</code>"
msgstr ""

#. type: Source code
#: ../E/ceil.txt:3
#, no-wrap
msgid "<c/>ceil ( value );<n/>"
msgstr ""

#. type: Plain text
#: ../E/ceil.txt:4
#, no-wrap
msgid "Rounds up a number."
msgstr ""

#. type: Plain text
#: ../E/ceil.txt:10
#, no-wrap
msgid "Ceiling of the value, i.e. the smallest integer not less than <code>value</code>. For example, <code>ceil(2.1)</code> is <code>3.0</code>."
msgstr ""

#. type: Plain text
#: ../E/ceil.txt:13 ../E/floor.txt:13 ../E/trunc.txt:13
#, no-wrap
msgid "<a cbot|round>round</a>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|expr>expressions</a>."
msgstr ""

#. type: \b; header
#: ../E/colors.txt:1
#, no-wrap
msgid "Value <code>Colors</code>"
msgstr ""

#. type: Plain text
#: ../E/colors.txt:2
#, no-wrap
msgid "Color names are used to define a specific color to use. They can be passed to functions like <a cbot|pendown>pendown</a> or <a cbot|pencolor>pencolor</a>."
msgstr ""

#. type: Plain text
#: ../E/colors.txt:4
#, no-wrap
msgid "In a program, colors are always displayed on a <format const>red background</format>. If a color isn't highlighted in red, it is misspelled. Caps and lower cases should be kept as is."
msgstr ""

#. type: Plain text
#: ../E/colors.txt:6
#, no-wrap
msgid "Below are the different colors available:"
msgstr ""

#. type: Plain text
#: ../E/colors.txt:8
#, no-wrap
msgid ""
"<code><format const>White</format></code>\n"
"<code><format const>Black</format></code>\n"
"<code><format const>Gray</format></code>\n"
"<code><format const>LightGray</format></code>\n"
"<code><format const>Red</format></code>\n"
"<code><format const>Pink</format></code>\n"
"<code><format const>Purple</format></code>\n"
"<code><format const>Orange</format></code>\n"
"<code><format const>Yellow</format></code>\n"
"<code><format const>Beige</format></code>\n"
"<code><format const>Brown</format></code>\n"
"<code><format const>Skin</format></code>\n"
"<code><format const>Green</format></code>\n"
"<code><format const>LightGreen</format></code>\n"
"<code><format const>Blue</format></code>\n"
"<code><format const>LightBlue</format></code>"
msgstr ""

#. type: Plain text
#: ../E/colors.txt:25
#, no-wrap
msgid "You can also draw colored symbols:"
msgstr ""

#. type: Plain text
#: ../E/colors.txt:27
#, no-wrap
msgid ""
"<code><format const>BlackArrow</format></code>\n"
"<code><format const>RedArrow</format></code>"
msgstr ""

#. type: \b; header
#: ../E/cos.txt:1
#, no-wrap
msgid "Instruction <code>cos</code>"
msgstr ""

#. type: Source code
#: ../E/cos.txt:3
#, no-wrap
msgid "<c/>cos ( angle );<n/>"
msgstr ""

#. type: Plain text
#: ../E/cos.txt:6 ../E/sin.txt:6
#, no-wrap
msgid "Angle in degrees."
msgstr ""

#. type: Plain text
#: ../E/cos.txt:9
#, no-wrap
msgid "Cosine of the angle."
msgstr ""

#. type: \b; header
#: ../E/destroy.txt:1
#, no-wrap
msgid "Instruction <code>destroy</code>"
msgstr ""

#. type: Source code
#: ../E/destroy.txt:3
#, no-wrap
msgid "<c/><a cbot|object>object</a>.destroy ( );<n/>"
msgstr ""

#. type: Plain text
#: ../E/destroy.txt:5
#, no-wrap
msgid "Destroys an object."
msgstr ""

#. type: Plain text
#: ../E/destroy.txt:8
#, no-wrap
msgid "<a object|destroy>Destroyer</a>."
msgstr ""

#. type: Plain text
#: ../E/destroy.txt:11
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <code>destroy()</code>.\n"
"<code>== 0 </code>The operation of destroying of an object was started\n"
"<code>!= 0 </code>The instruction could not be done (e.g. nothing to destroy)"
msgstr ""

#. type: \b; header
#: ../E/detect.txt:1
#, no-wrap
msgid "Instruction <code>detect</code>"
msgstr ""

#. type: Plain text
#: ../E/detect.txt:2
#, no-wrap
msgid "With the instruction <c/>detect();<n/>, you can look for objects like <a object|mother>enemies</a>, bots, buildings or raw materials, which are in front of the bot. It is a simpler version of <c/><a cbot|radar>radar</a>();<n/>."
msgstr ""

#. type: Source code
#: ../E/detect.txt:6
#, no-wrap
msgid "<c/>detect ( cat );<n/>"
msgstr ""

#. type: Plain text
#: ../E/detect.txt:8
#, no-wrap
msgid "Detects the nearest object of the specified <a cbot|category>category</a> being in front of the bot. It is similar to the following instruction:"
msgstr ""

#. type: Source code
#: ../E/detect.txt:9
#, no-wrap
msgid "<c/>radar(cat, 0, 45, 0, 20);<n/>"
msgstr ""

#. type: Bullet: 'o'
#: ../E/detect.txt:12 ../E/radar.txt:23
#, no-wrap
msgid "<a cbot|category>Category</a> of the objects that should be detected. For example, when you are looking for an ant, write <code>radar(AlienAnt)</code>. "
msgstr ""

#. type: Bullet: 'o'
#: ../E/detect.txt:13
#, no-wrap
msgid "<a cbot|array>Array</a> of categories of the objects that should be detected. For example, when you are looking only for grabbers:<c/>"
msgstr ""

#. type: Source code
#: ../E/detect.txt:14
#, no-wrap
msgid ""
"int bots[4];\n"
"bots[0] = WheeledGrabber;\n"
"bots[1] = TrackedGrabber;\n"
"bots[2] = WingedGrabber;\n"
"bots[3] = LeggedGrabber;\n"
"object nearestGrabber = radar(bots);"
msgstr ""

#. type: Bullet: 'o'
#: ../E/detect.txt:21 ../E/search.txt:17
#, no-wrap
msgid "Keyword <format const>Any</format> if you are looking for any object (including even plants and so on)."
msgstr ""

#. type: Plain text
#: ../E/detect.txt:24
#, no-wrap
msgid ""
"<format const>true</format> if the object was found\n"
"<format const>false</format> if the object was not found"
msgstr ""

#. type: \b; header
#: ../E/factory.txt:1
#, no-wrap
msgid "Instruction <code>factory</code>"
msgstr ""

#. type: Plain text
#: ../E/factory.txt:8
#, no-wrap
msgid "<a cbot|category>Category</a> of the robot to construct."
msgstr ""

#. type: \t; header
#: ../E/factory.txt:10
#, no-wrap
msgid "program: <code><a cbot|string>string</a></code> (default value: <code>\"\"</code>)"
msgstr ""

#. type: Plain text
#: ../E/factory.txt:17
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <code>factory()</code>.\n"
"<code>== 0 </code>The construction successfully started\n"
"<code>!= 0 </code>The construction could not be started (e.g. no <a object|titan>Titanium</a> in the factory, the bot is not researched)"
msgstr ""

#. type: \b; header
#: ../E/flatspace.txt:1
#, no-wrap
msgid "Instruction <code>flatspace</code>"
msgstr ""

#. type: Source code
#: ../E/flatspace.txt:3
#, no-wrap
msgid "<c/>flatspace ( center, flatmin, rmin, rmax, dist );<n/>"
msgstr ""

#. type: Plain text
#: ../E/flatspace.txt:5
#, no-wrap
msgid "Determines the position of the nearest free space with at least <code>flatmin</code> of flat ground around a given position. Works similar to <c/><a cbot|space>space();</a><n/>. Useful for finding a place for a <a cbot|category>building</a>."
msgstr ""

#. type: \t; header
#: ../E/flatspace.txt:10
#, no-wrap
msgid "flatmin: <code><a cbot|float>float</a></code>"
msgstr ""

#. type: Plain text
#: ../E/flatspace.txt:11
#, no-wrap
msgid "Minimum radius of flat ground around the desired position."
msgstr ""

#. type: \b; header
#: ../E/floor.txt:1
#, no-wrap
msgid "Instruction <code>floor</code>"
msgstr ""

#. type: Source code
#: ../E/floor.txt:3
#, no-wrap
msgid "<c/>floor ( value );<n/>"
msgstr ""

#. type: Plain text
#: ../E/floor.txt:4
#, no-wrap
msgid "Rounds down a number."
msgstr ""

#. type: Plain text
#: ../E/floor.txt:10
#, no-wrap
msgid "Floor of the value, i.e. the largest integer not greater than <code>value</code>. For example, <code>floor(2.9)</code> is <code>2.00</code>."
msgstr ""

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

#. type: Plain text
#: ../E/function.txt:2
#, no-wrap
msgid "Function, simply put, is an instruction created by you."
msgstr ""

#. type: \b; header
#: ../E/function.txt:4
#, no-wrap
msgid "Main function"
msgstr ""

#. type: Plain text
#: ../E/function.txt:5
#, no-wrap
msgid "You probably already know how to create a function. Every program in CBOT must have a main function, which looks like this:"
msgstr ""

#. type: Source code
#: ../E/function.txt:7
#, no-wrap
msgid ""
"extern void object::ProgramName()\n"
"{\n"
"\t\n"
"\t// instructions\n"
"\t\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/function.txt:17
#, no-wrap
msgid "With functions you can divide your program into several parts. Each of them will execute a specific task. For example, see the following program:"
msgstr ""

#. type: Source code
#: ../E/function.txt:19
#, no-wrap
msgid ""
"extern void object::Remote()\n"
"{\n"
"\tsend(\"order\", 1, 100);\n"
"\twait(5);\n"
"\tsend(\"order\", 3, 100);\n"
"\twait(5);\n"
"\tsend(\"order\", 2, 100);\n"
"\twait(5);\n"
"\tsend(\"order\", 4, 100);\n"
"\twait(5);\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/function.txt:31
#, no-wrap
msgid "<code><a cbot|send>send</a></code> and <code><a cbot|wait>wait</a></code> are repeated several times. So it would be a good thing if we created a function that executes these two instructions:"
msgstr ""

#. type: Source code
#: ../E/function.txt:33
#, no-wrap
msgid ""
"void SendToPost(float op)\n"
"{\n"
"\tsend(\"order\", op, 100);\n"
"\twait(5);\n"
"}\n"
"\n"
"extern void object::Remote()\n"
"{\n"
"\tSendToPost(1);\n"
"\tSendToPost(3);\n"
"\tSendToPost(2);\n"
"\tSendToPost(4);\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/function.txt:47
#, no-wrap
msgid "Now the program is much easier to read. It is a good practice to split the program into several functions with self-describing names."
msgstr ""

#. type: \b; header
#: ../E/function.txt:49
#, no-wrap
msgid "Syntax"
msgstr ""

#. type: Source code
#: ../E/function.txt:51
#, no-wrap
msgid ""
"result_type FunctionName(optional_parameters)\n"
"{\n"
"\tbody\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/function.txt:56
#, no-wrap
msgid "Result <a cbot|type>type</a> should be <a cbot/void>void</a> if the function does not give any. Body is just a set of instructions. Function name must be created with the exact same rules applied to <a cbot|var>variables</a>."
msgstr ""

#. type: \t; header
#: ../E/function.txt:58
#, no-wrap
msgid "Parameters"
msgstr ""

#. type: Plain text
#: ../E/function.txt:59
#, no-wrap
msgid "A function can have parameters:"
msgstr ""

#. type: Source code
#: ../E/function.txt:61
#, no-wrap
msgid ""
"void Example(int a, float x, string s)\n"
"{\n"
"\tmessage(a);\n"
"\tmessage(x);\n"
"\tmessage(s);\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/function.txt:68
#, no-wrap
msgid "The <code>Example</code> function will receive an <a cbot|int>integer</a> <code>a</code>, a <a cbot|float>floating point number</a> <code>x</code> and a <a cbot|string>string</a> <code>s</code>. Parameters are \"passed by value\", that is the values of parameter variables in a function are copies of the values the caller specified as variables. If you pass an <code><a cbot|int>int</a></code> to a function, its parameter is a copy of whatever value was being passed as the argument, and the function can change its parameter value without affecting values in the code that invoked the function."
msgstr ""

#. type: Plain text
#: ../E/function.txt:70
#, no-wrap
msgid "If you pass a <a cbot|class>class</a> instance or an <a cbot|array>array</a> as parameter to a function, the function only receives a <a cbot|pointer>reference</a> to the instance or the array. That means if you modify the instance or the array in the function, the instance or the array that has been specified by the caller will be actually modified."
msgstr ""

#. type: \t; header
#: ../E/function.txt:72
#, no-wrap
msgid "Result"
msgstr ""

#. type: Plain text
#: ../E/function.txt:73
#, no-wrap
msgid "A function can also return a result with the <code><a cbot|return>return</a></code> instruction. Therefore the function must be declared no longer as <code><a cbot|void>void</a></code> but as an other <a cbot|type>type</a>:"
msgstr ""

#. type: Source code
#: ../E/function.txt:75
#, no-wrap
msgid ""
"float Average(float a, float b)\n"
"{\n"
"\treturn (a+b)/2;\n"
"}\n"
"\n"
"extern void object::Test( )\n"
"{\n"
"\tfloat value;\n"
"\tvalue = Average(2, 6);\n"
"\tmessage(value);  // will display 4\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/function.txt:87
#, no-wrap
msgid "Some other examples:"
msgstr ""

#. type: Source code
#: ../E/function.txt:89
#, no-wrap
msgid ""
"float Pi()\n"
"{\n"
"\treturn 3.1415;\n"
"}\n"
"\n"
"string Sign(float a)\n"
"{\n"
"\tif (a > 0)  return \"positive\";\n"
"\tif (a < 0)  return \"negative\";\n"
"\treturn \"null\";\n"
"}"
msgstr ""

#. type: \b; header
#: ../E/function.txt:102
#, no-wrap
msgid "Overloading"
msgstr ""

#. type: Plain text
#: ../E/function.txt:103
#, no-wrap
msgid "You can declare several functions with the same name but different parameters:"
msgstr ""

#. type: Source code
#: ../E/function.txt:105
#, no-wrap
msgid ""
"float Pythagoras(float a, float b)\n"
"{\n"
"\treturn sqrt((a*a)+(b*b));\n"
"}\n"
"\n"
"float Pythagoras(float a, float b, float c)\n"
"{\n"
"\treturn sqrt((a*a)+(b*b)+(c*c));\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/function.txt:115
#, no-wrap
msgid "CBOT will call either the one or the other function depending on the parameters passed. They must be distinguishable, i.e. you can't declare two functions with the same name and parameter types in the exact same order, e.g. declaring <code>int Pythagoras(float b, float a)</code> will result in error. Note that result type does not matter."
msgstr ""

#. type: \b; header
#: ../E/function.txt:120
#, no-wrap
msgid "object::"
msgstr ""

#. type: Plain text
#: ../E/function.txt:121
#, no-wrap
msgid "Declaring a function as a part of the <a cbot|object>object</a> namespace gives it access to <code><a cbot|this>this</a></code> <a cbot|pointer>pointer</a>, in other words, to all available properties of the robot which the program is run on."
msgstr ""

#. type: Source code
#: ../E/function.txt:123
#, no-wrap
msgid ""
"void object::Example()\n"
"{\n"
"\tmessage(this.category);\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/object.txt:2
#, no-wrap
msgid "Use this type for variables that contain the characteristics of an object, be it a bot, a building, some raw material, an enemy, etc. Here are all properties of an object: "
msgstr ""

#. type: Plain text
#: ../E/object.txt:20
#, no-wrap
msgid "Also, some objects have additional methods (instructions). See them in <a cbot>the main list</a> in the <c/>\"Instructions specific for some objects\" section."
msgstr ""

#. type: Plain text
#: ../E/object.txt:23
#, 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 ""

#. type: Source code
#: ../E/object.txt:61
#, no-wrap
msgid "<code>team</code>"
msgstr ""

#. type: Plain text
#: ../E/object.txt:62
#, no-wrap
msgid "The bot's team. Used in <a battles>code battles</a>. If the object has no team assigned (e.g. in no team-based levels, the object being a resource), this is equal to <code>0</code>."
msgstr ""

#. type: Source code
#: ../E/object.txt:64
#, no-wrap
msgid "<code>velocity</code>"
msgstr ""

#. type: Plain text
#: ../E/object.txt:65
#, no-wrap
msgid "Current velocity of the object. Should be treated as a three-dimensional vector."
msgstr ""

#. type: \b; header
#: ../E/pencolor.txt:1
#, no-wrap
msgid "Instruction <code>pencolor</code>"
msgstr ""

#. type: Source code
#: ../E/pencolor.txt:3
#, no-wrap
msgid "<c/>pencolor ( color );<n/>"
msgstr ""

#. type: Plain text
#: ../E/pencolor.txt:4
#, no-wrap
msgid "The instruction <c/>pencolor();<n/> instructs the bot to change the color of the pencil."
msgstr ""

#. type: \t; header
#: ../E/pencolor.txt:6 ../E/pendown.txt:6
#, no-wrap
msgid "color: <code><a cbot|int>int</a></code> (default value: <code>Black</code>)"
msgstr ""

#. type: Plain text
#: ../E/pencolor.txt:7 ../E/pendown.txt:7
#, no-wrap
msgid "<a cbot|colors>Color name</a>."
msgstr ""

#. type: Plain text
#: ../E/pencolor.txt:10
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <c/>pencolor();<n/>.\n"
"<code>== 0 </code>The color was changed\n"
"<code>!= 0 </code>The instruction did not work"
msgstr ""

#. type: \b; header
#: ../E/pendown.txt:1
#, no-wrap
msgid "Instruction <code>pendown</code>"
msgstr ""

#. type: Source code
#: ../E/pendown.txt:3
#, no-wrap
msgid "<c/>pendown ( color, width );<n/>"
msgstr ""

#. type: Plain text
#: ../E/pendown.txt:4
#, no-wrap
msgid "The instruction <c/>pendown();<n/> instructs the bot to have the pen down, so it starts drawing."
msgstr ""

#. type: \t; header
#: ../E/pendown.txt:9
#, no-wrap
msgid "width: <code><a cbot|float>float</a></code> (default value: <code>0.5</code>)"
msgstr ""

#. type: Plain text
#: ../E/pendown.txt:10 ../E/penwidth.txt:7
#, no-wrap
msgid "Width of the pen. The width cannot be higher than <code>1.0</code> and cannot be lower than <code>0.0</code>. Passing a higher value will result in the width being the highest possible and passing a lower value will result in the width being the lowest possible."
msgstr ""

#. type: Plain text
#: ../E/pendown.txt:13
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <c/>pendown();<n/>.\n"
"<code>== 0 </code>The pen is now down\n"
"<code>!= 0 </code>The instruction did not work"
msgstr ""

#. type: \b; header
#: ../E/penup.txt:1
#, no-wrap
msgid "Instruction <code>penup</code>"
msgstr ""

#. type: Source code
#: ../E/penup.txt:3
#, no-wrap
msgid "<c/>penup ( );<n/>"
msgstr ""

#. type: Plain text
#: ../E/penup.txt:4
#, no-wrap
msgid "The instruction <c/>penup();<n/> instructs the bot to have the pen up, so it stops drawing. The pen is up by default, so it should be used only after using <code><a cbot|pendown>pendown</a></code>."
msgstr ""

#. type: Plain text
#: ../E/penup.txt:7
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <c/>penup();<n/>.\n"
"<code>== 0 </code>The pen is now up\n"
"<code>!= 0 </code>The instruction did not work"
msgstr ""

#. type: \b; header
#: ../E/penwidth.txt:1
#, no-wrap
msgid "Instruction <code>penwidth</code>"
msgstr ""

#. type: Source code
#: ../E/penwidth.txt:3
#, no-wrap
msgid "<c/>penwidth ( color );<n/>"
msgstr ""

#. type: Plain text
#: ../E/penwidth.txt:4
#, no-wrap
msgid "The instruction <c/>penwidth();<n/> instructs the bot to change the width of the pencil."
msgstr ""

#. type: \t; header
#: ../E/penwidth.txt:6
#, no-wrap
msgid "width: <code><a cbot|float>float</a></code>"
msgstr ""

#. type: Plain text
#: ../E/penwidth.txt:10
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <c/>penwidth();<n/>.\n"
"<code>== 0 </code>The width was changed\n"
"<code>!= 0 </code>The instruction did not work"
msgstr ""

#. type: \b; header
#: ../E/pow.txt:1
#, no-wrap
msgid "Instruction <code>pow</code>"
msgstr ""

#. type: Source code
#: ../E/pow.txt:3
#, no-wrap
msgid "<c/>pow ( x, y );<n/>"
msgstr ""

#. type: Plain text
#: ../E/pow.txt:6
#, no-wrap
msgid "Base."
msgstr ""

#. type: Plain text
#: ../E/pow.txt:9
#, no-wrap
msgid "Exponent."
msgstr ""

#. type: Plain text
#: ../E/pow.txt:12
#, no-wrap
msgid "x to the y (x raised to the yth power)."
msgstr ""

#. type: Source code
#: ../E/radar.txt:15
#, no-wrap
msgid "<c/>radar ( cat, angle, focus, min, max, sens, filter );<n/>"
msgstr ""

#. type: Bullet: 'o'
#: ../E/radar.txt:24
#, no-wrap
msgid "<a cbot|array>Array</a> of categories of the objects that should be detected. For example, when you are looking only for grabbers:"
msgstr ""

#. type: Plain text
#: ../E/radar.txt:25 ../E/search.txt:10
#, no-wrap
msgid "<c/><s/>int bots[4];"
msgstr ""

#. type: Source code
#: ../E/radar.txt:26
#, no-wrap
msgid ""
"bots[0] = WheeledGrabber;\n"
"bots[1] = TrackedGrabber;\n"
"bots[2] = WingedGrabber;\n"
"bots[3] = LeggedGrabber;\n"
"object nearestGrabber = radar(bots);<n/>"
msgstr ""

#. type: Bullet: 'o'
#: ../E/radar.txt:31
#, no-wrap
msgid "Keyword <format const>Any</format> if you are looking for any object (including even plants and so on). Filters may be useful to use with this keyword."
msgstr ""

#. type: \t; header
#: ../E/radar.txt:33
#, no-wrap
msgid "angle: <code><a cbot|float>float</a></code> (default value: <code>0</code>)"
msgstr ""

#. type: \t; header
#: ../E/radar.txt:39
#, no-wrap
msgid "focus: <code><a cbot|float>float</a></code> (default value: <code>360</code>)"
msgstr ""

#. type: \t; header
#: ../E/radar.txt:42
#, no-wrap
msgid "min: <code><a cbot|float>float</a></code> (default value: <code>0</code>)"
msgstr ""

#. type: \t; header
#: ../E/radar.txt:45
#, no-wrap
msgid "max: <code><a cbot|float>float</a></code> (default value: <code>1000</code>)"
msgstr ""

#. type: \t; header
#: ../E/radar.txt:48
#, no-wrap
msgid "sens: <code><a cbot|float>float</a></code> (default value: <code>1</code>)"
msgstr ""

#. type: \t; header
#: ../E/radar.txt:51
#, no-wrap
msgid "filter: <code><a cbot|int>int</a></code> (default value: <code><format const>FilterNone</format></code>)"
msgstr ""

#. type: Plain text
#: ../E/radar.txt:52
#, no-wrap
msgid "Determines which type of objects should be detected. Especially useful in use with an <a cbot|array>array</a> or <format const>Any</format>. The following filters are available:"
msgstr ""

#. type: Plain text
#: ../E/radar.txt:54
#, no-wrap
msgid ""
"<code><format const>FilterNone</format>        </code>Detects everything (default)\n"
"<code><format const>FilterOnlyLanding</format> </code>Detects only objects being on the ground\n"
"<code><format const>FilterOnlyFlying</format>  </code>Detects only objects not being on the ground\n"
"<code><format const>FilterFriendly</format>    </code>Detects only allies (objects in the same team)\n"
"<code><format const>FilterEnemy</format>       </code>Detects only enemies (objects in an other team except neutral)\n"
"<code><format const>FilterNeutral</format>     </code>Detects only neutral objects (e.g. resources)"
msgstr ""

#. type: Plain text
#: ../E/radar.txt:61
#, no-wrap
msgid "The last three are mainly useful in <a battles>code battles</a>. You can also pass a team ID to search only for objects from a specific team. Attention: you should use <format const>FilterNeutral</format> instead of <code>0</code> or else it will not work."
msgstr ""

#. type: Plain text
#: ../E/radar.txt:63
#, no-wrap
msgid "Filters and IDs can be mixed using bitwise OR operator <code>|</code>, for example <c/>radar(Any, 0, 360, 0, 1000, 1, 2 | FilterOnlyLanding);<n/> will only detect an object from team <code>2</code> that is on the ground. Attention: you can specify only one team ID at once, but you can specify several filters at once."
msgstr ""

#. type: \b; header
#: ../E/rand.txt:1
#, no-wrap
msgid "Instruction <code>rand</code>"
msgstr ""

#. type: Source code
#: ../E/rand.txt:3
#, no-wrap
msgid "<c/>rand ( );<n/>"
msgstr ""

#. type: Plain text
#: ../E/rand.txt:6
#, no-wrap
msgid "Pseudorandom number between 0 and 1 (including 0, but excluding 1)."
msgstr ""

#. type: \b; header
#: ../E/research.txt:1
#, no-wrap
msgid "Instruction <code>research</code>"
msgstr ""

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

#. type: Plain text
#: ../E/research.txt:14
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <code>research()</code>.\n"
"<code>== 0 </code>The research successfully started\n"
"<code>!= 0 </code>The research could not be started (e.g. the research is disabled in the level, no power cell)"
msgstr ""

#. type: \b; header
#: ../E/researched.txt:1
#, no-wrap
msgid "Instruction <code>researched</code>"
msgstr ""

#. type: Source code
#: ../E/researched.txt:3
#, no-wrap
msgid "<c/>researched ( research );<n/>"
msgstr ""

#. type: \b; header
#: ../E/researches.txt:1
#, no-wrap
msgid "Value <code>Research names</code>"
msgstr ""

#. type: Plain text
#: ../E/researches.txt:2
#, no-wrap
msgid "Research names represent the types of available researches in the CBOT language. You can use them to control <a object|research>ResearchCenter</a> by passing them to appropriate instructions (e.g. <a cbot|research>research</a>, <a cbot|canresearch>canresearch</a>, <a cbot|researched>researched</a>)."
msgstr ""

#. type: Plain text
#: ../E/researches.txt:4
#, no-wrap
msgid "In a program, research names are always displayed on a <format const>red background</format>. If a research name is not highlighted in red, it is misspelled. Caps and lower cases should be kept as is."
msgstr ""

#. type: Plain text
#: ../E/researches.txt:6
#, no-wrap
msgid "Below are the different research names available."
msgstr ""

#. type: \t; header
#: ../E/researches.txt:8
#, no-wrap
msgid "Done by <a object|research>ResearchCenter</a>:"
msgstr ""

#. type: \t; header
#: ../E/researches.txt:19
#, no-wrap
msgid "Done by <a object|labo>AutoLab</a>:"
msgstr ""

#. type: \t; header
#: ../E/researches.txt:24
#, no-wrap
msgid "Impossible to research:"
msgstr ""

#. type: \b; header
#: ../E/round.txt:1
#, no-wrap
msgid "Instruction <code>round</code>"
msgstr ""

#. type: Source code
#: ../E/round.txt:3
#, no-wrap
msgid "<c/>round ( value );<n/>"
msgstr ""

#. type: Plain text
#: ../E/round.txt:4
#, no-wrap
msgid "Rounds a number."
msgstr ""

#. type: Plain text
#: ../E/round.txt:10
#, no-wrap
msgid "Rounded <code>value</code>. For example, <code>round(2.5)</code> is <code>3.0</code>, whereas <code>round(2.4)</code> is <code>2.0</code>."
msgstr ""

#. type: Plain text
#: ../E/round.txt:13
#, no-wrap
msgid "<a cbot|trunc>trunc</a>, <a cbot|floor>floor</a>, <a cbot|ceil>ceil</a>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|expr>expressions</a>."
msgstr ""

#. type: Plain text
#: ../E/search.txt:5
#, no-wrap
msgid "Detects the object of the given category that is closest to the given position. Similar to <c/><a cbot|radar>radar();</a><n/>, but can search starting from the specific point instead of the actual bot's position."
msgstr ""

#. type: Bullet: 'o'
#: ../E/search.txt:8
#, no-wrap
msgid "<a cbot|category>Category</a> of the objects that should be detected. For example, when you are looking for an ant, write <code>search(AlienAnt)</code>. "
msgstr ""

#. type: Bullet: 'o'
#: ../E/search.txt:9
#, no-wrap
msgid "<a cbot|array>Array</a> of categories of the objects that should be detected. For example, when you are looking only for grabbers, starting from a certain point in the level:"
msgstr ""

#. type: Source code
#: ../E/search.txt:11
#, no-wrap
msgid ""
"bots[0] = WheeledGrabber;\n"
"bots[1] = TrackedGrabber;\n"
"bots[2] = WingedGrabber;\n"
"bots[3] = LeggedGrabber;\n"
"point p(50, 24, 0);\n"
"object grabberNearestThePoint = search(bots, p);<n/>"
msgstr ""

#. type: \t; header
#: ../E/search.txt:19
#, no-wrap
msgid "position: <code><a cbot|point>point</a></code> (default value: <code><a cbot|this>this</a>.<a cbot|object>position</a></code>)"
msgstr ""

#. type: \b; header
#: ../E/sin.txt:1
#, no-wrap
msgid "Instruction <code>sin</code>"
msgstr ""

#. type: Source code
#: ../E/sin.txt:3
#, no-wrap
msgid "<c/>sin ( angle );<n/>"
msgstr ""

#. type: Plain text
#: ../E/sin.txt:9
#, no-wrap
msgid "Sine of the angle."
msgstr ""

#. type: \b; header
#: ../E/sqrt.txt:1
#, no-wrap
msgid "Instruction <code>sqrt</code>"
msgstr ""

#. type: Source code
#: ../E/sqrt.txt:3
#, no-wrap
msgid "<c/>sqrt ( value );<n/>"
msgstr ""

#. type: Plain text
#: ../E/sqrt.txt:6
#, no-wrap
msgid "Non-negative number."
msgstr ""

#. type: Plain text
#: ../E/sqrt.txt:9
#, no-wrap
msgid "Square root of the value."
msgstr ""

#. type: \b; header
#: ../E/switch.txt:1
#, no-wrap
msgid "Instructions <code>switch</code>, <code>case</code> and <code>default</code>"
msgstr ""

#. type: Plain text
#: ../E/switch.txt:2
#, no-wrap
msgid "With the instruction <code>switch() {}</code> you can execute a proper set of instructions (a case) basing on some value."
msgstr ""

#. type: Plain text
#: ../E/switch.txt:7
#, no-wrap
msgid "See the following <a cbot|function>function</a>: the bot will be <a cbot|wait>waiting</a> a proper amount of time for a certain task to be completed:"
msgstr ""

#. type: Source code
#: ../E/switch.txt:9
#, no-wrap
msgid ""
"public void WaitForTaskCompleted(object building)\n"
"{\n"
"\tint cat = building.category;\n"
"\t<a cbot|if>if</a> (cat == Converter) wait(15);\n"
"\telse if (cat == BotFactory) wait(15);\n"
"\telse if (cat == PowerPlant) wait(12);\n"
"\telse message(\"Undefined wait time\", DisplayError);\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/switch.txt:18
#, no-wrap
msgid "This function can be also written using the <code>switch() {}</code> instruction:"
msgstr ""

#. type: Source code
#: ../E/switch.txt:20
#, no-wrap
msgid ""
"public void WaitForTaskCompleted(object building)\n"
"{\n"
"\tswitch (building.category)\n"
"\t{\n"
"\t\tcase Converter: wait(15); break;\n"
"\t\tcase BotFactory: wait(15); break;\n"
"\t\tcase PowerPlant: wait(12); break;\n"
"\t\tdefault: message(\"Undefined wait time\", DisplayError);\n"
"\t}\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/switch.txt:31
#, no-wrap
msgid "Which way to write this kind of choice structures, is a matter of taste."
msgstr ""

#. type: Plain text
#: ../E/switch.txt:33
#, no-wrap
msgid "You can also make cases like this:"
msgstr ""

#. type: Source code
#: ../E/switch.txt:35
#, no-wrap
msgid ""
"switch (building.category)\n"
"{\n"
"\tcase Converter:\n"
"\tcase BotFactory:\n"
"\t\twait(15); break;\n"
"\tcase PowerPlant: wait(12); break;\n"
"\tdefault: message(\"Undefined wait time\", DisplayError);\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/switch.txt:44
#, no-wrap
msgid "<a object|convert>Converter</a> and <a object|factory>bot factory</a> have the same waiting time, so in order to not write the same instructions twice, we made multiple cases run the same code. In fact, all code after the highest case used will be executed if we do not <code><a cbot|break>break</a></code> it."
msgstr ""

#. type: Source code
#: ../E/switch.txt:48
#, no-wrap
msgid ""
"<c/>switch ( value )\n"
"{\n"
"\tcase value1: instructions1\n"
"\tcase value2: instructions2\n"
"\t...\n"
"\tcase valueN: instructionsN\n"
"\tdefault: instructionsDefault\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/switch.txt:57
#, no-wrap
msgid "With this conditional structure you can execute <code>instructions1</code> or <code>instructions2</code> ... or <code>instructionsN</code> or <code>instructionsDefault</code> depending on the <code>value</code>."
msgstr ""

#. type: Plain text
#: ../E/switch.txt:59
#, no-wrap
msgid ""
"If the <code>value</code> is equal to <code>value1</code>, <code>instructions1</code> to <code>N</code> (including <code>instructionsDefault</code>) are executed.\n"
"If the <code>value</code> is equal to <code>value2</code>, <code>instructions2</code> to <code>N</code> (including <code>instructionsDefault</code>) are executed.\n"
"And so on.\n"
"If the <code>value</code> is equal to <code>valueN</code>, <code>instructionsN</code> and <code>instructionsDefault</code> are executed.\n"
"If the <code>value</code> is not equal to any value in the given cases, <code>instructionsDefault</code> are executed."
msgstr ""

#. type: Plain text
#: ../E/switch.txt:65
#, no-wrap
msgid "You can exit from the the <code>switch() {}</code> instruction using <code><a cbot|break>break</a></code>."
msgstr ""

#. type: Plain text
#: ../E/switch.txt:68
#, no-wrap
msgid "Do not put a <a cbot|term>semicolon</a> at the end of the <code>switch ( ) { }</code> instruction."
msgstr ""

#. type: \b; header
#: ../E/takeoff.txt:1
#, no-wrap
msgid "Instruction <code>takeoff</code>"
msgstr ""

#. type: Plain text
#: ../E/takeoff.txt:11
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <code>takeoff()</code>.\n"
"<code>== 0 </code>Spaceship takes off\n"
"<code>!= 0 </code>Spaceship could not take off (e.g. mission is not finished yet)"
msgstr ""

#. type: \b; header
#: ../E/tan.txt:1
#, no-wrap
msgid "Instruction <code>tan</code>"
msgstr ""

#. type: Source code
#: ../E/tan.txt:3
#, no-wrap
msgid "<c/>tan ( angle );<n/>"
msgstr ""

#. type: Plain text
#: ../E/tan.txt:6
#, no-wrap
msgid "Angle in degrees (except multiples of 90)."
msgstr ""

#. type: Plain text
#: ../E/tan.txt:9
#, no-wrap
msgid "Tangent of the angle."
msgstr ""

#. type: \b; header
#: ../E/trunc.txt:1
#, no-wrap
msgid "Instruction <code>trunc</code>"
msgstr ""

#. type: Source code
#: ../E/trunc.txt:3
#, no-wrap
msgid "<c/>trunc ( value );<n/>"
msgstr ""

#. type: Plain text
#: ../E/trunc.txt:4
#, no-wrap
msgid "Truncation is a method of approximating a decimal number by dropping all decimal places past a certain point without rounding. For positive numbers, it works like the <c/><a cbot|floor>floor();</a><n/> function, and for negative numbers, it works like the <c/><a cbot|ceil>ceil();</a><n/> function. It can be said that it rounds towards zero."
msgstr ""

#. type: Plain text
#: ../E/trunc.txt:10
#, no-wrap
msgid "Truncated <code>value</code>. For example, <code>trunc(-2.5)</code> is <code>-2.00</code>."
msgstr ""

#. type: Plain text
#: ../E/category.txt:4
#, no-wrap
msgid "In a program, categories are always displayed like that: <format const>category</format>. If a category isn't highlighted, it is misspelled. Caps and lower cases should be kept as is."
msgstr ""

#. type: Plain text
#: ../E/type.txt:9
#, no-wrap
msgid "In a program, the name of a type is always displayed like that: <format type>type</format>. If the name of a type is not highlighted, this means that the name is misspelled. Type names are always written with lower case characters. Here is a list of the different types: "
msgstr ""

#. type: \b; header
#: ../E/produce.txt:1
#, no-wrap
msgid "Instruction <code>produce</code>"
msgstr ""

#. type: Source code
#: ../E/produce.txt:3
#, no-wrap
msgid "<c/>produce ( position, orientation, category, program, power );<n/>"
msgstr ""

#. type: Bullet: 'o'
#: ../E/produce.txt:4
#, no-wrap
msgid "r"
msgstr ""

#. type: Source code
#: ../E/produce.txt:5
#, no-wrap
msgid "<c/>produce ( category, power );<n/>"
msgstr ""

#. type: Plain text
#: ../E/produce.txt:7
#, no-wrap
msgid "Immediately creates an <a cbot|category>object</a>."
msgstr ""

#. type: \t; header
#: ../E/produce.txt:12
#, no-wrap
msgid "orientation: <code><a cbot|float>float</a></code>"
msgstr ""

#. type: Plain text
#: ../E/produce.txt:13
#, no-wrap
msgid "Orientation (angle) of the object."
msgstr ""

#. type: Plain text
#: ../E/produce.txt:16
#, no-wrap
msgid "<a cbot|category>Category</a> of the object."
msgstr ""

#. type: \t; header
#: ../E/produce.txt:18
#, no-wrap
msgid "program: <code><a cbot|string>string</a></code>"
msgstr ""

#. type: Plain text
#: ../E/produce.txt:22
#, no-wrap
msgid "Energy level."
msgstr ""

#. type: \t; header
#: ../E/produce.txt:24
#, no-wrap
msgid "Return: <code><a cbot|void>void</a></code>"
msgstr ""

#. type: Plain text
#: ../E/produce.txt:25
#, no-wrap
msgid "Nothing."
msgstr ""

#. type: \b; header
#: ../E/produce.txt:27
#, no-wrap
msgid "Example usage"
msgstr ""

#. type: Plain text
#: ../E/produce.txt:28
#, no-wrap
msgid "It is used by <a object|mother>AlienQueen</a> to produce <a object|egg>AlienEggs</a>."
msgstr ""

#. type: Plain text
#: ../E/produce.txt:10
#, no-wrap
msgid "Where object will be created. The second syntax creates the object at the current bot's position."
msgstr ""

#. type: Plain text
#: ../E/produce.txt:19
#, no-wrap
msgid "Program for the object. Will have effect only for programmable objects like robots or aliens."
msgstr ""

#. type: Plain text
#: ../E/expr.txt:2
#, no-wrap
msgid "Expressions are used for various calculations with many different variables, which return the desired result. What distinguishes them from standard instructions are operators, which are described below."
msgstr ""

#. type: \b; header
#: ../E/expr.txt:8
#, no-wrap
msgid "Binary operations"
msgstr ""

#. type: Plain text
#: ../E/expr.txt:9
#, no-wrap
msgid "Assuming that <code>a</code>, <code>b</code> can be values of declared and initialized variables of types <code>t1</code> and <code>t2</code>, the binary operations can be described as follows:"
msgstr ""

#. type: Source code
#: ../E/expr.txt:10
#, no-wrap
msgid "<code>r = a op b</code>"
msgstr ""

#. type: Plain text
#: ../E/expr.txt:11
#, no-wrap
msgid "Where <code>r</code> is the result of the operation and <code>op</code> is a binary operator which works with values of types <code>t1</code> and <code>t2</code>."
msgstr ""

#. type: \t; header
#: ../E/expr.txt:13
#, no-wrap
msgid "Order of operations"
msgstr ""

#. type: Plain text
#: ../E/expr.txt:14
#, no-wrap
msgid "Let <code>a op1 b op2 c</code> be a legal expression, then the following rules apply:"
msgstr ""

#. type: Bullet: 'o'
#: ../E/expr.txt:15
#, no-wrap
msgid "If <code>op1 == op2</code> or <code>op1</code> is as strong as <code>op2</code> or <code>op1</code> is stronger than <code>op2</code>, first calculate <code>a op1 b</code> and store its result in a temporary variable <code>r</code>, then calculate <code>r op2 c</code>, which is the final result of the expression."
msgstr ""

#. type: Bullet: 'o'
#: ../E/expr.txt:16
#, no-wrap
msgid "If <code>op1</code> is weaker than <code>op2</code>, first calculate <code>b op2 c</code> and store its result in a temporary variable <code>r</code>, then calculate <code>a op1 r</code>, which is the final result of the expression."
msgstr ""

#. type: Plain text
#: ../E/expr.txt:18
#, no-wrap
msgid "Note: an operation can be made stronger by surrounding it in brackets, so for example assuming that <code>op1</code> is weaker than <code>op2</code>, in an expression <code>(a op1 b) op2 c</code> the <code>a op1 b</code> operation will be executed first."
msgstr ""

#. type: Plain text
#: ../E/expr.txt:20
#, no-wrap
msgid "Tip: always use brackets if you are not sure about the order of operations, do not try to remember how strong are each of the operators. Generally it should be fairly obvious."
msgstr ""

#. type: Plain text
#: ../E/expr.txt:22
#, no-wrap
msgid ""
"Here is a complicated example, which uses arithemtic operations described below, showing how expressions are calculated:\n"
"<c/>Assume a, b, c, d, x, y, z, e are all initialized variables of type float or int. Then the following expression should be calculated the following way:\n"
"  a * b + c - d / x % (y * z) - e =\n"
"= r1 + c - d / x % (y * z) - e    = , r1 = a * b\n"
"= r2 - d / x % (y * z) - e        = , r2 = r1 + c\n"
"= r2 - r3 % (y * z) - e           = , r3 = d / x\n"
"= r2 - r3 % r4 - e                = , r4 = y * z\n"
"= r2 - r5 - e                     = , r5 = r3 % r4\n"
"= r6 - e                          = , r6 = r2 - r5\n"
"= r7                                , r7 = r6 - e\n"
"r7 is the final result of this expression."
msgstr ""

#. type: \b; header
#: ../E/expr.txt:35
#, no-wrap
msgid "Assignment operator"
msgstr ""

#. type: Plain text
#: ../E/expr.txt:36
#, no-wrap
msgid "<code>=</code> is the assignment operator. It is used to store the result of an expression in a variable."
msgstr ""

#. type: Plain text
#: ../E/expr.txt:38
#, no-wrap
msgid "On the left side of this operator there must be so called l-value and on the right side - r-value. L-values are just <a cbot|var>variables</a><n/>, r-values are expressions or just usual values. This makes the assignment operator kind of special, because what is l-value is pretty restrictive (it cannot be an expression, constant and so on, only single variable). Also, the type of l-value must match the type of r-value (unless a conversion is possible, for example assigning a <code><a cbot|float>float</a></code> to <code><a cbot|int>int</a></code>)."
msgstr ""

#. type: Source code
#: ../E/expr.txt:42
#, no-wrap
msgid ""
" float a;\n"
" float b = 2.0 * (a = 4.0); // b == 8.0"
msgstr ""

#. type: Plain text
#: ../E/expr.txt:45
#, no-wrap
msgid "This example is actually really confusing, but this property is actually useful, because it lets doing something like this:"
msgstr ""

#. type: Source code
#: ../E/expr.txt:47
#, no-wrap
msgid ""
" float a, b, c, d, e;\n"
" a = b = c = d = e = 1.0; // a == b == c == d == e == 1.0"
msgstr ""

#. type: \b; header
#: ../E/expr.txt:50
#, no-wrap
msgid "Basic arithmetic operations"
msgstr ""

#. type: Plain text
#: ../E/expr.txt:51
#, no-wrap
msgid "Binary operators below are working with fundamental number types (<code><a cbot|int>int</a></code>, <code><a cbot|float>float</a></code>)."
msgstr ""

#. type: \t; header
#: ../E/expr.txt:53 ../E/expr.txt:90 ../E/expr.txt:116 ../E/expr.txt:141 ../E/expr.txt:164
#, no-wrap
msgid "List"
msgstr ""

#. type: \t; header
#: ../E/expr.txt:60
#, no-wrap
msgid "Notes"
msgstr ""

#. type: Bullet: 'o'
#: ../E/expr.txt:61
#, no-wrap
msgid "The <code>*</code>, <code>/</code>, <code>%</code> are all stronger than <code>+</code> and <code>-</code>."
msgstr ""

#. type: Bullet: 'o'
#: ../E/expr.txt:62
#, no-wrap
msgid "The result <a cbot|type>type</a> is always <code><a cbot|float>float</a></code>. If <code>a</code> or <code>b</code> are of type <code><a cbot|int>int</a></code>, they are automatically converted to <code><a cbot|float>float</a></code>. Note: this means that results of intermediate calculations tends to be as precise as possible, the precision is lost only during converting the final (<code><a cbot|float>float</a></code>) result to <code><a cbot|int>int</a></code>, for example by the assignment <code>=</code> operator."
msgstr ""

#. type: \t; header
#: ../E/expr.txt:64
#, no-wrap
msgid "Real life examples"
msgstr ""

#. type: \t; header
#: ../E/expr.txt:82
#, no-wrap
msgid "Compound assignment operators"
msgstr ""

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

#. type: Plain text
#: ../E/expr.txt:85
#, no-wrap
msgid "The compound-assignment operators combine the <code>=</code> assignment operator with another binary operator such as <code>+</code> or <code>-</code>. Compound-assignment operators perform the operation specified by the additional operator and then assign the result to the left operand. For example, a compound-assignment expression such as"
msgstr ""

#. type: Source code
#: ../E/expr.txt:86
#, no-wrap
msgid "<code>lvalue += expression</code>"
msgstr ""

#. type: Source code
#: ../E/expr.txt:88
#, no-wrap
msgid "<code>lvalue = lvalue + expression</code>"
msgstr ""

#. type: \b; header
#: ../E/expr.txt:97
#, no-wrap
msgid "String concatenation"
msgstr ""

#. type: Plain text
#: ../E/expr.txt:98
#, no-wrap
msgid "If at least one of the values used with the <code>+</code> operator is a <a cbot|string>string</a>, then the operation of concatenation is performed. The result of the operator is then a string, which is created by joining end-to-end the string and the other value. If the other value is not a string, then it is converted to string beforehand."
msgstr ""

#. type: Source code
#: ../E/expr.txt:102
#, no-wrap
msgid ""
"\tstring s = \"a\" + \"bc\";  // returns \"abc\"\n"
"\tstring s = 1 + \"bc\";    // returns \"1bc\"\n"
"\tstring s = 2.5 + \"bc\";  // returns \"2.5bc\"\n"
"\tstring s = \"a\" + true;  // returns \"atrue\""
msgstr ""

#. type: Plain text
#: ../E/expr.txt:107
#, no-wrap
msgid "Tip: the properties of the concatenation <code>+</code> operator is useful with the <a cbot|message>message();</a> function, because it does not work with other types than string. An empty string can be used together with a value in order to create a string, which actually can be passed to the <a cbot|message>message();</a> function:"
msgstr ""

#. type: \b; header
#: ../E/expr.txt:178
#, no-wrap
msgid "Prefix and postfix increment- and decrement operators"
msgstr ""

#. type: Plain text
#: ../E/expr.txt:181
#, no-wrap
msgid "For example to increment the variable <code>a</code> you can write"
msgstr ""

#. type: Source code
#: ../E/expr.txt:182
#, no-wrap
msgid "<c/>a++;<n/>"
msgstr ""

#. type: Plain text
#: ../E/expr.txt:183
#, no-wrap
msgid "instead of"
msgstr ""

#. type: Source code
#: ../E/expr.txt:184
#, no-wrap
msgid "<c/>a = a + 1;<n/>"
msgstr ""

#. type: Plain text
#: ../E/expr.txt:186
#, no-wrap
msgid "The result of the operation <code>a++</code> is the value of the variable <code>a</code> *before* the increment. If you use the prefix operator <code>++a</code> the result of the operation is the value of the variable <code>a</code> *after* the increment. The same holds for the <code>--</code> decrement operator."
msgstr ""

#. type: Plain text
#: ../E/expr.txt:4
#, no-wrap
msgid "Specifically speaking, an expression is an ordered series of operations which yield a result. Operations consist of operators, which are special <a cbot|function>functions</a> <code>T f(t1 x1, t2 x2, ..., tn xn)</code>, where <code>xi</code> is a value of type <code>ti</code>, and <code>T</code> is the result type. For example, <code>float +(float a, float b)</code> returns a sum of values <code>a</code> and <code>b</code>. Note: Operators are a part of the CBOT language and they cannot be defined in program. Also, the operators cannot be used as usual <a cbot|function>functions</a>, they need to be written using a special notation depending on the operator, for example <code>a+b</code>."
msgstr ""

#. type: Plain text
#: ../E/expr.txt:6
#, no-wrap
msgid "In nearly all operations, <a cbot>constants</a>, <a cbot|var>variables</a>, <a cbot|function>functions</a> returning non-<a cbot|void>void</a> type and also other operations can be used as values."
msgstr ""

#. type: Plain text
#: ../E/expr.txt:40
#, no-wrap
msgid "Note: it may be not obvious at first, but notice that <code>=</code> is an *operator* not an instruction. This mean that it can be used in the middle of an other expression! The result of <code>=</code> is the value which was assigned to the l-value - the result of the expression on the right. Example:"
msgstr ""

#. type: Source code
#: ../E/expr.txt:109
#, no-wrap
msgid ""
" float pi = 3.14;\n"
" // message(pi); // does not work\n"
" message(\"\"+pi);"
msgstr ""

#. type: Source code
#: ../E/expr.txt:190
#, no-wrap
msgid ""
" a = 2;\n"
" b = a++;\n"
" // now b contains 2 and a contains 3"
msgstr ""

#. type: Source code
#: ../E/expr.txt:194
#, no-wrap
msgid ""
" a = 2;\n"
" b = ++a;\n"
" // now b contains 3 and a contains 3"
msgstr ""

#. type: \b; header
#: ../E/expr.txt:138
#, no-wrap
msgid "Logical operators"
msgstr ""

#. type: Plain text
#: ../E/expr.txt:139
#, no-wrap
msgid "Logical operators work with values of type <a cbot|bool>bool</a> and they always return a <a cbot|bool>bool</a>. They are mainly used in <a cbot|cond>conditions</a>."
msgstr ""

#. type: \b; header
#: ../E/expr.txt:151
#, no-wrap
msgid "Ternary operator"
msgstr ""

#. type: Plain text
#: ../E/expr.txt:152
#, no-wrap
msgid ""
"The ternary operator is nothing more than a syntax sugar. It is also known as \"inline if\". It might be confusing at first, because its syntax is a little more complicated than other operators. It can be described as follows:\n"
"<code>(condition) ? (result when true) : (result when false)</code>\n"
"Brackets are not needed."
msgstr ""

#. type: Plain text
#: ../E/expr.txt:156
#, no-wrap
msgid "Firstly, the condition is valued and then the first result is returned if the condition is true, otherwise the second result is returned."
msgstr ""

#. type: \t; header
#: ../E/expr.txt:158 ../E/extends.txt:4 ../E/extends.txt:65 ../E/private.txt:4 ../E/protected.txt:4 ../E/super.txt:4
#, no-wrap
msgid "Example"
msgstr ""

#. type: Source code
#: ../E/expr.txt:159
#, no-wrap
msgid "<c/>float c = ((3.0 > 2.0) ? 10.0 : -10.0); // c == 10.0<n/>"
msgstr ""

#. type: Plain text
#: ../E/cond.txt:2
#, no-wrap
msgid "A condition is a special <a cbot|expr>expression</a> that returns a <a cbot|bool>boolean</a> value, that can only be either <code><a cbot|true>true</a></code> or <code><a cbot|false>false</a></code>. With a condition, you can choose f. ex. if the instructions in a <code><a cbot|while>while</a></code> loop must be repeated again, or if the instruction in a <code><a cbot|if>if</a></code> bloc must be executed."
msgstr ""

#. type: \b; header
#: ../E/expr.txt:113
#, no-wrap
msgid "Comparison operators"
msgstr ""

#. type: Plain text
#: ../E/expr.txt:114
#, no-wrap
msgid "Comparison operators work with values of type <a cbot|bool>float</a> and they always return a <a cbot|bool>bool</a>. They are mainly used in <a cbot|cond>conditions</a>."
msgstr ""

#. type: Plain text
#: ../E/expr.txt:142
#, no-wrap
msgid ""
"<code>!a      </code>not <code>a</code>\n"
"<code>a && b  </code><code>a</code> and <code>b</code>\n"
"<code>a || b  </code><code>a</code> or <code>b</code>"
msgstr ""

#. type: Plain text
#: ../E/expr.txt:147
#, no-wrap
msgid ""
"<code>!false        </code>returns true\n"
"<code>true && false </code>returns false \n"
"<code>true || false </code>returns true"
msgstr ""

#. type: \b; header
#: ../E/expr.txt:161
#, no-wrap
msgid "Bitwise operators"
msgstr ""

#. type: Plain text
#: ../E/expr.txt:162
#, no-wrap
msgid "Bitwise operators are similar to the logical operator, because they are operating on bits (which can be only 0 or 1, conditions can have a value only of false or true). So in theory, they should be working with basically any type of variable, because each value in the computer must be stored as a sequence of bits."
msgstr ""

#. type: Plain text
#: ../E/expr.txt:165
#, no-wrap
msgid ""
"<code>a & b  </code><code>a</code> AND <code>b</code>\n"
"<code>a | b  </code><code>a</code> OR <code>b</code>\n"
"<code>a ^ b  </code><code>a</code> XOR <code>b</code>\n"
"<code>a >> b  </code>shift bits of <code>a</code> to the right <code>b</code> times\n"
"<code>a << b  </code>shift bits of <code>a</code> to the left <code>b</code> times"
msgstr ""

#. type: Plain text
#: ../E/expr.txt:172
#, no-wrap
msgid ""
"<code>2 & 1         </code>returns 0\n"
"<code>2 | 1         </code>returns 3\n"
"<code>2 ^ 2         </code>returns 0\n"
"<code>2 >> 1        </code>returns 1\n"
"<code>2 << 1        </code>returns 4"
msgstr ""

#. type: Source code
#: ../E/array.txt:4
#, no-wrap
msgid ""
"int    [ ] a;   // an array of int\n"
"int    a [12];  // an array of int limited to 12 elements\n"
"string s[3];    // an array of 3 strings\n"
"float  xy[][];  // a 2 dimensionnal array of floats"
msgstr ""

#. type: \b; header
#: ../E/array.txt:30
#, no-wrap
msgid "Initialization syntax"
msgstr ""

#. type: Plain text
#: ../E/array.txt:31
#, no-wrap
msgid "You can initialize a new array using the following syntax:"
msgstr ""

#. type: Source code
#: ../E/array.txt:33
#, no-wrap
msgid "type arrayName[] = { value0, value1, value2, ..., valueN };"
msgstr ""

#. type: Source code
#: ../E/array.txt:37
#, no-wrap
msgid ""
"int numbers[] = { 10, 20, 30 };\n"
"MyClass objects[] = { new MyClass(1), new MyClass(2) };"
msgstr ""

#. type: Plain text
#: ../E/radar.txt:2
#, no-wrap
msgid "With the instruction <c/>radar();<n/>, you can look for objects like <a object|mother>enemies</a>, bots, buildings or raw materials."
msgstr ""

#. type: Plain text
#: ../E/radar.txt:81
#, no-wrap
msgid "<c/><a cbot|radarall>radarall</a>();<n/>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/radarall.txt:1
#, no-wrap
msgid "Instruction <code>radarall</code>"
msgstr ""

#. type: Plain text
#: ../E/radarall.txt:2
#, no-wrap
msgid "<c/>radarall();<n/> is an enhancement of the <c/><a cbot|radar>radar</a>();<n/> function -- it detects all objects matching the given criteria."
msgstr ""

#. type: \b; header
#: ../E/radarall.txt:4
#, no-wrap
msgid "Example<c/>"
msgstr ""

#. type: Source code
#: ../E/radarall.txt:13
#, no-wrap
msgid "<c/>radarall ( cat, angle, focus, min, max, sens, filter );<n/>"
msgstr ""

#. type: Plain text
#: ../E/radarall.txt:15
#, no-wrap
msgid "The function works generally the same as the <c/><a cbot|radar>radar</a>();<n/> function with the only difference being that it returns an <a cbot|array>array</a> of <a cbot|object>objects</a> instead of one object. If no object is found, <code><a cbot|null>null</a></code> is returned."
msgstr ""

#. type: Plain text
#: ../E/radarall.txt:17
#, no-wrap
msgid "The order of objects in the returned array is sorted by distance and depends on the <code>sens</code> parameter. The first object in the array is the object which would be returned by the <c/>radar();<n/> function called with the exactly same parameters."
msgstr ""

#. type: Plain text
#: ../E/radarall.txt:20
#, no-wrap
msgid "<c/><a cbot|radar>radar</a>();<n/>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: Plain text
#: ../E/for.txt:11
#, no-wrap
msgid "This set of instructions is executed before the first loop instance."
msgstr ""

#. type: Plain text
#: ../E/for.txt:17
#, no-wrap
msgid "This set of instructions is executed at the end of every instance of the loop. "
msgstr ""

#. type: \t; header
#: ../E/for.txt:38
#, no-wrap
msgid "Executing more instructions"
msgstr ""

#. type: Plain text
#: ../E/for.txt:39
#, no-wrap
msgid "In the <code>before</code> and <code>end</code> part of a <code>for</code> loop you can specify more than one instruction by using comma. Example:"
msgstr ""

#. type: Source code
#: ../E/for.txt:41
#, no-wrap
msgid ""
"int i = 0;\n"
"int j;\n"
"for (i++, j = 2; i < 3 && j > 0; i++, j--)\n"
"{\n"
"    message(i);\n"
"    message(j);\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/for.txt:49
#, no-wrap
msgid "The output of the above code is <code>1 2 2 1</code>."
msgstr ""

#. type: Source code
#: ../E/radarall.txt:5
#, no-wrap
msgid ""
"object[] items = radarall(PowerCell);\n"
"for (int i = 0; i < sizeof(items); ++i)\n"
"{\n"
"    message(items[i].id);\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/category.txt:108
#, no-wrap
msgid ""
"       <code><a object|flag>BlueFlag</a>          </code>Blue Flag\n"
"       <code><a object|flag>RedFlag</a>           </code>Red Flag\n"
"       <code><a object|flag>GreenFlag</a>         </code>Green Flag\n"
"       <code><a object|flag>YellowFlag</a>        </code>Yellow Flag\n"
"       <code><a object|flag>VioletFlag</a>        </code>Violet Flag\n"
"       <code><a object|waypoint>WayPoint</a>          </code>Checkpoint\n"
"       <code><a object|target2>Target2</a>           </code>Flying checkpoint\n"
"       <code><a object|enerspot>PowerSpot</a>        </code>Underground Energy Deposit\n"
"       <code><a object|stonspot>TitaniumSpot</a>      </code>Underground Titanium Deposit\n"
"       <code><a object|uranspot>UraniumSpot</a>       </code>Underground Uranium Deposit"
msgstr ""

#. type: Plain text
#: ../E/category.txt:10
#, no-wrap
msgid ""
"<button 176/>   <code><a object|huston>Houston</a>          </code>Mission Control\n"
"<button 171/>   <code><a object|base>SpaceShip</a>        </code>Spaceship\n"
"<button 160/>   <code><a object|factory>BotFactory</a>       </code>Robot Factory\n"
"<button 163/>   <code><a object|research>ResearchCenter</a>   </code>Research Center\n"
"<button 168/>   <code><a object|radar>RadarStation</a>     </code>Radar\n"
"<button 172/>   <code><a object|exchange>ExchangePost</a>     </code>Information Exchange Post\n"
"<button 169/>   <code><a object|repair>RepairCenter</a>     </code>Repair Center\n"
"<button 165/>   <code><a object|tower>DefenseTower</a>     </code>Defense Tower\n"
"<button 166/>   <code><a object|labo>AutoLab</a>          </code>Organic Matter Analyzer \n"
"<button 164/>   <code><a object|station>PowerStation</a>     </code>Power Station\n"
"<button 167/>   <code><a object|energy>PowerPlant</a>       </code>Power Cell Factory\n"
"<button 170/>   <code><a object|nuclear>NuclearPlant</a>     </code>Nuclear Plant\n"
"<button 162/>   <code><a object|convert>Converter</a>        </code>Titanium Converter\n"
"<button 161/>   <code><a object|derrick>Derrick</a>          </code>Derrick\n"
"<button 174/>   <code><a object|captor>PowerCaptor</a>      </code>Parabolic Lightning Conductor\n"
"<button 175/>   <code><a object|safe>Vault</a>            </code>Vault\n"
"       <code><a object|start>StartArea</a>        </code>Starting Pad\n"
"       <code><a object|goal>GoalArea</a>         </code>Finishing Pad\n"
"       <code><a object|target1>Target1</a>          </code>Flying target\n"
"       <code><a object|nest>AlienNest</a>        </code>Alien Nest"
msgstr ""

#. type: Plain text
#: ../E/class.txt:10
#, no-wrap
msgid "Classes can be only <a cbot|public>public</a>. This means that they can be used by all bots in a mission."
msgstr ""

#. type: \b; header
#: ../E/class.txt:12
#, no-wrap
msgid "Class Members"
msgstr ""

#. type: Plain text
#: ../E/class.txt:13
#, no-wrap
msgid "Class members are fields (<a cbot|var>variables</a>) and methods (<a cbot|function>functions</a>)."
msgstr ""

#. type: Plain text
#: ../E/class.txt:15
#, no-wrap
msgid "For example, the following class dubbed <code>MyClass</code> contains 4 fields (<code>a</code>, <code>b</code>, <code>x</code> and <code>s</code>) and one method (<code>MyFunction</code>)."
msgstr ""

#. type: Source code
#: ../E/class.txt:17
#, no-wrap
msgid ""
"public class MyClass\n"
"{\n"
"\tint     a, b;\n"
"\tfloat   x = 3.33;\n"
"\tstring  s = \"hello\";\n"
"\tfloat   MyFunction(float value)\n"
"\t{\n"
"\t\treturn (value * x) - 1;\n"
"\t}\n"
"}"
msgstr ""

#. type: \t; header
#: ../E/class.txt:55
#, no-wrap
msgid "Member Initialization"
msgstr ""

#. type: Plain text
#: ../E/class.txt:60
#, no-wrap
msgid "Example:<c/>"
msgstr ""

#. type: Source code
#: ../E/class.txt:61
#, no-wrap
msgid ""
"public class MyClass\n"
"{\n"
"\tint  a, b;\n"
"\tvoid MyClass()\n"
"\t{\n"
"\t\ta = 2;  b = 3;\n"
"\t}\n"
"\tvoid MyClass(int a, int b)\n"
"\t{\n"
"\t\tthis.a = a;  this.b = b;\n"
"\t}\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/class.txt:76
#, no-wrap
msgid "As the names of the parameters of the second constructor are the same as the names of the two members <code>a</code> and <code>b</code>, we must use the <code><a cbot|this>this</a></code> <a cbot|pointer>reference</a> to avoid confusion with the parameters' names."
msgstr ""

#. type: \b; header
#: ../E/class.txt:78
#, no-wrap
msgid "Object Creation"
msgstr ""

#. type: Plain text
#: ../E/class.txt:79
#, no-wrap
msgid "You can create objects of type <code>YourClass</code> using the <code><a cbot|new>new</a></code> keyword. Example:"
msgstr ""

#. type: \b; header
#: ../E/class.txt:90
#, no-wrap
msgid "Object Destruction"
msgstr ""

#. type: \b; header
#: ../E/class.txt:114
#, no-wrap
msgid "Passing Objects to Functions"
msgstr ""

#. type: Plain text
#: ../E/class.txt:115
#, no-wrap
msgid "Objects in CBOT are passed by <a cbot|pointer>reference</a>. This means that when an object is passed to a <a cbot|function>function</a>, the function receives a copy of a pointer to the instance, not a copy of the object, so any modifications on the object will be visible outside of the function."
msgstr ""

#. type: \b; header
#: ../E/class.txt:117
#, no-wrap
msgid "Inheritance"
msgstr ""

#. type: Plain text
#: ../E/class.txt:118
#, no-wrap
msgid "A class can inherit public and protected members of another class by using the <code><a cbot|extends>extends</a></code> keyword."
msgstr ""

#. type: Plain text
#: ../E/class.txt:2
#, no-wrap
msgid "This keyword allows you to create a class definition by using the following syntax:"
msgstr ""

#. type: \t; header
#: ../E/class.txt:9
#, no-wrap
msgid "All Classes Are Public"
msgstr ""

#. type: \t; header
#: ../E/class.txt:52
#, no-wrap
msgid "Class Members Modifiers"
msgstr ""

#. type: \t; header
#: ../E/class.txt:75
#, no-wrap
msgid "Using <code><a cbot|this>this</a></code>"
msgstr ""

#. type: Source code
#: ../E/class.txt:81
#, no-wrap
msgid ""
"extern void object::Test()\n"
"{\n"
"\tMyClass object1();       // Call default constructor (without parameters)\n"
"\tMyClass object2(4, 5);   // Call constructor with two int parameters\n"
"\tMyClass object3;         // No constructor called, object3 == null\n"
"\tobject3 = new MyClass(); // We call constructor now, object3 != null\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/class.txt:91
#, no-wrap
msgid "You can also define a destructor. This must be a <code><a cbot|void>void</a></code> fonction without parameters, which has the same name as the class but prefixed with the <code>~</code> character. The destructor is called automatically as soon as the class instance is no more referenced by anyone. Example:"
msgstr ""

#. type: Source code
#: ../E/class.txt:93
#, no-wrap
msgid ""
"public class MyClass\n"
"{\n"
"\tstatic private int counter = 0; // instance counter\n"
"\tvoid  MyClass( )\n"
"\t{\n"
"\t\tcounter++;  // one instance more\n"
"\t}\n"
"\tvoid ~MyClass( )\n"
"\t{\n"
"\t\tcounter--;  // one instance less\n"
"\t}\n"
"}\n"
"extern void object::Test()\n"
"{\n"
"\t                   // counter == 0\n"
"\tMyClass item1( );  // counter == 1\n"
"\tMyClass item2( );  // counter == 2\n"
"\titem1 = null;      // counter == 1\n"
"}\n"
"// counter == 0"
msgstr ""

#. type: \b; header
#: ../E/class.txt:28
#, no-wrap
msgid "Accessing Class Members"
msgstr ""

#. type: Plain text
#: ../E/class.txt:29
#, no-wrap
msgid "Class members can be accessed outside of the class definition by using the <code>.</code> operator. Example:"
msgstr ""

#. type: Plain text
#: ../E/class.txt:50
#, no-wrap
msgid "Class members are <a cbot|public>public</a> by default, which means that they are accessible outside of the class definition. They can also be declared as <code><a cbot|private>private</a></code> or <code><a cbot|protected>protected</a></code>. Such members can only be accessed inside of the class definition."
msgstr ""

#. type: Plain text
#: ../E/class.txt:53
#, no-wrap
msgid "Fields and methods can also be declared as <code><a cbot|static>static</a></code>. Methods can be additionaly declared as <code><a cbot|synchro>synchronized</a></code>."
msgstr ""

#. type: Plain text
#: ../E/class.txt:58
#, no-wrap
msgid "Another way of initiliazing fields is by defining a constructor which is a special method having the same name as the class. This method will be called automatically at <a cbot|new>creation</a> time of a class instance. Constructors can be <a cbot|function>overloaded</a>."
msgstr ""

#. type: Source code
#: ../E/class.txt:31
#, no-wrap
msgid ""
"public class MyClass\n"
"{\n"
"\tint myField = 0;\n"
"\tint MyFunction()\n"
"\t{\n"
"\t\treturn myField * 2;\n"
"\t}\n"
"}\n"
"\n"
"extern void object::Test()\n"
"{\n"
"\tMyClass myObject();\n"
"\tmyObject.myField = 10;\n"
"\tmessage(myObject.MyFunction()); // 20\n"
"\tMyClass mySecondObject();\n"
"\tmySecondObject.myField = myObject.myField - 2;\n"
"\tmessage(mySecondObject.MyFunction()); // 16\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/class.txt:121
#, no-wrap
msgid ""
"<code><a cbot|public>public</a></code>, <code><a cbot|private>private</a></code>, <code><a cbot|protected>protected</a></code>, <code><a cbot|static>static</a></code>, <code><a cbot|synchro>synchronized</a></code>, <code><a cbot|new>new</a></code>, <code><a cbot|pointer>reference</a></code>, <code><a cbot|this>this</a></code>, <code><a cbot|super>super</a></code>, <code><a cbot|extends>extends</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/protected.txt:1
#, no-wrap
msgid "Keyword <code>protected</code>"
msgstr ""

#. type: Plain text
#: ../E/protected.txt:2
#, no-wrap
msgid "This is an access modifier for <a cbot|class>class</a> members. Protected class members can be accessed in a child class, but they can't be accessed outside of classes definitions being part of the same inheritance tree (see the <code><a cbot|extends>extends</a></code> keyword)."
msgstr ""

#. type: Source code
#: ../E/protected.txt:6
#, no-wrap
msgid ""
"public class Parent\n"
"{\n"
"\tprotected int field = 0;\n"
"}\n"
"\n"
"public class Child extends Parent\n"
"{\n"
"\tvoid Print()\n"
"\t{\n"
"\t\tmessage(field);\n"
"\t}\n"
"}\n"
"\n"
"extern void object::Test()\n"
"{\n"
"\tChild child();\n"
"\tchild.Print(); // 0\n"
"\t//child.field = 1; // Error!\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/private.txt:2
#, no-wrap
msgid "This is an access modifier for <a cbot|class>class</a> members. Private members are not accessible outside of the class definition."
msgstr ""

#. type: Plain text
#: ../E/private.txt:20
#, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>, <code><a cbot|public>public</a></code>, <code><a cbot|protected>protected</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: Plain text
#: ../E/public.txt:34
#, no-wrap
msgid "<code>public</code> is also an access modifier for <a cbot|class>class</a> members, which is the default one. Public members can be accessed from outside of the class definition."
msgstr ""

#. type: Plain text
#: ../E/public.txt:50
#, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>, <code><a cbot|private>private</a></code>, <code><a cbot|protected>protected</a></code>, <code><a cbot|function>functions</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: Plain text
#: ../E/protected.txt:27
#, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>, <code><a cbot|public>public</a></code>, <code><a cbot|private>private</a></code>, <code><a cbot|extends>extends</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/super.txt:1
#, no-wrap
msgid "Keyword <code>super</code>"
msgstr ""

#. type: Plain text
#: ../E/super.txt:46
#, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>, <code><a cbot|this>this</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: Plain text
#: ../E/this.txt:53
#, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>, <code><a cbot|super>super</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/extends.txt:1
#, no-wrap
msgid "Keyword <code>extends</code>"
msgstr ""

#. type: \b; header
#: ../E/extends.txt:30
#, no-wrap
msgid "Inherited Members"
msgstr ""

#. type: Plain text
#: ../E/extends.txt:31
#, no-wrap
msgid "Only <code><a cbot|public>public</a></code> and <code><a cbot|protected>protected</a></code> members are inherited. <code><a cbot|private>private</a></code> members are directly inaccessible even for a child, although they can be accessed indirectly through inherited methods."
msgstr ""

#. type: Plain text
#: ../E/extends.txt:33
#, no-wrap
msgid "Constructors and destructors are not inherited, however, they can be overriden."
msgstr ""

#. type: \b; header
#: ../E/extends.txt:35
#, no-wrap
msgid "Method Overriding"
msgstr ""

#. type: Plain text
#: ../E/extends.txt:36
#, no-wrap
msgid "Inherited methods can be overriden (redefined) in the child class definition. Example:"
msgstr ""

#. type: Source code
#: ../E/extends.txt:38
#, no-wrap
msgid ""
"public class Parent\n"
"{\n"
"\tvoid foo()\n"
"\t{\n"
"\t\tmessage(\"foo\");\n"
"\t}\n"
"}\n"
"\n"
"public class Child extends Parent\n"
"{\n"
"\tvoid foo()\n"
"\t{\n"
"\t\tmessage(\"bar\");\n"
"\t}\n"
"}\n"
"\n"
"extern void object::Test()\n"
"{\n"
"\tChild child();\n"
"\tchild.foo(); // Will show \"bar\"\n"
"}"
msgstr ""

#. type: \b; header
#: ../E/extends.txt:62
#, no-wrap
msgid "Polymorphism"
msgstr ""

#. type: Plain text
#: ../E/extends.txt:63
#, no-wrap
msgid "<code><a cbot|pointer>Reference</a></code> of type Parent can point to an object of type Child. However, such a pointer can't be used to access a child member. In order to access a child member, it must be assured that the Parent reference really points to a Child object. If that's the case, it can be safely copied to a pointer of type Child, which has access to the child members."
msgstr ""

#. type: Source code
#: ../E/extends.txt:67
#, no-wrap
msgid ""
"public class Parent\n"
"{\n"
"\tvoid foo()\n"
"\t{\n"
"\t\tmessage(\"foo\");\n"
"\t}\n"
"}\n"
"\n"
"public class Child extends Parent\n"
"{\n"
"\tvoid foo()\n"
"\t{\n"
"\t\tmessage(\"bar\");\n"
"\t}\n"
"\tvoid bar()\n"
"\t{\n"
"\t\tmessage(\"foo bar\");\n"
"\t}\n"
"}\n"
"\n"
"extern void object::Test()\n"
"{\n"
"\tParent people[2];\n"
"\tpeople[0] = new Parent();\n"
"\tpeople[1] = new Child();\n"
"\tfor (int i = 0; i < 2; ++i)\n"
"\t{\n"
"\t\tpeople[i].foo();\n"
"\t}\n"
"\t//people[1].bar(); // Error\n"
"\tChild child = people[1];\n"
"\tchild.bar(); // OK\n"
"}"
msgstr ""

#. type: \b; header
#: ../E/extends.txt:102
#, no-wrap
msgid "Multiple Inheritance"
msgstr ""

#. type: Plain text
#: ../E/extends.txt:103
#, no-wrap
msgid "A child cannot have multiple parents, however, a parent can have many children."
msgstr ""

#. type: Plain text
#: ../E/extends.txt:106
#, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>, <code><a cbot|public>public</a></code>, <code><a cbot|private>private</a></code>, <code><a cbot|protected>protected</a></code>, <code><a cbot|new>new</a></code>, <code><a cbot|pointer>reference</a></code>, <code><a cbot|this>this</a></code>, <code><a cbot|super>super</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: Plain text
#: ../E/super.txt:2
#, no-wrap
msgid "This keyword is similar to <code><a cbot|this>this</a></code>, however, it grants access to methods from the parent class (see the <code><a cbot|extends>extends</a></code> keyword), which is especially useful for method overriding."
msgstr ""

#. type: Source code
#: ../E/super.txt:6
#, no-wrap
msgid ""
"public class Parent\n"
"{\n"
"\tprotected int field;\n"
"\t\n"
"\tvoid Parent()\n"
"\t{\n"
"\t\tfield = 0;\n"
"\t}\n"
"\t\n"
"\tvoid Print()\n"
"\t{\n"
"\t\tmessage(\"Parent's field: \" + field);\n"
"\t}\n"
"}\n"
"\n"
"public class Child extends Parent\n"
"{\n"
"\tprivate int childsField;\n"
"\t\n"
"\tvoid Child()\n"
"\t{\n"
"\t\tsuper.Parent();\n"
"\t\tchildsField = field + 1;\n"
"\t}\n"
"\t\n"
"\tvoid Print()\n"
"\t{\n"
"\t\tsuper.Print();\n"
"\t\tmessage(\"Child's field: \" + childsField);\n"
"\t}\n"
"}\n"
"\n"
"extern void object::Test()\n"
"{\n"
"\tChild child();\n"
"\tchild.Print(); // Will show both 0 and 1\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/extends.txt:2
#, no-wrap
msgid "This keyword is used in a <code><a cbot|class>class</a></code> definition when we want the class to inherit members from another class. The class which is extended we usually call a parent or base, the extending class we call a child."
msgstr ""

#. type: Source code
#: ../E/extends.txt:6
#, no-wrap
msgid ""
"public class Parent\n"
"{\n"
"\tvoid foo()\n"
"\t{\n"
"\t\tmessage(\"foo\");\n"
"\t}\n"
"}\n"
"\n"
"public class Child extends Parent\n"
"{\n"
"\tvoid bar()\n"
"\t{\n"
"\t\tmessage(\"bar\");\n"
"\t}\n"
"}\n"
"\n"
"extern void object::Test()\n"
"{\n"
"\tChild child();\n"
"\tchild.foo(); // Will show \"foo\"\n"
"\tchild.bar(); // Will show \"bar\"\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/extends.txt:60
#, no-wrap
msgid "A parent's method can be called inside an overriden method by using the <code><a cbot|super>super</a></code> keyword."
msgstr ""

#. type: Plain text
#: ../E/class.txt:56
#, no-wrap
msgid "As shown in the previous example, the class members can be initialized in the class definition (<c/>int x = 3.33;<n/>)."
msgstr ""

#. type: Plain text
#: ../E/open.txt:13
#, no-wrap
msgid ""
"<code>\"r\"</code> mode: open for reading.\n"
"<code>\"w\"</code> mode: open for writing.\n"
"<code>\"a\"</code> mode: open for appending."
msgstr ""

#. type: Plain text
#: ../E/openfile.txt:2
#, no-wrap
msgid "<c/>openfile();<n/> opens an text file in the files/ folder. This is not a method of the <code><a cbot|file>file</a></code> class but openfile returns a <a cbot|pointer>reference</a> to a new instance of the file class. You must supply two parameters, the filename and the opening mode."
msgstr ""

#. type: Plain text
#: ../E/openfile.txt:6
#, no-wrap
msgid ""
"<code>\"r\"</code> mode: open for reading.\n"
"<code>\"w\"</code> mode: open for writing.\n"
"<code>\"w\"</code> mode: open for appending."
msgstr ""

#. type: Plain text
#: ../E/function.txt:14
#, no-wrap
msgid "Nothing but a name can be changed in the main function. The keyword <code><a cbot|extern>extern</a></code> distinguishes the main function from others."
msgstr ""

#. type: \b; header
#: ../E/function.txt:117
#, no-wrap
msgid "Public Functions"
msgstr ""

#. type: \b; header
#: ../E/function.txt:129
#, no-wrap
msgid "Default Parameters"
msgstr ""

#. type: Plain text
#: ../E/function.txt:130
#, no-wrap
msgid "Last function parameters can have default values that can be omitted when calling."
msgstr ""

#. type: Source code
#: ../E/function.txt:132
#, no-wrap
msgid ""
"float Add(float a = 0.0, float b = 0.0)\n"
"{\n"
"\treturn a + b;\n"
"}\n"
"\n"
"// Somewhere in the main program...\n"
"Add(); // Will return 0.0\n"
"Add(2.0); // Will return 2.0\n"
"Add(2.0, 3.0); // Will return 5.0\n"
"// ..."
msgstr ""

#. type: \t; header
#: ../E/function.txt:144
#, no-wrap
msgid "Default Parameters and Overloading"
msgstr ""

#. type: Plain text
#: ../E/function.txt:145
#, no-wrap
msgid "Functions with default parameters still can be overloaded, one must only ensure that function calls are not ambiguous. For example, consider the following code:"
msgstr ""

#. type: Source code
#: ../E/function.txt:147
#, no-wrap
msgid ""
"float Add(float a = 0.0, float b = 0.0)\n"
"{\n"
"\treturn a + b;\n"
"}\n"
"\n"
"string Add(string a = \"\", string b = \"\")\n"
"{\n"
"\treturn a + b;\n"
"}\n"
"\n"
"// Somewhere in the main program...\n"
"Add(); // Compilation error: ambiguous call\n"
"Add(\"\"); // Ok\n"
"Add(0.0); // Ok\n"
"// ..."
msgstr ""

#. type: Plain text
#: ../E/function.txt:163
#, no-wrap
msgid "Note that in the above example overloading causes the first default parameter to be useless as caller needs to pass it anyway in order to distinguish the two functions."
msgstr ""

#. type: Plain text
#: ../E/category.txt:70
#, no-wrap
msgid ""
"<button 192/>   <code><a object|botbr>WheeledBuilder</a>         </code>Wheeled Builder\n"
"<button 193/>   <code><a object|botbc>TrackedBuilder</a>         </code>Tracked Builder\n"
"<button 194/>   <code><a object|botbj>WingedBuilder</a>          </code>Winged Builder\n"
"<button 195/>   <code><a object|botbs>LeggedBuilder</a>          </code>Legged Builder"
msgstr ""

#. type: Plain text
#: ../E/build.txt:2
#, no-wrap
msgid "The instruction <c/>build();<n/> instructs the bot to build a building of a given <a cbot|category>category</a>."
msgstr ""

#. type: Plain text
#: ../E/build.txt:5
#, no-wrap
msgid "Here is a program that looks for the nearest <a object|titan>titanium cube</a>, approaches it, and builds a <a object|factory>bot factory</a>."
msgstr ""

#. type: Plain text
#: ../E/build.txt:26
#, no-wrap
msgid ""
"<code><a cbot|canbuild>canbuild</a></code>, <code><a cbot|buildingenabled>buildingenabled</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: Plain text
#: ../E/buildingenabled.txt:2
#, no-wrap
msgid "The instruction <c/>buildingenabled();<n/> lets you know if a building of a given <a cbot|category>category</a> can be built during current mission."
msgstr ""

#. type: Plain text
#: ../E/buildingenabled.txt:23
#, no-wrap
msgid ""
"<code><a cbot|build>build</a></code>, <code><a cbot|canbuild>canbuild</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: Plain text
#: ../E/canbuild.txt:2
#, no-wrap
msgid "The instruction <c/>canbuild();<n/> lets you know if <a object|botbr>Builders</a>, <a object|human>Me</a> or <a object|human>Tech</a> can build a building of a given <a cbot|category>category</a>."
msgstr ""

#. type: Plain text
#: ../E/canbuild.txt:23
#, no-wrap
msgid ""
"<code><a cbot|build>build</a></code>, <code><a cbot|buildingenabled>buildingenabled</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: Plain text
#: ../E/canresearch.txt:5
#, no-wrap
msgid "Checks if a <a cbot|researches>research</a> can be done during current mission."
msgstr ""

#. type: Plain text
#: ../E/canresearch.txt:15
#, no-wrap
msgid ""
"<a cbot|researches>Research names</a>, <code><a cbot|research>research</a></code>, <code><a cbot|researched>researched</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: Source code
#: ../E/factory.txt:3
#, no-wrap
msgid "<c/>factory ( cat, program, object );<n/>"
msgstr ""

#. type: Plain text
#: ../E/factory.txt:5
#, no-wrap
msgid "Starts a construction of a bot of a given <a cbot|category>category</a> and runs a specified program on it after the construction is finished."
msgstr ""

#. type: Plain text
#: ../E/factory.txt:14
#, no-wrap
msgid "<a object|factory>BotFactory</a>, nearest by default."
msgstr ""

#. type: Plain text
#: ../E/factory.txt:62
#, no-wrap
msgid ""
"<code><a cbot|researched>researched</a></code>, <code><a cbot|wait>wait</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: \b; header
#: ../E/isbusy.txt:1
#, no-wrap
msgid "Instruction <code>isbusy</code>"
msgstr ""

#. type: Source code
#: ../E/isbusy.txt:3
#, no-wrap
msgid "<c/>isbusy ( object );<n/>"
msgstr ""

#. type: Plain text
#: ../E/isbusy.txt:5
#, no-wrap
msgid "Checks if a given object is busy."
msgstr ""

#. type: Source code
#: ../E/research.txt:3
#, no-wrap
msgid "<c/>research ( type, object );<n/>"
msgstr ""

#. type: Plain text
#: ../E/research.txt:5
#, no-wrap
msgid "Starts a <a cbot|researches>research</a> of a given type."
msgstr ""

#. type: Plain text
#: ../E/research.txt:11
#, no-wrap
msgid "<a object|research>ResearchCenter</a> or <a object|labo>AutoLab</a>. Nearest research center by default."
msgstr ""

#. type: Plain text
#: ../E/research.txt:19
#, no-wrap
msgid ""
"<a cbot|researches>Research names</a>, <code><a cbot|canresearch>canresearch</a></code>, <code><a cbot|researched>researched</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: Plain text
#: ../E/researched.txt:5
#, no-wrap
msgid "Checks if a <a cbot|researches>research</a> is done."
msgstr ""

#. type: Plain text
#: ../E/researched.txt:11
#, no-wrap
msgid ""
"<format const>true</format> if the research is done\n"
"<format const>false</format> if the research is not done"
msgstr ""

#. type: Plain text
#: ../E/researched.txt:15
#, no-wrap
msgid ""
"<a cbot|researches>Research names</a>, <code><a cbot|research>research</a></code>, <code><a cbot|canresearch>canresearch</a></code>, <code><a cbot|canbuild>canbuild</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""

#. type: Plain text
#: ../E/researches.txt:9
#, no-wrap
msgid ""
"<code><format const>ResearchTracked</format>       </code>Tracked bots (e.g. <a object|botgc>tracked grabber</a>)\n"
"<code><format const>ResearchWinged</format>        </code>Winged bots (e.g. <a object|botgj>winged grabber</a>)\n"
"<code><format const>ResearchShooter</format>       </code><a object|botfr>Fireball cannon</a>\n"
"<code><format const>ResearchDefenseTower</format>  </code><a object|tower>Defense tower</a>\n"
"<code><format const>ResearchNuclearPlant</format>  </code><a object|nuclear>Nuclear plant</a>\n"
"<code><format const>ResearchThumper</format>       </code><a object|bottump>Thumper</a>\n"
"<code><format const>ResearchShielder</format>      </code><a object|botshld>Shielder</a>\n"
"<code><format const>ResearchPhazerShooter</format> </code><a object|botphaz>Phazer cannon</a>\n"
"<code><format const>ResearchBuilder</format>       </code><a object|botbr>Neutron gun</a>"
msgstr ""

#. type: Plain text
#: ../E/researches.txt:20
#, no-wrap
msgid ""
"<code><format const>ResearchTarget</format>        </code><a object|bottarg>Target bot</a>\n"
"<code><format const>ResearchLegged</format>        </code>Legged bots (e.g. <a object|botgs>legged grabber</a>)\n"
"<code><format const>ResearchOrgaShooter</format>   </code><a object|botor>Orgaball cannon</a>"
msgstr ""

#. type: Plain text
#: ../E/researches.txt:25
#, no-wrap
msgid ""
"<code><format const>ResearchSniffer</format>       </code><a object|botsr>Sniffer</a>\n"
"<code><format const>ResearchSubber</format>        </code><a object|botsub>Subber</a>\n"
"<code><format const>ResearchRecycler</format>      </code><a object|botrecy>Recycler</a>"
msgstr ""

#. type: Plain text
#: ../E/researches.txt:30
#, no-wrap
msgid "<a cbot>CBOT Language</a>, <a cbot|type>Variables</a> and <a cbot|category>Categories</a>."
msgstr ""

#. type: Source code
#: ../E/takeoff.txt:3
#, no-wrap
msgid "<c/>takeoff ( object );<n/>"
msgstr ""

#. type: Plain text
#: ../E/takeoff.txt:5
#, no-wrap
msgid "Launch a spaceship."
msgstr ""

#. type: Plain text
#: ../E/takeoff.txt:8
#, no-wrap
msgid "<a object|base>SpaceShip</a>, nearest by default."
msgstr ""

#. type: Plain text
#: ../E/switch.txt:5
#, no-wrap
msgid "Note: the <a cbot|isbusy>isbusy</a> instruction might be much better to use in this scenario."
msgstr ""

#. type: Plain text
#: ../E/build.txt:15
#, no-wrap
msgid "Constructs a building using a titanium cube in front of the <a object|botbr>builder</a>."
msgstr ""

#. type: Source code
#: ../E/pointer.txt:37
#, no-wrap
msgid ""
"{\n"
"\tMyClass item = new MyClass();\n"
"\titem.a = 33;\n"
"\treturn item;\n"
"}"
msgstr ""

#. type: Plain text
#: ../E/category.txt:94
#, no-wrap
msgid ""
"<button 136/>   <code><a object|human>Me</a>              </code>You!\n"
"       <code><a object|mine>Mine</a>            </code>Mine\n"
"       <code><a object|barrier>Barrier</a>         </code>Barrier\n"
"       <code><a object|wreck>Wreck</a>           </code>Derelict bot\n"
"       <code><a object|ruin>Ruin</a>            </code>Derelict building\n"
"       <code><a object|bush>Bush</a>            </code>Greenery\n"
"       <code><a object|gravi>GraviPlant</a>      </code>Gravi-plant\n"
"       <code><a object|crystal>Crystal</a>         </code>Crystal\n"
"       <code><a object|bromush>BrownMushroom</a>   </code>Brown mushroom\n"
"       <code><a object|gremush>GreenMushroom</a>   </code>Poisonous green mushroom"
msgstr ""

#. type: \b; header
#: ../E/deflag.txt:1
#, no-wrap
msgid "Instruction <code>deflag</code>"
msgstr ""

#. type: Source code
#: ../E/deflag.txt:3
#, no-wrap
msgid "<c/>deflag ( );<n/>"
msgstr ""

#. type: Plain text
#: ../E/deflag.txt:5
#, no-wrap
msgid "Removes a <a object|flag>colored flag</a> in front of the <a object|botsr>sniffer</a>."
msgstr ""

#. type: Plain text
#: ../E/deflag.txt:8
#, 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/>deflag();<n/>.\n"
"<code>== 0 </code>removed a flag\n"
"<code>!= 0 </code>could not remove a flag"
msgstr ""

#. type: \b; header
#: ../E/flag.txt:1
#, no-wrap
msgid "Instruction <code>flag</code>"
msgstr ""

#. type: Source code
#: ../E/flag.txt:3
#, no-wrap
msgid "<c/>flag ( color );<n/>"
msgstr ""

#. type: Plain text
#: ../E/flag.txt:5
#, no-wrap
msgid "Plants a <a object|flag>colored flag</a> in front of the <a object|botsr>sniffer</a>."
msgstr ""

#. type: \t; header
#: ../E/flag.txt:7
#, no-wrap
msgid "color: <code><a cbot|int>int</a></code> (default value: <code>Blue</code>)"
msgstr ""

#. type: Plain text
#: ../E/flag.txt:8
#, no-wrap
msgid ""
"<code>Blue</code>\n"
"<code>Red</code>\n"
"<code>Green</code>\n"
"<code>Yellow</code>\n"
"<code>Violet</code>"
msgstr ""

#. type: Plain text
#: ../E/flag.txt:15
#, 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/>flag();<n/>.\n"
"<code>== 0 </code>planted a flag\n"
"<code>!= 0 </code>could not plant a flag"
msgstr ""

#. type: Plain text
#: ../E/factory.txt:11
#, no-wrap
msgid "Program that will be run on the bot after factory finishes the construction. This can be either a <a cbot|public>public</a> <a cbot|function>function</a>, a filename or raw code."
msgstr ""

#. type: Plain text
#: ../E/factory.txt:23
#, no-wrap
msgid "Raw code:"
msgstr ""

#. type: Source code
#: ../E/factory.txt:25
#, no-wrap
msgid ""
" extern void New()\n"
" {\n"
"     factory(WheeledGrabber, \"extern void Say123() { message(123); }\");\n"
" }"
msgstr ""

#. type: Plain text
#: ../E/factory.txt:31
#, no-wrap
msgid "Public function:"
msgstr ""

#. type: Source code
#: ../E/factory.txt:33
#, no-wrap
msgid ""
" extern void New()\n"
" {\n"
"     factory(WheeledGrabber, \"SayHello\");\n"
" }\n"
"\n"
" public void SayHello()\n"
" {\n"
"     message(\"hello\");\n"
" }"
msgstr ""

#. type: Plain text
#: ../E/factory.txt:44
#, no-wrap
msgid "File name:"
msgstr ""

#. type: Plain text
#: ../E/factory.txt:46
#, no-wrap
msgid "Save this as say-foo.cbot. Note: make sure to check the \"Public\" checkbox when saving - this will cause say-foo.cbot to be inside the program/ folder."
msgstr ""

#. type: Source code
#: ../E/factory.txt:48
#, no-wrap
msgid ""
" extern void New()\n"
" {\n"
"     message(\"Foo\");\n"
" }"
msgstr ""

#. type: Plain text
#: ../E/factory.txt:54
#, no-wrap
msgid "Run factory like this:"
msgstr ""

#. type: Source code
#: ../E/factory.txt:56
#, no-wrap
msgid ""
" extern void New()\n"
" {\n"
"     factory(WheeledGrabber, \"program/say-foo.cbot\");\n"
" }"
msgstr ""

#. type: Plain text
#: ../E/expr.txt:54
#, no-wrap
msgid ""
"<code>+</code>  addition\n"
"<code>-</code>  subtraction\n"
"<code>*</code>  multiplication\n"
"<code>/</code>  division\n"
"<code>%</code>  remainder of the division (works for <code><a cbot|int>int</a></code> as well as <code><a cbot|float>float</a></code>)"
msgstr ""

#. type: Source code
#: ../E/expr.txt:66
#, no-wrap
msgid ""
" int    i = 12 + 3;      // i == 15\n"
" int    i = 2 - 5;       // i == -3\n"
" \n"
" float  f = 3.01 * 10;   // f == 30.1\n"
" \n"
" int    i = 5 / 3;       // i == 1 (automatic conversion to int)\n"
" float  f = 5 / 3;       // f == 1.67\n"
" float  f = 5 / 0;       // returns an error (division by zero)\n"
" \n"
" int    i = 13 % 5;      // i == 3\n"
" int    i = -8 % 3;      // i == -2\n"
" float  f = -4.5 % 2.75; // f == -1.75\n"
" \n"
" float  f = sin(90) * i; // f == -2.0\n"
" "
msgstr ""

#. type: Plain text
#: ../E/expr.txt:91
#, 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"
msgstr ""

#. type: Plain text
#: ../E/object.txt:4
#, no-wrap
msgid ""
"<code><a cbot|int>int</a>    object.category     </code><a cbot|category>Category</a> of the object\n"
"<code><a cbot|point>point</a>  object.position     </code>Position of the object (x,y,z)\n"
"<code><a cbot|float>float</a>  object.orientation  </code>Orientation of the object (0..360)\n"
"<code><a cbot|float>float</a>  object.pitch        </code>Forward/backward angle of the object\n"
"<code><a cbot|float>float</a>  object.roll         </code>Right/left angle of the object \n"
"<code><a cbot|float>float</a>  object.energyLevel  </code>Energy level (0..1)\n"
"<code><a cbot|float>float</a>  object.shieldLevel  </code>Shield level (0..1)\n"
"<code><a cbot|float>float</a>  object.temperature  </code>Jet temperature (0..1)\n"
"<code><a cbot|float>float</a>  object.altitude     </code>Altitude above ground\n"
"<code><a cbot|float>float</a>  object.lifeTime     </code>Lifetime of the object\n"
"<code>object object.energyCell   </code>Power cell on the bot\n"
"<code>object object.load         </code>Object carried by the bot\n"
"<code><a cbot|int>int</a>    object.team         </code>The object's team (see <a battles>code battles</a>)\n"
"<code><a cbot|point>point</a>  object.velocity     </code>Velocity of the object\n"
"<code><a cbot|bool>bool</a>   object.dead         </code>Is the object dead?"
msgstr ""

#. type: Source code
#: ../E/object.txt:67
#, no-wrap
msgid "<code>dead</code>"
msgstr ""

#. type: Plain text
#: ../E/object.txt:68
#, no-wrap
msgid "True if the object was recently killed (while the death animation is playing). Note that accessing this property or any other property after the death animation finishes will cause an error that stops the program."
msgstr ""