immibis
/
colobot-data
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fail...

dev-ui
krzys-h 2013-03-29 10:13:47 +01:00
parent b0280f5a40
commit 01178b33ca
495 changed files with 0 additions and 11355 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
help/P/cbot/AIM.TXT.bak
View File

@ -1,21 +0,0 @@
\b;Instrukcja \c;aim\n;
Składnia:
\s;\c;aim ( kąt );\n;
Instrukcja ta umożliwia zmianę położenia lufy w pionie. Następujące roboty mogą strzelać:
o \l;Działo\u object\botfr;
o \l;Działo organiczne\u object\botor;
o \l;Działo fazowe\u object\botphaz;
Podczas kontroli robota za pomocą programu, jedynym sposobem obrócenia lufy w lewo lub w prawo jest obrócenie całego robota przy użyciu instrukcji \c;\l;turn\u cbot\turn;\n;.
\t;kąt: \c;\l;float\u cbot\float;\n;
Kąt w stopniach w odniesieniu do robota. Wartość dodatnia ustawia lufę w górę. Dla dział i dział organicznych ograniczeniem jest przedział od \c;-20\n; do \c;+20\n; stopni. Dla działa fazowego kąt ten musi należeć do przedziału od \c;-20\n; do \c;45\n; stopni.
\t;Zwracana wartość: \c;\l;int\u cbot\int;\n;
Zero jeśli wszystko jest w porządku, wartość różna od zera, jeśli obrót nie może być wykonany:
\c;== 0 \n;Lufa została wycelowana w żądanym kierunku
\c;!= 0 \n;obrót niemożliwy
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

5
help/P/cbot/BOOL.TXT.bak
View File

@ -1,5 +0,0 @@
\b;Typ \c;bool\n;
Zmiennej tego typu można przypisać wartość logiczną, czyli wartość która ma dwa stany: true (prawda) lub false (fałsz).
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

25
help/P/cbot/BREAK.TXT.bak
View File

@ -1,25 +0,0 @@
\b;Instrukcja \c;break\n;
Składnia:
\s;\c;while ( warunek )
\s;{
\s; break;
\s;}
\n;
Instrukcja break kończy wykonywanie pętli \c;\l;while\u cbot\while;\n; lub \c;\l;for\u cbot\for;\n;.
Oto przykład:
\s;\c;int i = 0;
\s;while ( true )
\s;{
\s; \n;Instrukcje ...\c;
\s; i = i+1;
\s; if ( i >= 10 )
\s; {
\s; break;
\s; }
\s; \n;więcej instrukcji ...\c;
\s;}
\n;
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

29
help/P/cbot/COND.TXT.bak
View File

@ -1,29 +0,0 @@
\b;Warunki
Warunek, to \l;wyrażenie\u cbot\expr; dające w wyniku wartość \l;logiczną\u cbot\bool;, którą może być \c;\l;true\u cbot\true;\n; (prawda) lub \c;\l;false\u cbot\false;\n; (fałsz). Używając warunku można wybrać czy instrukcje w pętli \c;\l;while\u cbot\while;\n; powinny być wykonane jeszcze raz lub czy instrukcje w bloku \c;\l;if\u cbot\if;\n; powinny być wykonywane.
Oto kilka operatorów, których można używać do porównywania dwóch wartości:
\c;a == b \n;\c;a\n; równe \c;b\n;
\c;a != b \n;\c;a\n; różne od \c;b\n;
\c;a < b \n;\c;a\n; mniejsze od \c;b\n;
\c;a <= b \n;\c;a\n; mniejsze od lub równe \c;b\n;
\c;a > b \n;\c;a\n; większe od \c;b\n;
\c;a >= b \n;\c;a\n; większe od lub równe \c;b\n;
Na przykład:
\c;12 == 12 \n;daje w wyniku true
\c;45 != 47 \n;daje w wyniku true
\c;99 == 98 \n;daje w wyniku false
\c;12 < -1 \n;daje w wyniku false
\c;12 >= 10 \n;daje w wyniku true
\c;12 >= 12 \n;daje w wyniku true
\t;Uwaga
Nie należy mylić operatora porównania \c;==\n; z operatorem przypisania wartości \l;zmiennej\u cbot\var; \c;=\n;.
\c;a == b\n; jest wyrażeniem porównującym \c;a\n; z \c;b\n;.
\c;a = b\n; jest wyrażeniem kopiującym wartość \c;b\n; do \c;a\n;.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

25
help/P/cbot/CONTINUE.TXT.bak
View File

@ -1,25 +0,0 @@
\b;Instrukcja \c;continue\n;
Składnia:
\s;\c;while ( warunek )
\s;{
\s; continue;
\s;}
\n;
Przy użyciu tej instrukcji, można przeskoczyć resztę instrukcji w \c;\l;bloku\u cbot\bloc;\n; pętli \c;\l;while\u cbot\while;\n; lub \c;\l;for\u cbot\for;\n;: Działanie zostanie wznowione na początku bloku przy następnym powtórzeniu pętli.
Oto przykład:
\s;\c;int i = 0;
\s;while ( i < 5 )
\s;{
\s; i = i+1;
\s; if ( i == 3 )
\s; {
\s; continue;
\s; }
\s; \n;Instrukcje ...\c;
\s;}
\n;
Instrukcje będą wykonane tylko dla wartości \c;i\n; 1, 2, 4 i 5.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

15
help/P/cbot/DIRECT.TXT.bak
View File

@ -1,15 +0,0 @@
\b;Instrukcja \c;direction\n;
Składnia:
\s;\c;direction ( pozycja );\n;
Oblicza kšt obrotu, niezbędny do skierowania robota w kierunku zadanej pozycji.
\t;pozycja: \c;\l;point\u cbot\point;\n;
Pozycja, w kierunku której ma być skierowany robot.
\t;Typ wyniku: \c;\l;float\u cbot\float;\n;
Kšt obrotu, który powinien być wykonany. -90 oznacza obrót o 90 stopni w prawo.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

30
help/P/cbot/DIST.TXT.bak
View File

@ -1,30 +0,0 @@
\b;Instrukcja \c;distance\n;
Za pomocą instrukcji \c;distance( , )\n; można obliczyć odległość między dwoma punktami.
\b;Podstawowe użycie
Napisanie samej instrukcji \c;position\n; daje w wyniku pozycję robota wykonującego program. Napisanie nazwy zmiennej, a następnie bezpośrednio po niej \c;.position\n;, daje w wyniku pozycję obiektu opisywanego przez zmienną.
Oto program polecający robotowi podejść do przodu, o odległość równą odległości pomiędzy robotem i najbliższą mrówką:
\c;
\s; item = \l;radar\u cbot\radar;(AlienAnt);
\s; \l;move\u cbot\move;(distance(position, item.position));
\n;
Byłoby to oczywiste samobójstwo. Lepiej zatrzymać robota 40 metrów wcześniej, w odległości odpowiedniej do strzału:
\c;
\s; item = radar(AlienAnt);
\s; move(distance(position, item.position) - 40);
\n;
\b;Dla specjalistów
Składnia:
\s;\c;distance ( pozycja1, pozycja2 );\n;
Oblicza odległość między dwoma punktami.
\t;pozycja1, pozycja2: \c;\l;point\u cbot\point;\n;
Współrzędne dwóch punktów.
\t;Typ wyniku: \c;\l;float\u cbot\float;\n;
Odległość między dwoma punktami.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

28
help/P/cbot/DO.TXT.bak
View File

@ -1,28 +0,0 @@
\b;Instrukcja \c;do - while\n;
Składnia:
\s;\c;do
\s;{
\s; \n;Instrukcje ...\c;
\s;}
\s;while ( warunek );
\n;
Instrukcja ta umożliwia kilkukrotne wykonanie instrukcji w \l;bloku\u cbot\bloc;. Instrukcje wykonywane są conajmniej jeden raz, gdyż warunek sprawdzany jest dopiero na końcu pętli.
Należy uważać, aby nie pomylić instrukcji \c;do { } while ( );\n; z instrukcją \c;\l;while\u cbot\while; ( ) { }\n;; ta druga sprawdza warunek przed wykonaniem instrukcji w bloku.
\t;\c;warunek\n;
Instrukcje w bloku wykonywane są tak długo, jak długo \l;warunek\u cbot\cond; jest prawdziwy.
Oto przykład:
\s;\c;do
\s;{
\s; p = radar(TitaniumOre);
\s;}
\s;while ( p == null );
\n;
\t;Uwaga
Zawsze należy umieszczać \l;średnik\u cbot\term; na końcu wiersza z instrukcją \c;while ( )\n;.
Instrukcje \c;\l;break\u cbot\break;\n; i \c;\l;continue\u cbot\continue;\n; mogą być przydatne wewnątrz bloku instrukcji \c;do { }\n;.
\t;Zobacz również
\l;Instrukcje\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

29
help/P/cbot/DROP.TXT.bak
View File

@ -1,29 +0,0 @@
\b;Instrukcja \c;drop\n;
Instrukcja \c;drop();\n; poleca robotowi upuścić niesiony przedmiot na ziemię, platformę budynku lub miejsce na ogniwo elektryczne robota.
\b;Podstawowe użycie
Instrukcja \c;drop();\n; napisana w takiej postaci upuszcza przedmiot przed robotem. Oto krótki program podnoszący przedmiot bezpośrednio przed robotem i upuszczający go 5 metrów dalej:
\c;
\s; \l;grab\u cbot\grab;();
\s; \l;move\u cbot\move;(5);
\s; drop();
\n;
\b;Dla specjalistów
Składnia:
\s;\c;drop ( oper );\n;
Instrukcja ta odwołuje się do ramienia \l;robota transportera\u object\botgr;, w celu upuszczenia niesionego przedmiotu.
\t;oper: \c;\l;int\u cbot\int;\n; (domyślna wartość \c;InFront\n;)
Oper oznacza gdzie robot powinien zostawić przedmiot. Jeśli nie jest to określone, przedmiot zostawiany jest przed robotem.
\c;InFront \n; przed (domyślnie).
\c;Behind \n; za
\c;EnergyCell\n; w miejscu na baterię samego robota.
\t;Typ wyniku: \c;\l;int\u cbot\int;\n;
Zwykle wystąpienie błędu powoduje zatrzymanie programu. Można wyłączyć zatrzymywanie się programu w przypadku wystąpienia błędu, używając instrukcji \c;\l;errmode\u cbot\errmode;(0)\n;. Wtedy w przypadku wystąpienia błędu instrukcja \c;drop();\n; zwraca w wyniku wartość różną od zera.
\c;== 0 \n;przedmiot został upuszczony
\c;!= 0 \n;błąd, nie upuszczono żadnego przedmiotu
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

88
help/P/cbot/EXPR.TXT.bak
View File

@ -1,88 +0,0 @@
\b;Wyrażenia
Wyrażenia mogą zawierać następujące operatory:
\c;+\n; dodawanie
\c;-\n; odejmowanie
\c;*\n; mnożenie
\c;/\n; dzielenie
\c;%\n; reszta z dzielenia (tylko dla typu całkowitego \c;\l;int\u cbot\int;\n;)
Dodatkowo operator \c;+\n; nie tylko dodaje liczby ale również złącza \l;łańcuchy\u cbot\string;.
\c;
\s; int i = 12+3; // daje w wyniku 15
\s; string s = "a"+"bc"; // daje w wyniku "abc"
\s; int i = 2-5; // daje w wyniku -3
\s; float f = 3.01*10; // daje w wyniku 30.1
\s; int i = 5/3; // daje w wyniku 1
\s; float f = 5/3; // daje w wyniku 1.67
\s; float f = 5/0; // powoduje wystąpienie błędu
\s; int i = 13%5; // daje w wyniku 3
\s; int i = -8%3; // daje w wyniku -2
\n;
Wyrażenie może zawierać stałe lub \l;zmienne\u cbot\var;. Na przykład:
\s;\c; 12+odległość\n;
Mnożenie i dzielenie wykonywane jest przed dodawaniem i odejmowaniem. Aby zapewnić właściwą kolejność wykonywania działań, należy użyć nawiasów:
\c;
\s; 12*a+b/c \n;jest równoważne\c; (12*a)+(b/c)
\s; 2.5*(odległość+zasięg)
\n;
W celu poprawienia czytelności, można dodać dowolną liczbę spacji:
\c;
\s; 12*a + b/c
\s; 2.5 * (odległość+zasięg)
\n;
Oto lista funkcji matematycznych:
\c;sin(angle) \n;sinus
\c;cos(angle) \n;cosinus
\c;tan(angle) \n;tangens
\c;asin(value) \n;arcus sinus
\c;acos(value) \n;arcus cosinus
\c;atan(value) \n;arcus tangens
\c;sqrt(value) \n;pierwiastek kwadratowy
\c;pow(x, y) \n;x do potęgi y
\c;rand() \n;losowa wartość pomiędzy 0 i 1
Kąty podawane są w stopniach.
\t;Złożone operatory przypisania (dla specjalistów)
Poza operatorem przypisania wartości zmiennej \c;=\n; jest kilka złożonych operatorów przypisania.
Złożone operatory przypisania to operator przypisania \c;=\n; z innym operatorem binarnym, takim jak \c;+\n; lub \c;-\n;. Złożone operatory przypisania wykonują działanie określona przez dodatkowy operator a wynik przypisują lewej stronie działania. Na przykład poniższe wyrażenie:
\c;\s;wyrażenie1 += wyrażenie2
jest równoważne
\c;\s;wyrażenie1 = wyrażenie1 + wyrażenie2
\c;+=\n; dodawanie
\c;-=\n; odejmowanie
\c;*=\n; mnożenie
\c;/=\n; dzielenie
\c;%=\n; reszta z dzielenia (tylko dla typu całkowitego \c;\l;int\u cbot\int;\n;)
\t;Przedrostkowe i przyrostkowe operatory zwiększania i zmniejszania (dla specjalistów)
Operatory \c;++\n; i \c;--\n; umożliwiają wygodny i zwarty zapis zwiększania (++) lub zmiejszania (--) zmiennych.
Na przykład aby zwiększyć zmienną \c;a\n; można napisać
\c;\s; a++ ;
\n;zamiast
\c;\s; a = a + 1 ;
\n;
Wartością wyrażenia \c;a++\n; jest wartość zmiennej \c;a\n; przed jej zwiększeniem. Użycie operatora przedrostkowego \c;++a\n; powoduje, że wartością wyrażenia jest wartość zmiennej \c;a\n; po jej zwiększeniu. To samo dotyczy operatora zmniejszania \c;--\n;.
Przykłady:
\c;\s; a = 2 ;
\s; b = a++ ;
\s; // teraz b jest równe 2, a jest równe 3
\c;\s; a = 2 ;
\s; b = ++a ;
\s; // a teraz b jest równe 3 i a jest równe 3
\n;
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

6
help/P/cbot/FALSE.TXT.bak
View File

@ -1,6 +0,0 @@
\b;Typ \c;false\n;
Wartość ta oznacza, że warunek nie jest prawdziwy; jest to jedna z dwóch wartości \l;zmiennej\u cbot\var; typu \l;boolean\u cbot\bool;.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

31
help/P/cbot/FIRE.TXT.bak
View File

@ -1,31 +0,0 @@
\b;Instrukcja \c;fire\n;
Instrukcja \c;fire();\n; powoduje wystrzał z broni pokładowej robota.
\b;Podstawowe użycie
Przeważnie instrukcja ta używana jest do jednosekundowych serii strzałów:
\c;
\s; fire(1);
\n;
\b;Dla specjalistów
Składnia:
\s;\c;fire ( czas );\n;
Strzela serią trwającą określony czas. Im dłuższa seria, tym więcej energii jest zużywane. Instrukcja ta może być używana przez następujące typy robotów:
o \l;Działo\u object\botfr;
o \l;Działo organiczne\u object\botor;
o \l;Działo fazowe\u object\botphaz;
Podczas kontrolowania działanie robota przy użyciu programu, jedynym sposobem obrócenia lufy w prawo lub w lewo, jest obrócenie całego robota instrukcją \c;\l;turn\u cbot\turn;\n;.
Do celowania w górę lub w dół, należy używać instrukcji \c;\l;aim\u cbot\aim;\n;.
\t;czas: \c;\l;float\u cbot\float;\n;
Czas trwania serii. Zwykle jest to 1 sekunda. Krótsze serie pozwalają zaoszczędzić czas i energię.
\t;Typ wyniku: \c;\l;int\u cbot\int;\n;
Zero w przypadku powodzenia lub inna wartość jeśli wystąpił błąd.
\c;== 0 \n;udało się wystrzelić
\c;!= 0 \n;błąd, strzał nie mógł byc wykonany
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

25
help/P/cbot/FLOAT.TXT.bak
View File

@ -1,25 +0,0 @@
\b;Typ \c;float\n;
Typ ten jest używany dla większości zmiennych zawierających liczby. Zmienne tego typu mogą zawierać liczby dodatnie i ujemne, zarówno całkowite jak i rzeczywiste, na przykład:
\c;
\s; 12.9
\s; 1.125
\s; 0.002
\s; -4.1
\n;
Jeśli potrzebne są tylko liczby całkowite (takie jak 12 lub -5000), lepszym wyborem jest użycie typu \c;\l;int\u cbot\int;\n;.
\t;Uwaga
Nie można wstawiać spacji ani przecinków wewnątrz liczby. Do rozdzielania części całkowitej i części ułamkowej należy używać kropki.
\c;
\s; dobrze źle
\s; 12.56 12 . 56
\s; -54.34 -54,34
\s;12895.69 12,895.69
\n;
\t;Dla specjalistów
Liczby zmiennoprzecinkowe reprezentowane są w grze Colobot za pomocą 32 bitów.
Największa reprezentowalna wartość to 3.4E+38.
Najmniejsza reprezentowalna wartość to 3.4E-38.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

40
help/P/cbot/FOR.TXT.bak
View File

@ -1,40 +0,0 @@
\b;Instrukcja \c;for\n;
Składnia:
\s;\c;for ( przed ; warunek ; koniec )
\s;{
\s; \n;Instrukcje...\c;
\s;}
\n;
Instrukcja ta pozwala na powtórzenie określoną ilość razy instrukcji zawartych w \l;bloku\u cbot\bloc;.
\t;\c;przed\n;
Instrukcja wykonywana przed pierwszym przejściem pętli.
\t;\c;warunek\n;
\l;Warunek\u cbot\cond; określa, czy powinno być wykonane następne przejście pętli. Jest on sprawdzany przed każdym jej przejściem.
\t;\c;koniec\n;
Instrukcja wykonywana po każdym przejściu pętli.
Przykład: liczenie od 1 do 4
\c;\s;\c;for ( i = 0 ; i <= 4 ; i++ )
\s;{
\s; message(i) ;
\s;}
\n;
Następujący przykład, równoważny pętli \c;for\n;, używa instrukcji \c;\l;while\u cbot\while;\n;:
\s;\c;przed;
\s;while ( warunek )
\s;{
\s; \n;Instrukcje...\c;
\s; koniec;
\s;}
\n;
\t;Uwaga
Na końcu instrukcji \c;for ( )\n; nie należy umieszczać \l;średnika\u cbot\term;.
Instrukcje \c;\l;break\u cbot\break;\n; i \c;\l;continue\u cbot\continue;\n; mogą być przydatne wewnątrz bloku instrukcji \c;for \n;.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

35
help/P/cbot/GOTO.TXT.bak
View File

@ -1,35 +0,0 @@
\b;Instrukcja \c;goto\n;
Instrukcja \c;goto();\n; rozkazuje robotowi udać się do podanej pozycji.
\b;Podstawowe użycie
Najczęstsze użycie polega na wysłaniu robota do obiektu zlokalizowanego przy użyciu instrukcji \c;\l;radar\u cbot\radar;();\n;. Jeśli jego dane zastały zapisane w zmiennej, należy po nazwie zmiennej napisać \c;.position\n; aby otrzymać pozycję obiektu. Oto przykładowy program znajdujący \l;kostkę tytanu\u object\titan; idący na jej pozycję i podnoszący ją:
\c;
\s; element = \l;radar\u cbot\radar;(Titanium);
\s; goto(element.position);
\s; \l;grab\u cbot\grab;();
\n;
\b;Dla specjalistów
Składnia:
\s;\c;goto ( pozycja, wysokość, cel, zderzenie );\n;
Rozkazuje robotowi udać się w podane miejsce unikając wszelkich przeszkód, jeśli to możliwe.
\t;pozycja: \c;\l;point\u cbot\point;\n;
Współrzędne pozycji docelowej.
\t;wysokość: \c;\l;float\u cbot\float;\n;
Wysokość lotu \l;robota latającego\u object\botgj;. Parametr ten jest użyteczny tylko w przypadku \l;robota latającego\u object\botgj;. Z wysokości początkowej, robot wznosi się do góry, do czasu osiągnięcia określonej wysokości. Po zbliżeniu się do miejsca docelowego, zmniejsza wysokość, aby opaść na ziemię w zadanej pozycji. Jeśli nie określono wysokości, domyślną wartością jest 10 metrów. Przy bardzo krótkich trasach, nawet robot latający może poruszać się po ziemi. Parametr ten jest ignorowany dla wszystkich robotów poza robotem latającym.
\t;cel: \c;\l;int\u cbot\int;\n; (domyślna wartość: \c;0\n;)
Określa sposób w jaki robot powinien osiągnąć swoj cel:
\c;0\n; zatrzymuje się dokładnie w pozycji docelowej
\c;1\n; zbliża się do pozycji docelowej bez zatrzymywania się.
Jeśli nie określono wartości, domyślnie przyjmowane jest \c;1\n; (dokładnie).
\t;Typ wyniku: \c;\l;int\u cbot\int;\n;
Zwykle wystąpienie błędu powoduje zatrzymanie programu. Można wyłączyć zatrzymywanie się programu w przypadku wystąpienia błędu, używając instrukcji \c;\l;errmode\u cbot\errmode;(0)\n;. Wtedy w przypadku wystąpienia błędu instrukcja \c;goto()\n; zwraca w wyniku wartość różną od zera.
\c;== 0 \n;Pozycja docelowa została osiągnięta
\c;!= 0 \n;Osiągnięcie pozycji docelowej jest niemożliwe
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

29
help/P/cbot/GRAB.TXT.bak
View File

@ -1,29 +0,0 @@
\b;Instrukcja \c;grab\n;
Instrukcja \c;grab();\n; rozkazuje robotowi podnieść za pomocą ramienia chwytającego przedmiot znajdujący się na ziemi, platformie budynku lub miejscu na ogniwo robota.
\b;Podstawowe użycie
Instrukcja \c;grab();\n; napisana w ten sposób, podniesie przedmiot znajdujący się przed robotem. Oto krótki program podnoszący przedmiot przed robotem i upuszczający go 5 metrów dalej:
\c;
\s; grab();
\s; \l;move\u cbot\move;(5);
\s; \l;drop\u cbot\drop;();
\n;
\b;Dla specjalistów
Składnia:
\s;\c;grab ( oper );\n;
Instrukcja ta odwołuje się do ramienia \l;robota transportera\u object\botgr;, powodując chwycenie najbliższego obiektu.
\t;oper: \c;\l;int\u cbot\int;\n; (domyślna wartość \c;InFront\n;)
Parametr oper określa gdzie robot powinien szukać przedmiotu do podniesienia. Jeśli nie jest to określone, podnoszony jest obiekt znajdujący się przed robotem:
\c;InFront \n; przed (domyślnie).
\c;Behind \n; za.
\c;EnergyCell\n; wyjmuje własne ogniwo elektryczne.
\t;Typ wyniku: \c;\l;int\u cbot\int;\n;
Zwykle wystąpienie błędu powoduje zatrzymanie programu. Można wyłączyć zatrzymywanie się programu w przypadku wystąpienia błędu, używając instrukcji \c;\l;errmode\u cbot\errmode;(0)\n;. Wtedy w przypadku wystąpienia błędu instrukcja \c;grab();\n; zwraca w wyniku wartość różną od zera.
\c;== 0 \n;obiekt został chwycony
\c;!= 0 \n;błąd, obiekt nie został chwycony
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

40
help/P/cbot/IF.TXT.bak
View File

@ -1,40 +0,0 @@
\b;Instrukcje \c;if\n; i \c;else\n;
Używając instrukcji \c;if() {}\n; można uzależnić wykonanie zbioru instrukcji od spełnienia określonego warunku. Warunek należy zapisać w nawiasach \c;()\n;, a instrukcje w nawiasach klamrowych \c;{}\n;.
\b;Podstawowe użycie
Oto konkretny przykład: Robot będzie strzelał dopiero wtedy, gdy cel będzie bliżej niż 40 metrów:
\c;
\s; item = \l;radar\u cbot\radar;(AlienAnt);
\s; if (\l;distance\u cbot\dist;(position, item.position) < 40)
\s; {
\s; fire(1);
\s; }
\n;
Można też sprawdzić czy obiekt istnieje w ogóle. Jeśli instrukcja \c;\l;radar\u cbot\radar;();\n; nie znajdzie żądanego obiektu, zwraca wartość \c;null\n;. Można więc sprawdzić czy obiekt istnieje, warunkiem \c;(item != null)\n; lub czy nie istnieje \c;(item == null)\n;. Dwa znaki równości \c;==\n; sprawdzają równość, znak równości poprzedzony wykrzyknikiem \c;!=\n; sprawdza nierówność. Oto program testowy, który będzie ładował \l;ogniwa elektryczne\u object\power; tylko wtedy, gdy znajdzie \l;stację energetyczną\u object\station;:
\c;
\s; item = \l;radar\u cbot\radar;(PowerStation);
\s; if (item != null)
\s; {
\s; \l;goto\u cbot\goto;(item.position);
\s; \l;wait\u cbot\wait;(5);
\s; }
\n;
\b;Dla specjalistów
Składnia:
\s;\c;if ( warunek )
\s;{
\s; \n;Instrukcje A ...\c;
\s;}
\s;else
\s;{
\s; \n;Instrukcje B ...\c;
\s;}
\n;
Przy użyciu tej struktury warunkowej można wykonać \l;blok\u cbot\bloc; A lub \l;blok\u cbot\bloc; B w zależności od \l;warunku\u cbot\cond;. Jeśli warunek jest prawdziwy, wykonywany jest blok A. Jeśli warunek jest fałszywy, wykonywany jest blok B.
Część \c;else { }\n; nie jest obowiązkowa.
\t;Uwaga
Na końcu linii \c;if ( )\n; nie należy stawiać \l;średnika\u cbot\term;.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

20
help/P/cbot/INT.TXT.bak
View File

@ -1,20 +0,0 @@
\b;Typ \c;int\n;
Jest to typ zmiennych zawierajšcych tylko liczby całkowite, dodatnie albo ujemne. Na przykład:
\c;
\s; 12
\s; 1000
\s; -4
\n;
Do reprezentacji liczb rzeczywistych, takich jak 12,05 lub -0,005 należy używać typu \c;\l;float\u cbot\float;\n;.
\t;Uwaga
Nie należy używać spacji ani przecinków w zapisie liczby.
\t;Dla specjalistów
Reprezentacja liczb typu \c;int\n; zajmuje 32 bity.
Największa reprezentowalna liczba to (2^31)-1, czyli 2 147 483 647.
Najmniejsza reprezentowalna liczba to -(2^31), czyli -2 147 483 648.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

16
help/P/cbot/JET.TXT.bak
View File

@ -1,16 +0,0 @@
\b;Instrukcja \c;jet\n;
Składnia:
\s;\c;jet ( moc );\n;
Umożliwia bezpośrednią kontrolę nad silnikiem odrzutowym \l;robota latającego\u object\botgj;. Silnik odrzutowy umożliwia robotom latanie. Instrukcja ta może służyć do wznoszenia się, zwiększania i zmniejszania wysokości lotu oraz lądowania.
\t;moc: \c;\l;float\u cbot\float;\n;
Moc silnika odrzutowego, może zawierać się w zakresie od \c;-1\n; do \c;+1\n;. \c;jet(1);\n; to sposób na najszybsze wznoszenie się robota, \c;jet(-1);\n; zmniejsza wysokość tak szybko, jak to możliwe, \c;jet(0);\n; utrzymuje stałą wysokość. W celu uzyskania wolniejszych zmian wysokości, należy użyć wartości pośrednich, na przykład \c;jet(0.3);\n;.
\t;Typ wyniku: \c;\l;void\u cbot\void;\n;
Brak.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

25
help/P/cbot/MESSAGE.TXT.bak
View File

@ -1,25 +0,0 @@
\b;Instrukcja \c;message\n;
Sk豉dnia:
\s;\c;message ( tekst, typ );\n;
Wy菏ietla wiadomo𨀣 na g鏎ze ekranu. Wiadomo𨀣 znika automatycznie po kilku sekundach.
\t;tekst: \c;\l;string\u cbot\string;\n;
Tekst do wy菏ietlenia. Mo磧iwe jest z章czanie tekst闚 i/lub warto𦣇i przy u篡ciu operatora \c;+\n;:
\c;message("Nie znaleziono");\n;
\c;message(k靖);\n;
\c;message(n + " obiekt闚");\n;
\c;message("Odleg這𨀣 = " + dist + " metr闚");\n;
\t;typ: \c;\l;int\u cbot\int;\n; (domy𦧺na warto𨀣: \c;DisplayMessage\n;)
Typ wiadomo𦣇i, okre𦧺aj鉍y kolor t豉.
o \c;DisplayMessage\n; Standardowa wiadomo𨀣 na 鄴速ym tle.
o \c;DisplayInfo \n; Informacja na zielonym tle.
o \c;DisplayWarning\n; Ostrze瞠nie na niebieskim tle.
o \c;DisplayError \n; B章d na czerwonym tle.
\t;Typ wyniku: \c;\l;void\u cbot\void;\n;
Brak.
\t;Zobacz r闚nie<69>
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

22
help/P/cbot/MOVE.TXT.bak
View File

@ -1,22 +0,0 @@
\b;Instrukcja \c;move\n;
Instrukcja \c;move();\n; rozkazuje robotowi poruszać się do przodu lub do tyłu przy zachowaniu niezmiennej orientacji. W nawiasie należy podać odległość (w metrach) o jaką powinien przemieścić się robot.
\b;Podstawowe użycie
Aby robot przemieścił się do przodu o 30 metrów, należy napisać \c;move(30);\n;. Aby robot cofnął się po umieszczeniu \l;rudy tytanu\u object\titanore; w \l;hucie\u object\convert;, należy napisać \c;move(-2.5);\n;.
\b;Dla specjalistów
Składnia:
\s;\c;move ( odległość );\n;
Porusza robotem do przodu lub do tyłu o zadaną odległość, zachowując bieżącą orientację robota.
\t;odległość: \c;\l;float\u cbot\float;\n;
Odległość w metrach. Wartość ujemna powoduje ruch do tyłu.
\t;Typ wyniku: \c;\l;int\u cbot\int;\n;
Zwykle wystąpienie błędu powoduje zatrzymanie programu. Można wyłączyć zatrzymywanie się programu w przypadku wystąpienia błędu, używając instrukcji \c;\l;errmode\u cbot\errmode;(0)\n;. Wtedy w przypadku wystąpienia błędu instrukcja \c;move();\n; zwraca w wyniku wartość różną od zera.
\c;== 0 \n;instrukcja move została wykonana
\c;!= 0 \n;błąd, instrukcja nie została poprawnie wykonana
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

16
help/P/cbot/NAN.TXT.bak
View File

@ -1,16 +0,0 @@
\b;Typ \c;nan\n;
Specjalna wartość oznaczająca, że \l;zmienna\u cbot\var; typu \c;\l;int\u cbot\int;\n; lub \c;\l;float\u cbot\float;\n; nie zawiera liczby ale "nic".
Na przykład jeśli instrukcja \c;\l;receive\u cbot\receive;\n; nie może uzyskać żądanej informacji, zwraca w wyniku wartość \c;nan\n;:
\c;
\s; wartość = receive("Length");
\s; if ( wartość == nan ) // nie znaleziono?
\s; {
\s;
\s; }
\n;
\t;Słownik
\c;nan\n; = Not A Number (nie liczba)
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

7
help/P/cbot/NULL.TXT.bak
View File

@ -1,7 +0,0 @@
\b;Typ \c;null\n;
Specjalna wartość oznaczająca, że zmienna, która ją zawiera nie wskazuje na żadną instancję.
\t;Zobacz również
\l;Wskaźniki\u cbot\pointer;
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

70
help/P/cbot/OBJECT.TXT.bak
View File

@ -1,70 +0,0 @@
\b;Typ \c;object\n;
Typ używany dla zmiennych zawierających charakterystyki obiektów, takich jak roboty, budynki, surowce, wrogowie, itp.
\c;\l;int\u cbot\int; object.category \n;\l;Kategoria\u cbot\category; obiektu
\c;\l;point\u cbot\point; object.position \n;Pozycja obiektu (x,y,z)
\c;\l;float\u cbot\float; object.orientation \n;Orientacja obiektu (0..360)
\c;\l;float\u cbot\float; object.pitch \n;Pochylenie obiektu przód/tył
\c;\l;float\u cbot\float; object.roll \n;Pochylenie obiektu prawo/lewo
\c;\l;float\u cbot\float; object.energyLevel \n;Poziom energii (0..1)
\c;\l;float\u cbot\float; object.shieldLevel \n;Poziom osłony (0..1)
\c;\l;float\u cbot\float; object.temperature \n;Temperatura silnika odrzutowego (0..1)
\c;\l;float\u cbot\float; object.altitude \n;Wysokość nad poziomem ziemi
\c;\l;float\u cbot\float; object.lifeTime \n;Czas życia obiektu
\c;object object.energyCell \n;Ogniwo elektryczne robota
\c;object object.load \n;Przedmiot niesiony przez robota
\s;\c;category\n;
\n;\l;Kategoria\u cbot\category; obiektu określa czym jest obiekt, tzn. określa np. rodzaj robota, budynku lub wroga, itp.
\s;\c;position\n;
Położenie obiektu na planecie, w metrach. Współrzędne \c;x\n; i \c;y\n; odnoszą się do położenia na mapie, współrzędna \c;z\n; odpowiada wysokości nad (lub odpowiednio pod) poziomem morza.
\s;\c;orientation\n;
Orientacja obiektu, w stopniach. Określa kierunek, w którym obrócony jest obiekt. Wartość \c;0\n; odpowiada orientacji na wschód, zgodnie z dodatnią osią \c;x\n;. Orientacja liczona jest przeciwnie do ruchu wskazówek zegara.
\s;\c;pitch\n;
Pochylenie robota w przód/tył. Wartość \c;0\n; oznacza, że robot stoi na płaskim terenie. Wartość dodatnia oznacza, że robot "patrzy" w górę, wartość ujemna, że w dół.
\s;\c;roll\n;
Pochylenie robota w lewo/prawo. Wartość dodatnia oznacza, że robot jest przechylony na lewą stronę, wartość ujemna, że na prawą.
\s;\c;energyLevel\n;
Poziom energii, pomiędzy 0 i 1. Dla w pełni naładowanego \l;zwykłego ogniwa elektrycznego\u object\power; zwracana jest wartość \c;1\n;. \l;Atomowe ogniwo elektryczne\u object\atomic; nigdy nie zwraca wartości większej niż 1, jedynie działa dłużej. Uwaga: Poziom energii robota zawsze jest równy zero, gdyż energia nie jest zawarta w robocie ale w ogniwie elektrycznym. Aby poznać poziom energii ogniwa elektrycznego robota, należy napisać \c;energyCell.energyLevel\n;.
\s;\c;shieldLevel\n;
Poziom osłony robota albo budynku. Wartość \c;1\n; oznacza w pełni sprawną osłonę. Za każdym uderzeniem pocisku lub zderzeniem z innym obiektem, zmniejsza się poziom osłony. Gdy osiągnie on \c;0\n;, następny pocisk bądź zderzenie spowoduje zniszczenie robota albo budynku.
Roboty mogą zregenerować osłony w \l;warsztacie\u object\repair;. Powłoka budynku regenerowana jest gdy znajdzie się w zasięgu sfery ochronnej robota \l;osłaniacza\u object\botshld;.
\s;\c;temperature\n;
Temperatura silnika odrzutowego \l;robotów latających\u object\botgj;. \c;0\n; odpowiada zimnemu silnikowi. W miarę używania, wzrasta jego temperatura. Gdy osiągnie wartość \c;1\n;, silnik przegrzewa się i przestaje działać do czasu ostygnięcia.
\s;\c;altitude\n;
Współrzędna \c;z\n; oznacza wysokość nad poziomem morza, podczas gdy \c;altitude\n; oznacza wysokość nad poziomem ziemi. Wartość ta ma znaczenie jedynie dla \l;robotów latających\u object\botgj; i \l;os\u object\wasp;. Dla pozostałych obiektów jest zerowa.
\s;\c;lifeTime\n;
Wiek obiektów, w sekundach, od czasu ich powstania.
\s;\c;energyCell\n;
Jest to specjalna informacja, gdyż zwraca informacje o innym obiekcie, w tym przypadku ogniwie elektrycznym. Oznacza to, że energyCell zawiera wszystkie charakterystyki normalnego obiektu, na przykład \c;category\n; (PowerCell lub NuclearCell), \c;position\n; (pozycję ogniwa), itp.
Aby poznać poziom energii robota, zamiast \c;energyLevel\n;, należy sprawdzić \c;energyCell.energyLevel\n;.
Jeśli robot nie zawiera ogniwa elektrycznego, \c;energyCell\n; jest równe \c;null\n;.
\s;\c;load\n;
Ta informacja również zwraca opis całego obiektu, a mianowicie opis obiektu trzymanego przez \l;transporter\u object\botgr;. Jeśli nie niesie on niczego, \c;load\n; jest równe \c;null\n;.
\b;Przykłady
Typ \c;object\n; zwraca specjalną wartość \c;\l;null\u cbot\null;\n; gdy obiekt nie istnieje. Na przykład:
\c;
\s; object a;
\s; a = radar(BotGrabberRoller);
\s; if ( a == null ) // obiekt nie istnieje?
\s; {
\s; }
\s; if ( a.position.z > 50 ) // czy jest na górze?
\s; {
\s; }
\n;
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

36
help/P/cbot/Point.txt.bak
View File

@ -1,36 +0,0 @@
\b;Typ \c;point\n;
Zmienne tego typu zawierają współrzędne punktu w przestrzeni. Składa się on z trzech wartości reprezentujących współrzędne \c;x\n;, \c;y\n; oraz \ c;z\n;.
\c;x\n; i \c;y\n; odpowiadają miejscu na powierzchni ziemi. Dodatnia oś \c;x\n; wskazuje wschód, dodatnia oś \c;y\n; wskazuje północ.
Wartość \c;z\n; odpowiada wysokości nad poziomem morza.
Aby zadeklarować zmienną typu point, można napisać:
\c;
\s; point a (10, 20, 30);
\n;
Można również pojedynczo ustawić wartości współrzędnych:
\c;
\s; point b;
\s; b.x = 10;
\s; b.y = 20;
\s; b.z = 30;
\n;
W przykładach tych, następujący \l;warunek\u cbot\cond; jest prawdziwy:
\c;
\s; if ( a == b )
\s; {
\s; }
\n;
Następująca deklaracja:
\c;
\s; point c (4, 7);
\n;
Jest równoważna poniższej:
\c;
\s; point c;
\s; c.x = 4;
\s; c.y = 7;
\s; c.z = 0;
\n;
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

60
help/P/cbot/RADAR.TXT.bak
View File

@ -1,60 +0,0 @@
\b;Instrukcja \c;radar\n;
Przy użyciu instrukcji \c;radar()\n;, można znajdować różne obiekty, takie jak \l;wrogów\u object\mother;, roboty, budynki lub surowce.
\b;Podstawowe użycie
W nawiasach należy napisać \l;nazwę poszukiwanego obiektu\u cbot\category;. Wynik należy umieścić w zmiennej \l;typu\u cbot\type; \c;object\n;. Oto przykład znajdujący najbliższą mrówkę:
\c;
\s;// Na początku programu:
\s;object item; // deklaracja zmiennej
\s;
\s;// Znajdź najbliższą mrówkę
\s;item = radar(AlienAnt);
\n;
\b;Dla specjalistów
Składnia:
\s;\c;radar ( category, angle, focus, min, max, way );\n;
Wykrywa obiekty w zależnie od różnych parametrów.
\image radar1 8 8;
Patrząc z góry, czerwona strefa odpowiada strefie, w której będą wykrywane obiekty.
\t;category: \c;\l;int\u cbot\int;\n;
\l;Kategoria\u cbot\category; poszukiwanego obiektu. Na przykład szukając mrówki, należy napisać \c;radar (AlienAnt)\n;.
\t;angle: \c;\l;float\u cbot\float;\n; (domyślna wartość: \c;0\n;)
Kierunek, w którym "patrzy" radar, w stopniach:
\c; 0\n; -> na wprost
\c;-90\n; -> ćwierć obrotu w prawo
\c; 90\n; -> ćwierć obrotu w lewo
\t;focus: \c;\l;float\u cbot\float;\n; (domyślna wartość: \c;360\n;)
Kąt widzenia radaru, w stopniach.
\t;min: \c;\l;float\u cbot\float;\n; (domyślna wartość: \c;0\n;)
Minimalna odległość wykrywania, w metrach. Obiekty znajdujące się bliżej nie będą wykryte.
\t;max: \c;\l;float\u cbot\float;\n; (domyślna wartość: \c;1000\n;)
Maksymalna odległość wykrywania, w metrach. Obiekty znajdujące się dalej nie będą wykryte.
\t;way: \c;\l;float\u cbot\float;\n; (domyślna wartość: \c;1\n;)
Określa sposób wykrywania obiektu. Przy wartości \c;1\n;, znajduje najbliższy obiekt w podanej strefie. Przy wartości\c;-1\n;, znajduje najdalszy obiekt w strefie.
\t;Typ wyniku: \c;\l;object\u cbot\object;\n;
Zwraca pierwszy znaleziony obiekt odpowiadający podanej kategorii w podanej strefie. Jeśli nie znaleziono obiektu, zwracana jest wartość \c;\l;null\u cbot\null;\n;.
\t;Uwaga
Nie jest konieczne podawanie wszystkich parametrów. Oto dwa przykłady równoważnych instrukcji:
\c;
\s; radar(Titanium, 0, 360, 0, 1000);
\s; radar(Titanium); // równoważne
\s; radar(Titanium, 0, 90, 0, 1000);
\s; radar(Titanium, 0, 90); // równoważne
\n;
Jeśli pominięto jeden lub więcej parametrów, przyjmowane są wymienione powyżej wartości domyślne; tylko pierwszy parametr jest obowiązkowy.
Zwykle określony jest tylko pierwszy parametr, np. \c;radar (AlienAnt)\n; wykrywa najbliższą mrówkę, niezależnie od jej położenia.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

14
help/P/cbot/RECYCLE.TXT.bak
View File

@ -1,14 +0,0 @@
\b;Instrukcja \c;recycle\n;
Składnia:
\s;\c;recycle ( );\n;
Odzyskuje surowce z pozostałości robota znajdującego się bezpośrednio przed robotem \l;recyklerem\u object\botrecy; i tworzy \l;kostkę tytanu\u object\titan;.
\t;Typ wyniku: \c;\l;int\u cbot\int;\n;
Zero jeśli wszystko w porządku, lub wartość inna od zera w przypadku wystąpienia błędu.
\c;== 0 \n;odzyskano surowce z pozostałości robota
\c;!= 0 \n;błąd, pozostałość robota nie mogła zostać przetworzona
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

15
help/P/cbot/RETOBJ.TXT.bak
View File

@ -1,15 +0,0 @@
\b;Instrukcja \c;retobject\n;
Składnia:
\s;\c;retobject ( numer );\n;
Zwraca obiekt odpowiadający podanemu numerowi.
\t;numer: \c;\l;int\u cbot\int;\n;
Numer obiektu, pomiędzy 0 i n, gdzie "n" to liczba wszystkich obiektów na planecie.
\t;Typ wyniku: \c;\l;object\u cbot\object;\n;
Obiekt odpowiadający numerowi. Wartość \c;\l;null\u cbot\null;\n; oznacza, że nie ma obiektu odpowiadającego podanemu numerowi, gdyż nie ma aż tylu obiektów na tej planecie.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

31
help/P/cbot/RETURN.TXT.bak
View File

@ -1,31 +0,0 @@
\b;Instrukcja \c;return\n;
Powrót z funkcji. Sk³adnia:
\c;
\s;void funkcja ( )
\s;{
\s; return;
\s;}
\n;
\b;Dla specjalistów
Jeœli \l;funkcja\u cbot\function; ma okreœlony typ wyniku, po instrukcji \c;return\n; musi wyst¹piæ wartoœæ, która ma byæ zwrócona przez funkcjê:
\c;
\s;float Pi ( )
\s;{
\s; return 3.1415;
\s;}
\s;float Œrednia (float a, float b)
\s;{
\s; return (a+b)/2;
\s;}
\s;string Znak (float a)
\s;{
\s; if ( a > 0 ) return "dodatnia";
\s; if ( a < 0 ) return "ujemna";
\s; return "zero";
\s;}
\n;
\t;Zobacz równie¿
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

18
help/P/cbot/Receive.txt.bak
View File

@ -1,18 +0,0 @@
\b;Instrukcja \c;receive\n;
Składnia:
\s;\c;receive ( nazwa, moc );\n;
Pobiera informację z najbliższej \l;stacji przekaźnikowej informacji\u object\exchange;.
\t;nazwa: \c;string\n;
Nazwa informacji żądanej od stacji przekaźnikowej. Jest ona łańcuchem i powinna być zapisana w cudzysłowach "¦".
\t;moc: \c;float\n;
Moc odbiornika, która odpowiada maksymalnej odległości pomiędzy odbiorcą i stacją przekaźnikową. Jeśli odległość jest większa, nie zostanie pobrana żadna informacja. Domyślną wartością jest 10 metrów.
\t;Typ wyniku: \c;\l;float\u cbot\float;\n;
Wartość pobranej informacji. Jeśli wystarczająco blisko nie ma żadnej stacji przekaźnikowej, lub jeśli informacja o podanej nazwie nie istnieje, zwracana jest wartość \c;nan\n;.
\t;Zobacz również
\c;\l;send\u cbot\send;\n;, \c;\l;testinfo\u cbot\testinfo;\n; i \c;\l;deleteinfo\u cbot\delinfo;\n;.
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

18
help/P/cbot/SEARCH.TXT.bak
View File

@ -1,18 +0,0 @@
\b;Instrukcja \c;search\n;
Składnia:
\s;\c;search ( kategoria, pozycja );\n;
Znajduje obiekt o określonej kategorii, będący najbliżej podanej pozycji.
\t;kategoria: \c;\l;int\u cbot\int;\n;
\l;Kategoria\u cbot\category; poszukiwanego obiektu.
\t;pozycja: \c;\l;point\u cbot\point;\n;
Funkcja \c;search\n; zwraca obiekt o podanej kategorii znajdujący się najbliżej określonej tutaj pozycji.
\t;Typ wyniku: \c;\l;object\u cbot\object;\n;
Charakterystyka znalezionego obiektu. Wartość \c;\l;null\u cbot\null;\n; oznacza, że nie znaleziono obiektu o podanej kategorii.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

19
help/P/cbot/SHIELD.TXT.bak
View File

@ -1,19 +0,0 @@
\b;Instrukcja \c;shield\n;
Składnia:
\s;\c;shield ( oper );\n;
Aktywuje lub dezaktywuje osłonę robota \l;osłaniacza\u object\botshld;. Oczywiście można poruszać robotem przy aktywnej osłonie. Zabezpiecza ona wszystkie obiekty znajdujące się wewnątrz strefy przed atakami wroga. Promień sfery może się zawierać pomiędzy 10 a 25 metrami.
\t;oper: \c;\l;float\u cbot\float;\n;
\c;1\n; aktywuje osłonę.
\c;0\n; dezaktywuje osłonę
Zwykłe, w pełni naładowane \l;ogniwo elektryczne\u object\power; wystarcza na 20 sekund aktywności osłony. Gdy ogniwo się wyczerpie, osłona jest wyłączana.
\t;promień: \c;\l;float\u cbot\float;\n;
Promień sfery ochronnej, pomiędzy 10 a 25 metrów.
\t;Typ wyniku: \c;\l;void\u cbot\void;\n;
Brak.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

17
help/P/cbot/SNIFF.TXT.bak
View File

@ -1,17 +0,0 @@
\b;Instrukcja \c;sniff\n;
Składnia:
\s;\c;sniff ( );\n;
Analizuje grunt przed robotem \l;szperaczem\u object\botsr;. W zależności od wykrytego surowca, pojawia się następujący znacznik:
\c;Złoże tytanu\n; -> \l;Czerwony plus\u object\stonspot;
\c;Złoże uranu \n; -> \l;Żółte kółko\u object\uranspot;
\c;Źródło energii \n; -> \l;Zielony plus\u object\enerspot;
\t;Typ wyniku: \c;\l;int\u cbot\int;\n;
Zero jeśli wszystko jest w porządku, lub wartość inna od zera w przypadku wystąpienia błędu.
\c;== 0 \n;analiza wykonana
\c;!= 0 \n;analiza niemożliwa
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

33
help/P/cbot/STRING.TXT.bak
View File

@ -1,33 +0,0 @@
\b;Typ \c;string\n;
Zmiennej tego typu można używać do przechowywania znaków lub ciągów znaków.
Na przykład:
\s;\c; "Cześć!"
\s; "To jest łańcuch"
\s; "x"
\s; "" // pusty łańcuch
\n;
Dwa łańcuchy można złączać, używając operatora \c;+\n;:
\s;\c; "Dzień dobry" + " " + "Panu"
\n;
Daje w wyniku łańcuch:
\s;\c; "Dzień dobry Panu"
\n;
Aby użyć cudzysłowu (") lub odwróconej kreski ułamkowej (\) w łańcuchu, należy napisać¦:
\s;\c;"To jest \"bardzo\" ważne"
\n;czego wynikiem będzie \c; To jest "bardzo" ważne.
\s;\c;"%user%\\ant.txt"
\n;czego wynikiem będzie \c;%user%\ant.txt
\n;
Następujące instrukcje mogą być używane na łańcuchach¦:
\c;\l;strlen\u cbot\strlen; \n;Podaje długość łańcucha
\c;\l;strleft\u cbot\strleft; \n;Wyodrębnia lewą część
\c;\l;strright\u cbot\strright; \n;Wyodrębnia prawą część
\c;\l;strmid\u cbot\strmid; \n;Wyodrębnia środkową część
\c;\l;strfind\u cbot\strfind; \n;Znajduje podłańcuch
\c;\l;strval\u cbot\strval; \n;Zamienia łańcuch na liczbę
\c;\l;strupper\u cbot\strupper; \n;Zamienia litery na wielkie
\c;\l;strlower\u cbot\strlower; \n;Zamienia litery na małe
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

31
help/P/cbot/TERM.TXT.bak
View File

@ -1,31 +0,0 @@
\b;Średnik
Po prostych wyrażeniach zawsze należy używać średnika \c;;\n;. Na przykład:
\c;
\s; int licznik = 0;
\n;
Nie należy jednak używać średnika na zakończenie \l;bloku\u cbot\bloc;:
\c;
\s; {
\s; float odl;
\s; odl = distance(p1, p2);
\s; } \n;// tutaj bez średnika!\c;
\n;
Nie należy również stosować średnika bezpośrednio po instrukcjach \c;\l;while\u cbot\while;\n;, \c;\l;if\u cbot\if;\n; lub \c;\l;for\u cbot\for;\n;:
\c;
\s; if ( a < b ) \n;// tutaj bez średnika!\c;
\s; {
\s; b = 100-a;
\s; }
\n;
Ponieważ instrukcje zawsze kończą się średnikiem a nie znakiem końca linii, można umieścić kilka instrukcji w jednej linii:
\c;
\s; int d=20;
\s; move(d);
\s; turn(90);
\n;
Jest równoważne:
\c;
\s; int d=20; move(d); turn(90);
\n;
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

13
help/P/cbot/THUMP.TXT.bak
View File

@ -1,13 +0,0 @@
\b;Instrukcja \c;thump\n;
Składnia:
\s;\c;thump ( );\n;
Uruchamia system broni robota \l;uderzacza\u object\bottump;, który przewraca mrówki i pająki do góry brzuchem, powodując ich chwilowe unieszkodliwienie.
\t;Typ wyniku: \c;\l;int\u cbot\int;\n;
Zero w przypadku powodzenia lub inna wartość, jeśli wystąpił błąd.
\c;== 0 \n;Uderzenie wykonane
\c;!= 0 \n;Operacja niemożliwa
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

14
help/P/cbot/TOPO.TXT.bak
View File

@ -1,14 +0,0 @@
\b;Instrukcja \c;topo\n;
Składnia:
\s;\c;topo ( pozycja );\n;
Podaje wysokość gruntu w podanej pozycji. Wysokość zerowa odpowiada poziomowi morza. Wartość ujemna oznacza, że sprawdzany punkt jest przykryty wodą.
\t;pozycja: \c;\l;point\u cbot\point;\n;
Współrzędne pozycji, której wysokość ma być sprawdzona.
\t;Typ wyniku: \c;\l;float\u cbot\float;\n;
Wysokość gruntu w podanej pozycji.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

5
help/P/cbot/TRUE.TXT.bak
View File

@ -1,5 +0,0 @@
\b;Typ \c;true\n;
Wartość ta oznacza, że warunek jest prawdziwy; jest to jedna z dwóch wartości \l;zmiennej\u cbot\var; typu \l;boolean\u cbot\bool;.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

33
help/P/cbot/TURN.TXT.bak
View File

@ -1,33 +0,0 @@
\b;Instrukcja \c;turn\n;
Instrukcja \c;turn();\n; służy do wykonania przez robota obrotu o określoną liczbę stopni.
\b;Podstawowe użycie
90 stopni oznacza ćwierć obrotu, 180 stopni to pół obrotu. Kąt dodatni to obrót przeciwny do ruchu wskazówek zegara, kąt ujemny oznacza obrót zgodny z ruchem wskazówek zegara. Oto kilka przykładów użycia instrukcji \c;turn();\n;:
\c;turn(90);\n; ćwierć obrotu w lewo
\c;turn(-90);\n; ćwierć obrotu w prawo (ujemny kąt)
\c;turn(180);\n; połowa obrotu
Aby obrócić robota w kierunku obiektu znalezionego przy użyciu instrukcji \c;\l;radar\u cbot\radar;();\n;, należy obliczyć kąt obrotu przy pomocy instrukcji \c;\l;direction\u cbot\direct;()\n;:
\c;
\s; item = \l;radar\u cbot\radar;(AlienSpider);
\s; turn(\l;direction\u cbot\direct;(item.position));
\n;
Po tych liniach wystarczy wystrzelić z działa i już mamy jednego wroga mniej.
\b;Dla specjalistów
Składnia:
\s;\c;turn ( kąt );\n;
Obraca robota o podany kąt, w prawo lub w lewo, bez poruszania do przodu ani do tyłu.
\t;kąt: \c;\l;float\u cbot\float;\n;
Kąt obrotu w stopniach. Wartość dodatnia to obrót w lewo, ujemna - w prawo. \c;turn(180)\n; obraca do tyłu.
\t;Typ wyniku: \c;\l;int\u cbot\int;\n;
Zero w przypadku powodzenia lub inna wartość, jeśli wystąpił błąd.
\c;== 0 \n;obrót wykonany
\c;!= 0 \n;obrót niemożliwy
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

33
help/P/cbot/TYPE.TXT.bak
View File

@ -1,33 +0,0 @@
\b;Typy zmiennych
Definiując \l;zmienną\u cbot\var; należy podać dwa elementy:
1) nazwę
2) typ
Po zdefiniowaniu zmiennej można w niej umieszczać informacje. Jednakże informacja, którą może przechowywać zmienna musi być odpowiedniego typu: zmienna typu \l;float\u cbot\float; nie może zawierać łańcucha itd.
W programie typy zmiennych wyświetlane są na \type;zielonym tle\norm;. Jeśli jest inaczej, prawdopodobnie w nazwie jest literówka. Nazwy typów są zawsze zapisywane małymi literami. Oto lista różnych typów:
\s;\c;\l;int\u cbot\int;\n;
Dla liczb całkowitych (12, -500, itd.)
\s;\c;\l;float\u cbot\float;\n;
Dla liczb rzeczywistych (12, 3.14, 0.2, -99.98, itd.)
\s;\c;\l;bool\u cbot\bool;\n;
Dla zmiennych logicznych, które mogą zawierać wartości \c;true\n; lub \c;false\n;
\s;\c;\l;string\u cbot\string;\n;
Dla tekstów ("Cześć!", "Nie znaleziono obiektu", itd.)
\s;\c;\l;point\u cbot\point;\n;
Dla współrzędnych punktu w przestrzeni; zmienna tego typu składa się z trzech części nazwanych x, y oraz z.
\s;\c;\l;object\u cbot\object;\n;
Zmienna tego typu może zawierać informacje o obiekcie (robocie, budynku, wrogu, itd.)
\s;\c;\l;void\u cbot\void;\n;
Jest to "typ pusty", używany wtedy, gdy nie chcemy określać typu.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

67
help/P/cbot/VAR.TXT.bak
View File

@ -1,67 +0,0 @@
\b;Zmienne
Zmienna jest jak pudełko, do którego można wkładać różne informacje. Wartość zmiennej może się zmieniać podczas wykonywania programu.
Na przykład można użyć zmiennej do liczenia jednostek rudy tytanu zebranych i przeniesionych przez transporter do huty. Najpierw należy ustalić odpowiednią nazwę dla zmiennej: nie powinna być ona zbyt długa, ale powinna wyjaśniać do czego używana jest zmienna. Nazwijmy ją \c;liczTyt\n;. Zmienna ta będzie zawierała tylko liczby całkowite, dlatego odpowiednim dla niej typem będzie \c;int\n;. Na początku programu zmienną trzeba zadeklarować. Następnie można w niej umieścić wartość \c;0\n;, zwiększając ją o \c;1\n; za każdym razem, gdy robot podniesie rudę tytanu. Zmienna ta będzie zawierać liczbę porcji rudy tytanu zebranych do tej pory przez robota.
Aby zadeklarować zmienną, należy napisać:
\c;\s; int liczTyt;\n;
Aby przypisać jej wartość \c;0\n;, należy napisać:
\c;\s; liczTyt = 0;\n;
Po zebraniu każdej porcji rudy tytanu należy napisać:
\c;\s; liczTyt = liczTyt + 1\n;
W wyborze nazwy dla zmiennej jest dużo swobody, można ją nazwać dowolnie, np.: \c;odl\n;, \c;kierunek\n;, \c;p2\n;, \c;a\n;, \c;x\n;, \c;nic_do_zestrzelenia\n;, itd.
Nazwa zmiennej musi zaczynać się od litery, po której może następować dowolna kombinacja liter, cyfr i znaków podkreślenia \c;_\n;. Oczywiście nie można używać słów kluczowych języka CBOT takich jak \c;\l;for\u cbot\for;\n;, \c;\l;while\u cbot\while;\n;, \c;\l;break\u cbot\break;\n;, \c;\l;continue\u cbot\continue;\n;, \c;do\n;, itd.
Należy być ostrożnym w wyborze nazw przydzielanych zmiennym; pisanie programu może okazać się bardzo trudne jeśli zapomni się nazwy zmiennych lub nie pamięta do czego one służyły. Należy opracować własny system nazywania zmiennych i raczej nie używać nazw podobnych do \c;Bmo45\n;, \c;a\n; czy \c;tgBinX\n;.
W powyższym przykładzie, słowo \c;int\n; określa, że zmienna może zawierać tylko liczby całkowite, odpowiednie do liczenia obiektów. Do mierzenia odległości lepiej jest użyć zmiennej, która może również zawierać liczby rzeczywiste z częścią ułamkową (takie jak 3.45 lub 0.034): w tym przypadku odpowiedniejszy jest typ \c;float\n;.
Zmienna składa się z trzech części:
1) nazwy
2) typu informacji przez nią przechowywanych
3) zawartości, czyli samej informacji
\t;nazwa
Jest niezbędna do rozróżniania zmiennych pomiędzy sobą.
\t;typ
\l;Typ\u cbot\type; warunkuje rodzaj informacji, jaką może zawierać zmienna. Zależnie od typu, zmienna może zawierać liczby całkowite, liczby rzeczywiste, łańcuchy, współrzędne punktu, informacje o obiekcie, itd.
Oto lista najczęściej występujących typów zmiennych:
o \c;\l;int\u cbot\int;\n; dla liczb całkowitych (12, -500, itd.)
o \c;\l;float\u cbot\float;\n; dla liczb rzeczywistych (3.14, 0.2, -99.98, itd.)
o \c;\l;string\u cbot\string;\n; dla łańcuchów znakowych ("Cześć!", "Nie znaleziono obiektu", itd.)
o \c;\l;point\u cbot\point;\n; dla współrzędnych x, y, z w przestrzeni
o \c;\l;object\u cbot\object;\n; dla informacji o obiekcie (robocie, budynku, itd.)
\t;zawartość
Zawartością zmiennej jest informacja, której rodzaj jest określony przez typ. Może się ona zmieniać w trakcie działania programu.
Po zadeklarowaniu zmiennej nie zawiera ona żadnej wartości. Zanim będzie można jej użyć, trzeba nadać jej wartość:
\c;\s; int i, j;
\s; j = 25; // j przyjmuje wartość 25
\s; j = i; // tak nie można napisać, gdyż i nie ma jeszcze żadnej wartości.
\n;
Możliwe jest zadeklarowanie zmiennej i przypisanie jej wartości w tym samym wierszu:
\c;\s; int liczTyt = 0;
\n;
Przy wykonywaniu przypisania wartości zmiennej przy użyciu znaku równości\c;=\n;, wartość z prawej strony jest kopiowana do wartości po lewej stronie. Rozważmy następujący przykład:
\c;\s; int i, j;
\s; i = 5+2; // i przyjmuje wartość 7
\s; j = i+6; // j przyjmuje wartość i plus 6, czyli 13
\s; i = j; // i przyjmuje wartość j, czyli 13
\n;
Na końcu tego przykładu obie zmienne \c;i\n; i \c;j\n; zawierają wartość \c;13\n;.
Następujące przypisanie jest niepoprawne, gdyż po lewej stronie znaku równości \c;=\n; może występować tylko nazwa zmiennej:
\c;\s; i+2 = j; // niemożliwe
\n;
Do zamiany zawartości dwóch zmiennych konieczne jest użycie trzeciej zmiennej. Oto przykład zamieniający zawartość zmiennych \c;a\n; i \c;b\n;:
\c;\s; int pom;
\s; pom = a; // pom przyjmuje wartość a
\s; a = b; // zawartość b jest kopiowana do a
\s; b = pom; // zawartość pom jest kopiowana do b
\n;
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

11
help/P/cbot/VOID.TXT.bak
View File

@ -1,11 +0,0 @@
\b;Typ \c;void\n;
Tego typu należy użyć do deklaracji funkcji, która nie zwraca żadnego wyniku.
Przykład:
\c;\s;void MojaFunkcja(int a)
\s;{
\s; ...
\s;}
\n
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

22
help/P/cbot/WAIT.TXT.bak
View File

@ -1,22 +0,0 @@
\b;Instrukcja \c;wait\n;
Instrukcja \c;wait();\n; każe robotowi czekać przez kilka sekund, zależnie od wartości podanej w nawiasach.
\b;Podstawowe użycie
Na naładowanie \l;ogniwa elektrycznego\u object\power; w stacji energetycznej należy poczekać 5 sekund używając instrukcji \c;wait(5);\n;.
Na przetopienie \l;rudy tytanu\u object\titanore; w \l;kostkę tytanu\u object\titan; w \l;hucie\u object\convert; należy poczekać 15 sekund używając instrukcji \c;wait(15);\n;.
\b;Dla specjalistów
Składnia:
\s;\c;wait ( czas );\n;
Czeka przez chwilę.
\t;czas: \c;\l;float\u cbot\float;\n;
Określa czas przez jaki robot powinien czekać.
\t;Typ wyniku: \c;\l;void\u cbot\void;\n;
Brak.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

11
help/P/cbot/abstime.txt.bak
View File

@ -1,11 +0,0 @@
\b;Instrukcja \c;abstime\n;
SkładniaŚ:
\s;\c;abstime ( );\n;
Zwraca czas (w sekundach) jaki upłynšł od poczštku misji.
\t;Typ wyniku: \c;\l;float\u cbot\float;\n;
Czas w sekundach.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

31
help/P/cbot/array.txt.bak
View File

@ -1,31 +0,0 @@
\b;Tablice
Tablica jest zestawem obiektów tego samego typu lub klasy. W języku CBOT można używać N wymiarowych tablic. Każdy wymiar jest ograniczony do 9999 elementów. Aby zadeklarować tablicę, należy użyć nawiasów kwadratowych \c;[]\n; po nazwie zmiennej lub nazwie typu.
\c;
\s;int [ ] a; // tablica typu int
\s;int a [12]; // tablica typu int ograniczona do 12 elementów
\s;string s[3]; // tablica 3 elementów typu string
\s;float xy[][]; // 2 wymiarowa tablica typu float
\n;
W rzeczywistości, gdy interpreter języka CBOT napotka deklarację tablicy, tworzy jedynie \l;wskażnik\u cbot\pointer; \c;\l;null\u cbot\null;\n;:
\c;
\s;int a[5]; // jest teraz wskaźnikiem null
\n;
Z chwilą wstawienia wartości do tablicy, tworzone są elementy i inicjalizowany jest wskaźnik:
\c;
\s;a[2] = 213; // tablica a wskazuje na
\s; // 3 elementy: [0], [1] i [2]
\n;
Po tej operacji, zmienna \c;a\n; zawiera wskaźnik do elementów tablicy. Elementy \c;[0]\n; i \c;[1]\n; są tworzone, ale nie inicjalizowane, gdyż tablica nie może zawierać pustych elementów. Instrukcja \c;\l;sizeof\u cbot\sizeof;\n; umożliwia sprawdzenie liczby elementów tablicy.
Gdy określony jest rozmiar maksymalny deklarowanej tablicy, program zatrzyma się w przypadku próby dostępu poza tablicę. Błąd ten nie jest sygnalizowany podczas kompilacji, nawet jeśli jest oczywisty:
\c;
\s;{
\s; int a[5];
\s; a[7] = 123; // nie ma błędu podczas kompilacji
\s; // ale pojawia się podczas działania programu
\s;}
\n;
Jeśli tablica przekazywana jest jako parametr \l;funkcji\u cbot\function;, funkcja otrzymuje jedynie \l;wskaźnik\u cbot\pointer; do tablicy. Oznacza to, że w przypadku modyfikacji elementu tablicy wewnątrz funkcji, zostanie w rzeczywistości zmodyfikowany element tablicy przekazanej funkcji jako parametr.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

49
help/P/cbot/bloc.txt.bak
View File

@ -1,49 +0,0 @@
\b;Bloki
Do zgrupowania razem kilku instrukcji można użyć nawiasów klamrowych \c;{ }\n; i utworzyć z nich jeden blok, na przykład:
\c;
\s; {
\s; float t;
\s; t = a;
\s; a = b;
\s; b = t; // zamienia zawartości a i b
\s; }
\n;
Każda instrukcja w bloku zakończona jest \l;średnikiem\u cbot\term; ale sam blok już nie.
W celu zilustrowania użycia bloków w programie rozważmy następujący przykład z instrukcją \c;\l;if\u cbot\if;\n;:
\c;
\s; if ( a < b )
\s; \n;instrukcja 1\c;;
\s; \n;instrukcja 2\c;;
\s; \n;instrukcja 3\c;;
\n;
Jeśli \l;warunek\u cbot\cond; jest prawdziwy, wykonywane są instrukcje 1, 2 i 3. Jeśli nie, tylko instrukcja 1 jest pomijana, instrukcje 2 i 3 są wykonywane. Fakt, że instrukcja 2 jest na tym samym poziomie co instrukcja 1 nie ma znaczenia.
Jeśli instrukcje 1 i 2 mają być wykonywane tylko gdy warunek jest prawdziwy, należy użyć nawiasów klamrowych do złączenie ich w jeden blok:
\c;
\s; if ( a < b )
\s; {
\s; \n;instrukcja 1\c;;
\s; \n;instrukcja 2\c;;
\s; }
\s; \n;instrukcja 3\c;;
\n;
Bloki mogą być niezbędne w przypadku instrukcji \c;\l;if\u cbot\if;\n;, \c;\l;while\u cbot\while;\n; oraz \c;\l;for\u cbot\for;\n;, w celu zgrupowania instrukcji, które mają być wykonywane tylko w przypadku prawdziwości warunku bądź powtarzane wielokrotnie.
Bloki można umieszczać wewnątrz innych bloków dowolną liczbę razy. Oto przykład dwupoziomowego zagnieżdżenia:
\c;
\s; if ( a > b )
\s; {
\s; int i = 0;
\s; while ( i < 18 )
\s; {
\s; move(10);
\s; turn(5);
\s; i = i+1;
\s; }
\s; }
\n;
Aby poprawić czytelność programu, najlepiej jest wyrównać klamrę otwierającą\c;{\n; z zamykającą \c;}\n;, chociaż nie jest to obowiązkowe. Następujący przykład zajmuje mniej miejsca i jest równoważny poprzedniemu, nie jest jednak polecane używanie takiego stylu:
\c;
\s; if(a>b) { int i=0; while(i<18) {
\s; move(10);turn(5);i=i+1; }}
\n;
\t;Zobacz również
\l;Instrukcje\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

108
help/P/cbot/category.txt.bak
View File

@ -1,108 +0,0 @@
\b;\c;Kategorie\n; wartości
Kategorie to nazwy obiektów języka CBOT. W grze COLOBOT wszystko to obiekty: roboty, budynki, surowce, itd., nawet Ty.
W programie kategorie są wyświetlane na \const;czerwonym tle\norm;. Jeśli kategoria nie jest podświetlona na czerwono, w jej nazwie jest literówka. Wielkie i małe litery powinny być zachowane.
Poniżej wymienione są różne dostępne kategorie:
\t;Budynki:
\button 176; \c;\l;Houston\u object\Huston; \n;Centrum Kontroli Misji
\button 171; \c;\l;SpaceShip\u object\base; \n;Statek kosmiczny
\button 160; \c;\l;BotFactory\u object\factory; \n;Fabryka robotów
\button 163; \c;\l;ResearchCenter\u object\research; \n;Centrum badawcze
\button 168; \c;\l;RadarStation\u object\radar; \n;Radar
\button 172; \c;\l;ExchangePost\u object\exchange; \n;Stacja przekaźnikowa informacji
\button 169; \c;\l;RepairCenter\u object\repair; \n;Warsztat
\button 165; \c;\l;DefenseTower\u object\tower; \n;Wieża obronna
\button 166; \c;\l;AutoLab\u object\labo; \n;Analizator materii organicznej
\button 164; \c;\l;PowerStation\u object\station; \n;Elektrownia
\button 167; \c;\l;PowerPlant\u object\energy; \n;Fabryka ogniw elektrycznych
\button 170; \c;\l;NuclearPlant\u object\nuclear; \n;Elektrownia atomowa
\button 162; \c;\l;Converter\u object\convert; \n;Huta tytanu
\button 161; \c;\l;Derrick\u object\derrick; \n;Kopalnia
\button 174; \c;\l;PowerCaptor\u object\captor; \n;Paraboliczny odgromnik
\button 175; \c;\l;Vault\u object\safe; \n;Skrytka
\c;\l;StartArea\u object\start; \n;Podest startowy
\c;\l;GoalArea\u object\goal; \n;Podest końcowy
\c;\l;AlienNest\u object\nest; \n;Gniazdo Obcych
\t;Obiekty przenośne:
\c;\l;TitaniumOre\u object\titanore; \n;Ruda tytanu
\c;\l;UraniumOre\u object\uranore; \n;Ruda uranu
\c;\l;Titanium\u object\titan; \n;Kostka przetopionego tytanu
\c;\l;PowerCell\u object\power; \n;Zwykłe ogniwo elektryczne
\c;\l;NuclearCell\u object\atomic; \n;Atomowe ogniwo elektryczne
\c;\l;OrgaMatter\u object\bullet; \n;Materia organiczna
\c;\l;BlackBox\u object\bbox; \n;Czarna skrzynka
\c;\l;TNT\u object\tnt; \n;Materiały wybuchowe
\c;\l;KeyA..D\u object\key; \n;Klucze A, B, C i D
\t;Roboty:
\button 158; \c;\l;PracticeBot\u object\bottr; \n;Robot treningowy
\button 173; \c;\l;TargetBot\u object\bottarg; \n;Robot cel
\button 137; \c;\l;WheeledGrabber\u object\botgr; \n;Transporter na kołach
\button 138; \c;\l;TrackedGrabber\u object\botgc; \n;Transporter na gąsienicach
\button 139; \c;\l;WingedGrabber\u object\botgj; \n;Transporter latający
\button 150; \c;\l;LeggedGrabber\u object\botgs; \n;Transporter na nogach
\button 140; \c;\l;WheeledSniffer\u object\botsr; \n;Szperacz na kołach
\button 141; \c;\l;TrackedSniffer\u object\botsc; \n;Szperacz na gąsienicach
\button 142; \c;\l;WingedSniffer\u object\botsj; \n;Szperacz latający
\button 152; \c;\l;LeggedSniffer\u object\botss; \n;Szperacz na nogach
\button 143; \c;\l;WheeledShooter\u object\botfr; \n;Działo na kołach
\button 144; \c;\l;TrackedShooter\u object\botfc; \n;Działo na gąsienicach
\button 145; \c;\l;WingedShooter\u object\botfj; \n;Działo latające
\button 151; \c;\l;LeggedShooter\u object\botfs; \n;Działo na nogach
\button 153; \c;\l;WheeledOrgaShooter\u object\botor; \n;Działo organiczne na kołach
\button 154; \c;\l;TrackedOrgaShooter\u object\botoc; \n;Działo organiczne na gąsienicach
\button 155; \c;\l;WingedOrgaShooter\u object\botoj; \n;Latające działo organiczne
\button 156; \c;\l;LeggedOrgaShooter\u object\botos; \n;Działo organiczne na nogach
\button 149; \c;\l;Subber\u object\botsub; \n;Robot nurek
\button 148; \c;\l;Recycler\u object\botrecy; \n;Robot recykler
\button 157; \c;\l;Shielder\u object\botshld; \n;Robot osłaniacz
\button 146; \c;\l;Thumper\u object\bottump; \n;Robot uderzacz
\button 147; \c;\l;PhazerShooter\u object\botphaz; \n;Działo fazowe
\t;Wrogowie:
\c;\l;AlienQueen\u object\mother; \n;Królowa Obcych
\c;\l;AlienEgg\u object\egg; \n;Jajo Obcych
\c;\l;AlienAnt\u object\ant; \n;Mrówka
\c;\l;AlienSpider\u object\spider; \n;Pająk
\c;\l;AlienWasp\u object\wasp; \n;Osa
\c;\l;AlienWorm\u object\worm; \n;Robal
\t;Różne:
\button 136; \c;\l;Me\u object\human; \n;Ty!
\c;\l;Mine\u object\mine; \n;Mina
\c;\l;Barrier\u object\barrier; \n;Bariera
\c;\l;Wreck\u object\wreck; \n;Szczątki robota
\c;\l;Ruin\u object\ruin; \n;Szczątki budynku
\t;Flagi i inne znaczniki:
\c;\l;BlueFlag\u object\flag; \n;Niebieska flaga
\c;\l;RedFlag\u object\flag; \n;Czerwona flaga
\c;\l;GreenFlag\u object\flag; \n;Zielona flaga
\c;\l;YellowFlag\u object\flag; \n;Żółta flaga
\c;\l;VioletFlag\u object\flag; \n;Fioletowa flaga
\c;\l;WayPoint\u object\waypoint; \n;Punkt kontrolny
\c;\l;EnergySite\u object\enerspot; \n;Podziemne źródło energii
\c;\l;TitaniumSite\u object\stonspot; \n;Podziemne złoże tytanu
\c;\l;UraniumSite\u object\uranspot; \n;Podziemne złoże uranu
\t;Zobacz również
\l;Język CBOT\u cbot; i \l;zmienne\u cbot\type;.

72
help/P/cbot/class.txt.bak
View File

@ -1,72 +0,0 @@
\b;Instrukcja \c;class\n;
Pozwala na zadeklarowanie definicji klasy, przy użyciu następującej składni:
\c;
\s;public class NazwaKlasy
\s;{
\s; deklaracje;
\s;}
\n;
Klasy mogą być tylko typu \l;public\u cbot\public; (publiczne), a więc mogą być używane podczas misji przez wszystkie roboty. Elementy klasy również są publiczne, dostępne spoza klasy. Do klasy mogą należeć pola lub funkcje (zwane również metodami), na przykład następująca klasa \c;MojaKlasa\n; zawiera 4 pola (a, b, x oraz s) i jedną metodę (MojaFunkcja).
\c;
\s;public class MojaKlasa
\s;{
\s; int a, b;
\s; float x = 3.33;
\s; string s = "Cześć";
\s; float MojaFunkcja( float value )
\s; {
\s; return (value*x)-1;
\s; }
\s;}
\n;
Jak pokazano na tym przykładzie, elementy klasy mogą być inicjalizowane (\c;x=3.33\n;). Można też zdefiniować konstruktor, który jest specjalną metodą o nazwie takiej samej jak nazwa klasy. Metoda ta jest wywoływana automatycznie podczas tworzenia instancji klasy. Możliwe jest również zadeklarowanie więcej niż jednej metody o tej samej nazwie ale o innych parametrach.
\c;
\s;public class MojaKlasa
\s;{
\s; int a, b;
\s; void MojaKlasa( )
\s; {
\s; a = 2; b = 3;
\s; }
\s; void MojaKlasa( int a, int b )
\s; {
\s; this.a = a; this.b = b;
\s; }
\s;}
\n;
W tym przykładzie zadeklarowano dwa konstruktory dla klasy \c;MojaKlasa\n;, jeden bez parametrów, drugi z dwoma parametrami. Jako że nazwy parametrów drugiego konstruktora są takie same jak nazwy dwóch pól klasy \c;a\n; et \c;b\n; konieczne jest użycie \c;\l;this\u cbot\this;.a\n; i \c;\l;this\u cbot\this;.b\n; w celu rozróżnienia parametrów. Inne, prostsze rozwiązanie, to nadanie różnych nazw parametrom.
\c;
\s;void Test( )
\s;{
\s; MojaKlasa element1(); // konstruktor bez parametrów
\s; MojaKlasa element2(4, 5); // konstruktor z 2 parametrami
\s; MojaKlasa element3; // konstruktor nie jest wywoływany,
\s; // więc item3 == null
\s;}
\n;
Można też zdefinować destruktor. Musi to być funkcja \c;void\n; bez parametrów o takiej samej nazwie jak nazwa klasy, poprzedzona znakiem ~. Destruktor jest wywoływany automatycznie gdy nie ma już żadnych odwołań do instancji klasy.
\c;
\s;public class MojaKlasa
\s;{
\s; static private int licznik = 0; // licznik instancji
\s; void MojaKlasa( )
\s; {
\s; licznik ++; // jedna instancja więcej
\s; }
\s; void ~MojaKlasa( )
\s; {
\s; licznik --; // jedna instancja mniej
\s; }
\s;}
\s;void Test()
\s;{
\s; MojaKlasa element1( ); // licznik = 1
\s; MojaKlasa element2( ); // licznik = 2
\s; element1 = null; // licznik = 1
\s;} // licznik = 0
\n;
W przypadku przekazywania instancji klasy jako parametru \l;funkcji\u cbot\function;, otrzymuje ona tylko \l;wskaźnik\u cbot\pointer; do instancji. Oznacza to, że jeśli zostanie zmodyfikowana instancja wewnątrz funkcji, w rzeczywistości zostanie zmodyfikowana instancja przekazana funkcji.
\t;Zobacz również
\c;\l;public\u cbot\public;\n;, \c;\l;private\u cbot\private;\n;, \c;\l;static\u cbot\static;\n;, \c;\l;synchronized\u cbot\synchro;\n;, \c;\l;new\u cbot\new;\n;, \c;\l;wskaźnik\u cbot\pointer;\n;, \c;\l;this\u cbot\this;\n;
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

8
help/P/cbot/close.txt.bak
View File

@ -1,8 +0,0 @@
\b;Instrukcja \c;close\n;
Zamyka plik otwarty wcześniej przy użyciu instrukcji \c;\l;open\u cbot\open;\n;. Jest to metoda klasy \c;\l;file\u cbot\file;\n;, wobec czego nie można napisać \c;close()\n;, lecz jedynie \c;handle.close()\n;¦:
\c;
\s; handle.close();
\n;
\t;Zobacz również
\c;\l;file\u cbot\file;\n;, \c;\l;open\u cbot\open;\n;, \c;\l;readln\u cbot\readln;\n;, \c;\l;writeln\u cbot\writeln;\n; i \c;\l;eof\u cbot\eof;\n;.
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

10
help/P/cbot/deletef.txt.bak
View File

@ -1,10 +0,0 @@
\b;Instrukcja \c;deletefile\n;
Instrukcja deletefile usuwa istniejšcy plik z folderu files/.
Pliki mogš być usuwane tylko w folderze files/ znajdujšcym się w folderze, w którym została zainstalowana gra Colobot. Nie jest możliwe usuwanie plików znajdujšcych się w innych folderach.
SkładniaŚ:
\s;\c;deletefile ( nazwa_pliku );\n;
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

15
help/P/cbot/delinfo.txt.bak
View File

@ -1,15 +0,0 @@
\b;Instrukcja \c;deleteinfo\n;
Składnia¦:
\s;\c;deleteinfo ( nazwa, moc );\n;
Usuwa istniejącą informację z najbliższej \l;stacji przekaźnikowej\u object\exchange;.
\t;nazwa: \c;string\n;
Nazwa informacji do usunięcia. Nazwa jest typu string i musi być napisana w cudzysłowach "¦".
\t;moc: \c;float\n;
Moc transmitera, odpowiadająca maksymalnej odległości pomiędzy nadawcą i stacją przekaźnikową. Jeśli odległość jest większa, informacja nie zostanie usunięta. Domyślana wartość to 10 metrów.
\t;Zobacz również
\c;\l;receive\u cbot\receive;\n;, \c;\l;send\u cbot\send;\n; i \c;\l;testinfo\u cbot\testinfo;\n;.
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

14
help/P/cbot/dist2d.txt.bak
View File

@ -1,14 +0,0 @@
\b;Instrukcja \c;distance2d\n;
Składnia:
\s;\c;distance2d ( pozycja1, pozycja2 );\n;
Oblicza odległość pomiędzy dwoma punktami (pomijając współrzędną z).
\t;pozycja1, pozycja2: \c;\l;point\u cbot\point;\n;
Współrzędne dwóch punktów.
\t;Typ wyniku: \c;\l;float\u cbot\float;\n;
Odległość między dwoma punktami.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

15
help/P/cbot/eof.txt.bak
View File

@ -1,15 +0,0 @@
\b;Instrukcja \c;eof\n;
Sprawdza warunek koñca otwartego pliku. Jest to metoda klasy \c;\l;file\u cbot\file;\n;; wobec czego zamiast \c;eof()\n; nale¿y napisaæ \c;handle.eof()\n;¦:
\c;
\s; if ( handle.eof() )
\n;
Przyk³ad¦:
\c;
\s; while ( not handle.eof() )
\s; {
\s; s = handle.readln();
\s; }
\n;
\t;Zobacz równie¿
\c;\l;file\u cbot\file;\n;, \c;\l;open\u cbot\open;\n;, \c;\l;close\u cbot\close;\n;, \c;\l;readln\u cbot\readln;\n; i \c;\l;writeln\u cbot\writeln;\n;.
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

33
help/P/cbot/errmode.txt.bak
View File

@ -1,33 +0,0 @@
\b;Instrukcja \c;errmode\n;
Instrukcja \c;errmode();\n; pozwala wybrać, czy program powinien zatrzymywać się w przypadku wystąpienia błędu w wykonywaniu jednej z następujących instrukcji: \c;\l;goto\u cbot\goto;\n;, \c;\l;move\u cbot\move;\n;, \c;\l;grab\u cbot\grab;\n;, \c;\l;drop\u cbot\drop;\n;, itd.
\b;Dla specjalistów
Składnia¦:
\s;\c;errmode ( tryb );\n;
Zwykle program zatrzymuje się po wystąpieniu błędu. Po użyciu instrukcji \c;errmode(0);\n; na początku programu, wymienione powyżej instrukcje dają w wyniku wartość różną od zera jeśli instrukcja nie mogła być wykonana.
\t;tryb: \c;\l;float\u cbot\float;\n; (domyślnie \c;1\n;)
Sposób traktowania błędu.
\c;0\n; -> kontynuuje działanie programu i daje w wyniku wartość różną od zera
\c;1\n; -> zatrzymuje program (działanie domyślne)
Przykład 1¦:
\s;\c;errmode(0);
\s;while ( goto(pos) != 0 )
\s;{
\s; wait(2);
\s;}
\n;
Przykład 2¦:
\s;\c;errmode(0);
\s;int err;
\s;err = goto(pozycja);
\s;if ( err != 0 )
\s;{
\s; \n;instrukcji goto nie udało się wykonać...\c;
\s; \n;podejmij odpowienie działania...\c;
\s;}
\n;
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

30
help/P/cbot/extern.txt.bak
View File

@ -1,30 +0,0 @@
\b;Instrukcja \c;extern\n;
Instrukcja \c;extern\n; wyróżnia \l;funkcję\u cbot\function;, która jest głównym programem robota. Nazwa funkcji zadeklarowanej jako \c;extern\n; pojawi się na liście programów w lewej dolnej części ekranu.
\c;
\s;extern void object::MowDown( )
\s;{
\s; while ( true )
\s; {
\s; fire(1);
\s; turn(10);
\s; }
\s;}
\n;
Jeśli program zawiera inne funkcje, tylko główna funkcja powinna być poprzedzona słowem \c;extern\n;.
\c;
\s;extern void object::Square( )
\s;{
\s; for ( int i=0 ; i<4 ; i++ )
\s; {
\s; Line(10);
\s; }
\s;}
\s;
\s;void object::Line(float dist)
\s;{
\s; move(dist);
\s; turn(90);
\s;}
\n;
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

18
help/P/cbot/file.txt.bak
View File

@ -1,18 +0,0 @@
\b;Typ \c;file\n;
Jest to typ wykorzystywany przy dostępie do plików znajdujących się w folderze files/.
\c;
\s; file handle();
\n;
Powyższej składni należ używać do deklarowania zmiennej plikowej. Konieczne jest użycie () do utworzenia instancji klasy \c;file\n;. Bez (), handle będzie wskazywać na \c;\l;null\u cbot\null;\n;.
Pliki mogą być tworzone i otwierane tylko w folderze files/, który znajduje sie w folderze instalacji gry Colobot. Nie jest możliwe tworzenie ani otwieranie plików poza folderem files/.
\b;Dla specjalistów
\c;file\n; w rzeczywistości nie jest typem prostym ale klasą. \c;open\n;, \c;close\n;, \c;writeln\n; itd. są metodami klasy \c;file\n;. Dlatego zawsze należy pisać \c;handle.method()\n;¦:
\c;
\s; handle.open("test.txt", "w");
\s; handle.close();
\n;
\t;Zobacz również
\c;\l;open\u cbot\open;\n;, \c;\l;close\u cbot\close;\n;, \c;\l;readln\u cbot\readln;\n;, \c;\l;writeln\u cbot\writeln;\n; i \c;\l;eof\u cbot\eof;\n;.
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

17
help/P/cbot/flatgrnd.txt.bak
View File

@ -1,17 +0,0 @@
\b;Instrukcja \c;flatground\n;
Składnia¦:
\s;\c;flatground ( center, rmax );\n;
Oblicza maksymalny promień płaskiego obszaru, na którym może być zbudowany budynek.
\t;center: \c;\l;point\u cbot\point;\n;
Środek kolistej strefy.
\t;rmax: \c;\l;float\u cbot\float;\n;
Maksymalny promień.
\t;Typ wyniku: \c;\l;float\u cbot\float;\n;
Promień płaskiego obszaru (zawsze pomiędzy 0 i rmax).
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

85
help/P/cbot/function.txt.bak
View File

@ -1,85 +0,0 @@
\b;Funkcje
Używając funkcji można podzielić program na kilka części, z których każda będzie wykonywała określone zadanie.
Wyobraźmy sobie następujący program¦:
\c;
\s;extern void object::Zdalnie( )
\s;{
\s; send("order", 1, 100);
\s; wait(5);
\s; send("order", 3, 100);
\s; wait(5);
\s; send("order", 2, 100);
\s; wait(5);
\s; send("order", 4, 100);
\s; wait(5);
\s;}
\n;
Instrukcje \c;send\n; i \c;wait\n; wykonywane są wielokrotnie. Byłoby dobrze utworzyć funkcję wykonującą te dwie instrukcje:
\c;
\s;void object::WyślijDoStacji( float op )
\s;{
\s; send("order", op, 100);
\s; wait(5);
\s;}
\s;extern void object::Zdalnie( )
\s;{
\s; WyślijDoStacji(1);
\s; WyślijDoStacji(3);
\s; WyślijDoStacji(2);
\s; WyślijDoStacji(4);
\s;}
\n;
Funkcja może mieć parametry¦:
\c;
\s;void Przykład( int a, float x, string s )
\n;
Funkcja \c;Przykład\n; dostaje jako parametry liczbę całkowitą \c;a\n;, liczbę zmiennoprzecinkową \c;x\n; oraz łańcuch \c;s\n;. Parametry są "przekazywane przez wartość", czyli są kopią wartości określonych jako zmienne podczas wywołania. Przy przekazaniu zmiennej \c;int\n; funkcji, jej parametr jest kopią wartości przekazanej jako argument, wobec czego funkcja może zmieniać wartość parametru bez zmiany wartości w miejscu, z którego była wywołana funkcja.
Przy przekazaniu instancji \l;klasy\u cbot\class; lub \l;tablicy\u cbot\array; jako parametru, funkcja otrzymuje jedynie \l;wskaźnik\u cbot\pointer; do instancji lub tablicy. Oznacza to, że w przypadku modyfikacji instancji lub tablicy wewnątrz funkcji, w rzeczywistości zostanie zmodyfikowana instancja lub tablica określona podczas wywołania.
Funkcja może również zwrócić wynik przy użyciu instrukcji \c;\l;return\u cbot\return;\n;. Jednakże powinna być wówczas zadeklarowana nie jako void, ale powinna mieć określony typ:
\c;
\s;float Średnia( float a, float b )
\s;{
\s; return (a+b)/2;
\s;}
\s;
\s;extern void object::Test( )
\s;{
\s; float wartość;
\s; wartość = Średnia(2, 6);
\s; message( wartość ); // wyświetli liczbę 4
\s;}
\n;
I jeszcze kilka przykładów¦:
\c;
\s;float Pi( )
\s;{
\s; return 3.1415;
\s;}
\s;
\s;string Znak( float a )
\s;{
\s; if ( a > 0 ) return "dodatnia";
\s; if ( a < 0 ) return "ujemna";
\s; return "zero";
\s;}
\n;
Można zadeklarować kilka funkcji o tej samej nazwie lecz o różnych parametrach¦:
\c;
\s;float Pitagoras( float a, float b )
\s;{
\s; return sqrt((a*a)+(b*b));
\s;}
\s;
\s;float Pitagoras( float a, float b, float c )
\s;{
\s; return sqrt((a*a)+(b*b)+(c*c));
\s;}
\n;
CBOT wywoła jedną z nich, w zależności od przekazanych parametrów.
Można też zadeklarować funkcję \l;publiczną\u cbot\public;, która będzie dostępna dla wszystkich robotów.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

39
help/P/cbot/motor.txt.bak
View File

@ -1,39 +0,0 @@
\b;Instrukcja \c;motor\n;
Instrukcja \c;motor( , );\n; ustawia prędkość lewego i prawego silnika robota.
\b;Podstawowe użycie
Prędkość nadana robotowi pozostaje niezmienna podczas wykonywania następujących instrukcji. Dzięki temu możliwe jest obracanie robota podczas wykonywania instrukcji \c;\l;fire\u cbot\fire;();\n;. Pozwala to na omiecenie całego obszaru jedną serią. Oto program omiatający całą strefę przed robotem:
\c;
\s; \l;turn\u cbot\turn;(45); // obróć o 45 stopnie w lewo
\s; motor(0.5, -0.5); // powoli obracaj w prawo
\s; \l;fire\u cbot\fire;(2); // strzelaj
\s; motor(0,0); // zatrzymaj obracanie
\n;
Z lewym silnikiem obracającym się z połową prędkości do przodu i prawym obracającym się z połową prędkości do tyłu, robot będzie się powoli obracał podczas 2 sekundowej serii strzałów.
\b;Dla specjalistów
Składnia:
\s;\c;motor ( lewy, prawy );\n;
Ustala prędkości prawego i lewego silnika. Silniki będą poruszały się z tą prędkością do czasu ustalenia nowej prędkości silników lub wykonania jednej z instrukcji: \c;\l;move\u cbot\move;\n;, \c;\l;turn\u cbot\turn;\n; lub \c;\l;goto\u cbot\goto;\n;.
\t;lewy: \c;\l;float\u cbot\float;\n;
Prędkość lewego silnika; wartości w zakresie od -1 do 1.
\t;prawy: \c;\l;float\u cbot\float;\n;
Prędkość prawego silnika; wartości w zakresie od -1 do 1.
Przykłady :
\c;motor(1, 1);\n; ruch do przodu z maksymalną prędkością.
\c;motor(-0.5, -0.5);\n; ruch do tyłu z połową prędkości.
\c;motor(1, -1);\n; obrót w prawo z maksymalną prędkością.
Uwaga:
\c;motor(2, 2);\n; nie będzie poruszało robotem do przodu szybciej niż \c;motor(1, 1)\n;
\c;motor(-2, -2);\n; nie będzie poruszało robotem do tyłu szybciej niż \c;motor(-1, -1)\n;
\t;Typ wyniku: \c;\l;void\u cbot\void;\n;
Brak.
\t;Zobacz również
\l;Instrukcje\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

21
help/P/cbot/new.txt.bak
View File

@ -1,21 +0,0 @@
\b;Instrukcja \c;new\n; (dla specjalistów)
Operator \c;new\n; tworzy nową instancję \l;klasy\u cbot\class;:
\c;\s; MojaKlasa element; // jest teraz wskaźnikiem null
\s; element = new MojaKlasa(); // jest teraz wskaźnikiem
\s; // do nowej instancji klasy
\n;
W przypadku tworzenia nowej instancji podczas deklaracji, można ominąć operator \c;new\n;, dodając () na końcu deklaracji:
Zamiast:
\c;\s; MojaKlasa element = new MojaKlasa();
\n;można napisać:
\c;\s; MojaKlasa element();
\n;
Jeśli klasa ma konstruktor z parametrami, można napisać:
\c;\s; MojaKlasa element = new MojaKlasa(2, 3);
\n;lub:
\c;\s; MojaKlasa element(2, 3);
\n;
\t;Zobacz również
\c;\l;klasa\u cbot\class;\n;, \c;\l;wskaźnik\u cbot\pointer;\n;
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

20
help/P/cbot/open.txt.bak
View File

@ -1,20 +0,0 @@
\b;Instrukcja \c;open\n;
Otwiera plik tekstowy w folderze files/. Jest to metoda klasy \c;\l;file\u cbot\file;\n;, dlatego zawsze należy używać konstrukcji \c;handle.open()\n;Ś:
\c;
\s; handle.open("test.txt", "w");
\n;
Aby otworzyć plik, należy postępować następujšcoŚ:
\c;
\s; file handle();
\s; handle.open("nazwapliku", "w");
\s; handle.writeln("abc");
\s; handle.close();
\n;
\c;"r"\n; tryb: otwarty do odczytu.
\c;"w"\n; tryb: otwarty do zapisu.
Pliki mogš być tworzone tylko w folderze files/ znajdujšcym się w folderze, w którym została zainstalowana gra Colobot. Nie jest możliwe tworzenie ani otwieranie plików znajdujšcych się w innych folderach.
\t;Zobacz również
\c;\l;file\u cbot\file;\n;, \c;\l;close\u cbot\close;\n;, \c;\l;readln\u cbot\readln;\n;, \c;\l;writeln\u cbot\writeln;\n; i \c;\l;eof\u cbot\eof;\n;.
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

11
help/P/cbot/openfile.txt.bak
View File

@ -1,11 +0,0 @@
\b;Instrukcja \c;openfile\n;
Instrukcja \c;openfile();\n; otwiera plik tekstowy w folderze files/. Nie jest to metoda klasy \c;\l;file\u cbot\file;\n; ale zwraca ona \l;wskaźnik\u cbot\pointer; do nowej instancji klasy file. Należy określić dwa parametry, nazwę pliku i tryb otwarcia.
\c;
\s;file handle = openfile("nazwapliku", "r");
\n;
\c;"r"\n; tryb: otwarty do odczytu.
\c;"w"\n; tryb: otwarty do zapisu.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

53
help/P/cbot/pointer.txt.bak
View File

@ -1,53 +0,0 @@
\b;Wskaźniki (dla specjalistów)
CBOT używa odwołań do \l;klas\u cbot\class; i \l;tablic\u cbot\array;. Każda zmienna w rzeczywistości zawiera odwołanie do instancji. Instancja natomiast zawiera pola klasy. Wiele wskaźników może odwoływać się do tej samej instancji. Wskaźnik \c;\l;null\u cbot\null;\n; nie odwołuje się do niczego. Instancję można porównać do teczki, a wskaźnik do trzymającego. Za każdym razem gdy potrzebujemy nowej teczki, tworzymy nową instancję z trzymającym. Ale teczka może być trzymana przez więcej niż jedną osobę. Osoba nie trzymająca żadnej teczki to wskaźnik na \c;\l;null\u cbot\null;\n;.
Przykład:
\c;\s;{
\s; MojaKlasa item1();// utwórz nową instancję
\s; // wskazywaną przez item1
\s; MojaKlasa item2; // utwórz wskaźnik null
\s; item2 = item1; // skopiuj wskaźnik,
\s; // item2 i item1 wskazują
\s; // teraz tę samą instancję
\s; item1.a = 12; // zmodyfikuj instancję
\s; // wskazywaną przez item1 (i item2)
\s; message(item2.a); // wyświetla liczbę 12
\s;}
\n;
W przypadku przekazania instancji \l;klasy\u cbot\class; jako parametru funkcji, funkcja otrzymuje wskaźnik do tej instancji. Oznacza to, że w przypadku modyfikacji instancji wewnątrz funkcji, zostanie zmodyfikowana instancja podana przy wywołaniu funkcji jako parametr.
\c;\s;void Test( MojaKlasa item )
\s;{
\s; item.a = 12; // zmodyfikuj oryginalną instancję
\s; item = new MojaKlasa(); // nowa instancja lokalna
\s; item.a = 33; // zmodyfikuj instancję lokalną
\s;}
\n;
Wywołanie funkcji \c;Test()\n;¦:
\c;\s;{
\s; MojaKlasa toto();
\s; Test(toto);
\s; message(toto.a); // wyświetla 12
\s;}
\n;
Instancja zawierająca pole \c;a = 33\n; jest wskazywana tylko przez nowoutworzoną instancję \c;item\n; wewnątrz funkcji \c;Test\n;. Na końcu funkcji \c;Test\n; ta instancja wskazywana przez \c;item\n; jest automatycznie usuwana.
Funkcja może zwrócić instancję¦:
\c;\s;MojaKlasa Test2( )
\s;{
\s; MojaKlasa item = new MojaKlasa();
\s; item.x = 33;
\s; return item;
\s;}
\n;
W taki sposób należy wywoływać funkcję:
\c;\s;{
\s; MojaKlasa toto;
\s; toto = Test2(); // toto będzie zawierać wskaźnik do
\s; // instancji utworzonej przez Test2()
\s; message(toto.a); // wyświetla 33
\s;}
\n;
\t;Zobacz również
\c;\l;class\u cbot\class;\n;, \c;\l;new\u cbot\new;\n;
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

19
help/P/cbot/private.txt.bak
View File

@ -1,19 +0,0 @@
\b;Instrukcja \c;private\n; (dla specjalistów)
Elementy \l;klasy\u cbot\class; mogą być \l;publiczne\u cbot\public; (domyślnie) lub prywatne. Aby zadeklarować element jako prywatny, należy umieścić instrukcję \c;private\n; przed deklaracją jego typu. Elementy prywatne nie są widoczne poza definicją klasy.
\c;
\s;public class MojaKlasa
\s;{
\s; int b; // publiczna domyślnie
\s; public int a; // również publiczna
\s; private point position; // prywatna
\s;}
\s;void Test()
\s;{
\s; MojaKlasa item;
\s; item.a = item.b = 12; // ok
\s; message( item.position ); // powoduje błąd
\s;}
\n;
\t;Zobacz również
\c;\l;class\u cbot\class;\n;, \c;\l;public\u cbot\public;\n;
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

51
help/P/cbot/public.txt.bak
View File

@ -1,51 +0,0 @@
\b;Instrukcja \c;public\n; (dla specjalistów)
Instrukcja ta ma dwa podstawowe zadania¦:
1) Czyni funkcję dostępną dla innych robotów.
2) Sprawia, że element klasy jest widoczny poza definicją klasy.
\b;Instrukcja \c;public\n; dla funkcji
Umieszczenie instrukcji \c;public\n; przed definicją \l;funkcji\u cbot\function; sprawi, że funkcja będzie dostępna dla innych robotów podczas tej misji.
Na przykład pierwszy robot może zawierać¦:
\c;
\s;public void object::Segment(float odl, float kąt)
\s;{
\s; move(odl);
\s; turn(kąt);
\s;}
\n;
A inny¦:
\c;
\s;extern void object::Kwadrat( )
\s;{
\s; for ( int i=0 ; i<4 ; i++ )
\s; {
\s; Segment(10, 90);
\s; fire(1);
\s; }
\s;}
\n;
Jeśli funkcję zadeklarowano jako \c;public\n;, nie można zadeklarować funkcji o tej samej nazwie i parametrach w innym robocie podczas tej samej misji.
Jeśli robot zawierający funkcję zadeklarowaną jako \c;public\n; zostanie zniszczony, inne roboty używające tej funkcji zatrzymają się sygnalizując wystąpienie błędu.
\b;Instrukcja \c;public\n; dla klas
Elementy \l;klasy\u cbot\class; mogą być publiczne (domyślnie) lub \l;prywatne\u cbot\private;. Aby zadeklarować element jako prywatny, należy umieścić instrukcję \c;private\n; przed deklaracją jego typu. Elementy prywatne nie są dostępne poza definicją klasy.
\c;
\s;public class MojaKlasa
\s;{
\s; int b; // publiczna domyślnie
\s; public int a; // również publiczna
\s; private point position; // prywatna
\s;}
\s;void Test()
\s;{
\s; MojaKlasa item;
\s; item.a = item.b = 12; // ok
\s; message( item.position ); // powoduje błąd
\s;}
\n;
\t;Zobacz również
\c;\l;class\u cbot\class;\n;, \c;\l;private\u cbot\private;\n;, \c;\l;funkcje\u cbot\function;\n;
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

20
help/P/cbot/readln.txt.bak
View File

@ -1,20 +0,0 @@
\b;Instrukcja \c;readln\n;
Wczytuje jednš linię z otwartego pliku w folderze files/. Jest to metoda klasy \c;\l;file\u cbot\file;\n;, dlatego też zawsze należy używać konstrukcji \c;handle.readln()\n;Ś:
\c;
\s; s = handle.readln();
\n;
Plik musi być otwarty do odczytu (\c;"r"\n;) przy użyciu instrukcji \c;\l;open\u cbot\open;\n;. Metoda \c;readln\n; zwraca cały wiersz ale bez znaków końca linii 0x0D (CR) i 0x0A (LF)
SkładniaŚ:
\s;\c;string = handle.readln ( );\n;
PrzykładŚ:
\c;
\s; string s;
\s; s = handle.readln();
\s; if ( s == "abc" )
\s; ...
\n;
\t;Zobacz również
\c;\l;file\u cbot\file;\n;, \c;\l;open\u cbot\open;\n;, \c;\l;close\u cbot\close;\n;, \c;\l;writeln\u cbot\writeln;\n; i \c;\l;eof\u cbot\eof;\n;.
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

19
help/P/cbot/send.txt.bak
View File

@ -1,19 +0,0 @@
\b;Instrukcja \c;send\n;
Składnia¦:
\s;\c;send ( nazwa, wartość, moc );\n;
Wysyła informację do najbliższej \l;stacji przekaźnikowej\u object\exchange;.
\t;nazwa: \c;string\n;
Nazwa informacji wysyłanej do stacji przekaźnikowej. Jest to łańcuch, który powinien być zapisany w cudzysłowach "¦".
Jeśli nie ma informacji o podanej nazwie, tworzony jest nowy wpis, o ile ich liczba nie przekroczy 10. Jeśli istnieje już informacja o podanej nazwie, zastępowana jest ona nową wartością.
\t;wartość: \c;float\n;
Wartość informacji do wysłania.
\t;moc: \c;float\n;
Moc transmitera, odpowiadająca maksymalnej odległości gdzie ma być przesłana informacja. Domyślna wartość to 10 metrów.
\t;Zobacz również
\c;\l;receive\u cbot\receive;\n;, \c;\l;testinfo\u cbot\testinfo;\n; i \c;\l;deleteinfo\u cbot\delinfo;\n;.
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

22
help/P/cbot/sizeof.txt.bak
View File

@ -1,22 +0,0 @@
\b;Instrukcja \c;sizeof\n;
Funkcja sizeof pozwala poznać ilość elementów zawartych w \l;tablicy\u cbot\array;.
Jest to indeks ostatniego elementu plus jeden (liczone są również "puste" elementy).
\c;
\s;{
\s; int a[12];
\s; a[5] = 345;
\s; message( sizeof(a) ); // wyświetli liczbę 6
\s;}
\n;
W tym przykładzie po operacji \c;a[5]=345\n; tablica ma 6 elementów. Liczone są również następujące niezainicjalizowane elementy: \c;[0]\n;, \c;[1]\n;, \c;[2]\n;, \c;[3]\n; i \c;[4]\n;.
W przypadku tablicy wielowymiarowej można otrzymać rozmiar podtablicy:
\c;
\s;float xy[][]; // tablica dwuwymiarowa
\s;xy[5][10] = 67;
\s;message( sizeof(xy) ); // wyświetli liczbę 6
\s;message( sizeof(xy[5]) ); // wyświetli liczbę 11
\s;
\n;
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

23
help/P/cbot/space.txt.bak
View File

@ -1,23 +0,0 @@
\b;Instrukcja \c;space\n;
Składnia:
\s;\c;space ( środek, rmin, rmaks, odl );\n;
Określa pozycję najbliższego wolnego miejsca w pobliżu podanej pozycji.
\t;środek: \c;\l;point\u cbot\point;\n; (domyślnie: pozycja robota)
Preferowana pozycja wolnego miejsca.
\t;rmin: \c;\l;float\u cbot\float;\n; (domyślna wartość: \c;8\n;)
Minimalna odległość od żądanej pozycji.
\t;rmaks: \c;\l;float\u cbot\float;\n; (domyślna wartość: \c;50\n;)
Maksymalna odległość od żądanej pozycji.
\t;odl: \c;\l;float\u cbot\float;\n; (domyślna wartość: \c;4\n;)
Wymagana odległość między dwoma wolnymi miejscami.
\t;Wynik: \c;\l;point\u cbot\point;\n;
Pozycja wolnego miejsca.
\t;Zobacz również
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

22
help/P/cbot/static.txt.bak
View File

@ -1,22 +0,0 @@
\b;Instrukcja \c;static\n; (dla specjalistów)
Elementy \l;klasy\u cbot\class; zadeklarowane jako \c;static\n; są współdzielone przez wszystkie instancje klasy.
\c;
\s;public class MojaKlasa
\s;{
\s; static int nb = 1;
\s; static string [ ] list = null;
\s;}
\s;void Test ()
\s;{
\s; MojaKlasa item1();
\s; MojaKlasa item2();
\s; item1.nb = 3;
\s; item1.list[item1.nb] = "Cześć";
\s; message( item2.list[item2.nb] ); // wyświetla komunikat "Cześć"
\s;}
\n;
Elementy \c;static\n; mogą być zadeklarowane jako \c;\l;private\u cbot\private;\n;, co spowoduje, że będą dostępne tylko dla elementów klasy (włączając konstruktory i destruktory).
\t;Zobacz również
\c;\l;class\u cbot\class;\n;, \c;\l;synchronized\u cbot\synchro;\n;
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

20
help/P/cbot/strfind.txt.bak
View File

@ -1,20 +0,0 @@
\b;Instrukcja \c;strfind\n;
Znajduje podci¹g w ³añcuchu i zwraca pozycjê pierwszego znalezionego podci¹gu lub wartoœæ \l;nan\u cbot\nan; jeœli podci¹gu nie znaleziono.
Sk³adnia¦:
\s;\c;strfind ( ³añcuch, sub );\n;
\t;³añcuch: \c;\l;string\u cbot\string;\n;
Przeszukiwany ³añcuch.
\t;sub: \c;\l;string\u cbot\string;\n;
Podci¹g, który ma zostaæ znaleziony.
Przyk³ady¦:
\s;\c; int pos = strfind("abcdef", "ab"); // pos równe 0
\s; int pos = strfind("abcdef", "de"); // pos równe 3
\s; int pos = strfind("abcdef", "xy"); // pos równe \l;nan\u cbot\nan;
\n;
\t;Zobacz równie¿
\c;\l;strlen\u cbot\strlen;\n;, \c;\l;strleft\u cbot\strleft;\n;, \c;\l;strright\u cbot\strright;\n;, \c;\l;strmid\u cbot\strmid;\n;, \c;\l;strval\u cbot\strval;\n;, \c;\l;strupper\u cbot\strupper;\n;, \c;\l;strlower\u cbot\strlower;\n;
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

16
help/P/cbot/strleft.txt.bak
View File

@ -1,16 +0,0 @@
\b;Instrukcja \c;strleft\n;
Wyodrêbnia pocz¹tkowe (najbardziej na lewo) znaki z ³añcucha.
Sk³adnia¦:
\s;\c;strleft ( ³añcuch, d³ugoœæ );\n;
\t;d³ugoœæ: \c;\l;int\u cbot\int;\n;
Liczba znaków do wyodrêbnienia.
Przyk³ady¦:
\s;\c; string s = strleft("abcdef", 2); // s równe "ab"
\s; string s = strleft("abc", 10); // s równe "abc"
\n;
\t;Zobacz równie¿
\c;\l;strlen\u cbot\strlen;\n;, \c;\l;strright\u cbot\strright;\n;, \c;\l;strmid\u cbot\strmid;\n;, \c;\l;strfind\u cbot\strfind;\n;, \c;\l;strval\u cbot\strval;\n;, \c;\l;strupper\u cbot\strupper;\n;, \c;\l;strlower\u cbot\strlower;\n;
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

14
help/P/cbot/strlen.txt.bak
View File

@ -1,14 +0,0 @@
\b;Instrukcja \c;strlen\n;
Podaje d³ugoœæ ³añcucha.
Sk³adnia¦:
\s;\c;strlen ( ³añcuch );\n;
Przyk³ady¦:
\s;\c; int len = strlen("abc"); // len równe 3
\s; int len = strlen(""); // len równe 0
\s; if ( strlen(s) == 0 ) // czy ³añcuch pusty?
\n;
\t;Zobacz równie¿
\c;\l;strleft\u cbot\strleft;\n;, \c;\l;strright\u cbot\strright;\n;, \c;\l;strmid\u cbot\strmid;\n;, \c;\l;strfind\u cbot\strfind;\n;, \c;\l;strval\u cbot\strval;\n;, \c;\l;strupper\u cbot\strupper;\n;, \c;\l;strlower\u cbot\strlower;\n;
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

12
help/P/cbot/strlower.txt.bak
View File

@ -1,12 +0,0 @@
\b;Instrukcja \c;strlower\n;
Zamienia wszystkie znaki ³añcucha na ma³e litery.
Sk³adnia¦:
\s;\c;strlower ( ³añcuch );\n;
Przyk³ady¦:
\s;\c; string s = strlower("Abc"); // s jest równe "abc"
\n;
\t;Zobacz równie¿
\c;\l;strlen\u cbot\strlen;\n;, \c;\l;strleft\u cbot\strleft;\n;, \c;\l;strright\u cbot\strright;\n;, \c;\l;strmid\u cbot\strmid;\n;, \c;\l;strfind\u cbot\strfind;\n;, \c;\l;strval\u cbot\strval;\n;, \c;\l;strupper\u cbot\strupper;\n;
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

20
help/P/cbot/strmid.txt.bak
View File

@ -1,20 +0,0 @@
\b;Instrukcja \c;strmid\n;
Wyodrêbnia z ³añcucha pod³añcuch o okreœlonej d³ugoœci i okreœlonej pozycji pocz¹tkowej.
Sk³adnia¦:
\s;\c;strmid ( ³añcuch, pozycja, d³ugoœæ );\n;
\t;pozycja: \c;\l;int\u cbot\int;\n;
Indeks pierwszego znaku, który powinien wyst¹piæ w wyodrêbnionym pod³añcuchu.
\t;d³ugoœæ: \c;\l;int\u cbot\int;\n;
Liczba znaków do wyodrêbnienia.
Przyk³ady¦:
\s;\c; string s = strmid("abcdef", 1, 2); // s równe "bc"
\s; string s = strmid("abcdef", 4, 5); // s równe "ef"
\s; string s = strmid("abcdef", 9, 2); // s równe ""
\n;
\t;Zobacz równie¿
\c;\l;strlen\u cbot\strlen;\n;, \c;\l;strleft\u cbot\strleft;\n;, \c;\l;strright\u cbot\strright;\n;, \c;\l;strfind\u cbot\strfind;\n;, \c;\l;strval\u cbot\strval;\n;, \c;\l;strupper\u cbot\strupper;\n;, \c;\l;strlower\u cbot\strlower;\n;
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

16
help/P/cbot/strright.txt.bak
View File

@ -1,16 +0,0 @@
\b;Instrukcja \c;strright\n;
Wyodrêbnia koñcowe (najbardziej na prawo) znaki z ³añcucha.
Sk³adnia¦:
\s;\c;strright ( ³añcuch, d³ugoœæ );\n;
\t;d³ugoœæ: \c;\l;int\u cbot\int;\n;
Liczba znaków do wyodrêbnienia.
Przyk³ady¦:
\s;\c; string s = strright("abcdef", 2); // s równe "ef"
\s; string s = strright("abc", 10); // s równe "abc"
\n;
\t;Zobacz równie¿
\c;\l;strlen\u cbot\strlen;\n;, \c;\l;strleft\u cbot\strleft;\n;, \c;\l;strmid\u cbot\strmid;\n;, \c;\l;strfind\u cbot\strfind;\n;, \c;\l;strval\u cbot\strval;\n;, \c;\l;strupper\u cbot\strupper;\n;, \c;\l;strlower\u cbot\strlower;\n;
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

12
help/P/cbot/strupper.txt.bak
View File

@ -1,12 +0,0 @@
\b;Instrukcja \c;strupper\n;
Zamienia wszystkie znaki ³añcucha na wielkie litery.
Sk³adnia¦:
\s;\c;strupper ( ³añcuch );\n;
Przyk³ady¦:
\s;\c; string s = strupper("Abc"); // s jest równe "ABC"
\n;
\t;Zobacz równie¿
\c;\l;strlen\u cbot\strlen;\n;, \c;\l;strleft\u cbot\strleft;\n;, \c;\l;strright\u cbot\strright;\n;, \c;\l;strmid\u cbot\strmid;\n;, \c;\l;strfind\u cbot\strfind;\n;, \c;\l;strval\u cbot\strval;\n;, \c;\l;strlower\u cbot\strlower;\n;
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

19
help/P/cbot/strval.txt.bak
View File

@ -1,19 +0,0 @@
\b;Instrukcja \c;strval\n;
Zamienia ³añcuch na liczbê. Nie nale¿y myliæ ³añcucha \c;"45"\n;, zawieraj¹cego dwa znaki \c;4\n; i \c;5\n; oraz liczby \c;45\n;.
Przyk³ady¦:
\s;\c; string s = "45"+"12"; // s zawiera "4512"
\s; float n = 45 + 12; // n zawiera 67
\n;
Sk³adnia¦:
\s;\c;strval ( ³añcuch );\n;
\n;
Przyk³ady¦:
\s;\c; float n = strval("1.23"); // n równe 1,23
\s; float n = strval("12abc45"); // n równe 12
\s; float n = strval("abc"); // n równe 0
\s; float n = strval("100")+2; // n równe 102
\n;
\t;Zobacz równie¿
\c;\l;strlen\u cbot\strlen;\n;, \c;\l;strleft\u cbot\strleft;\n;, \c;\l;strright\u cbot\strright;\n;, \c;\l;strmid\u cbot\strmid;\n;, \c;\l;strfind\u cbot\strfind;\n;, \c;\l;strupper\u cbot\strupper;\n;, \c;\l;strlower\u cbot\strlower;\n;
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

25
help/P/cbot/synchro.txt.bak
View File

@ -1,25 +0,0 @@
\b;Instrukcja \c;synchronized\n; (dla specjalistów)
Metoda \l;klasy\u cbot\class; może być zadeklarowana jako \c;synchronized\n;. Dzięki temu można zapewnić, że metoda będzie uruchamiana nie więcej niż przez jednego robota w tym samym czasie.
Następujący przykład pomoże zilustrować problem:
\c;
\s;class blokowanie
\s;{
\s; static int nb = 33;
\s; synchronized int inc( )
\s; {
\s; int val = nb;
\s; wait ( 2 ); // czekaj 2 sekundy
\s; nb = nb + 1;
\s; return val;
\s; }
\s;}
\n;
Co się dzieje, gdy dwa roboty wykonają metodę \c;inc\n; w tym samym czasie¦?
Oba wykonają polecenie \c;val=nb\n; i poczekają 2 sekundy, a więc oba otrzymają \c;val=33\n;. Gdy użyjemy instrukcji \c;synchronized\n; pierwszy robot rozpocznie wykonywanie z \c;val=33\n; poczeka 2 sekundy i wyjdzie z metody. Dopiero po zakończeniu wykonywania metody \c;inc\n; przez pierwszego robota, drugi robot będzie miał możliwość wykonania metody \c;inc\n;, wobec czego otrzyma on zawsze \c;val=34\n;.
Można mieć więcej niż jedną zsynchronizowaną metodę w \l;klasie\u cbot\class; w celu zapobieżenia równoczesnemu wykonywaniu więcej niż jednej metody. Innymi słowy: tak długo, jak długo robot jest wewnątrz zsynchronizowanej metody, żaden inny robot nie może wykonywać żadnej zsynchronizowanej metody tej samej klasy.
\t;Zobacz również
\c;\l;klasa\u cbot\class;\n;, \c;\l;static\u cbot\static;\n;
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

18
help/P/cbot/testinfo.txt.bak
View File

@ -1,18 +0,0 @@
\b;Instrukcja \c;testinfo\n;
Składnia¦:
\s;\c;testinfo ( nazwa, moc );\n;
Sprawdza czy istnieje żądana informacja w najbliższej \l;stacji przekaźnikowej\u object\exchange;.
\t;nazwa: \c;string\n;
Nazwa informacji do sprawdzenia. Jest ona łańcuchem i powinna być zapisana w cudzysłowach "¦".
\t;moc: \c;float\n;
Moc transmitera, odpowiadająca maksymalnej odległości pomiędzy transmiterem i stacją przekaźnikową. Jeśli odległość jest większa, funkcja zwraca wartość \c;false\n;. Domyślna wartość to 10 metrów.
\t;Typ wyniku: \c;\l;bool\u cbot\bool;\n;
Daje w wyniku \c;true\n; jesli informacja istnieje, oraz \c;false\n; jeśli informacja nie istnieje lub odbiorca jest za daleko od stacji przekaźnikowej.
\t;Zobacz również
\c;\l;receive\u cbot\receive;\n;, \c;\l;send\u cbot\send;\n; i \c;\l;deleteinfo\u cbot\delinfo;\n;.
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

54
help/P/cbot/this.txt.bak
View File

@ -1,54 +0,0 @@
\b;Instrukcja \c;this\n;
Czasami metoda \l;klasy\u cbot\class; potrzebuje wskaźnika do instancji, w której działa. Na przykład instancja może chcieć przekazać wskaźnik do samej siebie jako parametr dla innej funkcji. Odwołanie wprost poprzez \c;this\n; jest dostępne również dla metod; \c;this\n; jest odwołaniem do bieżącej instancji.
\c;
\s;public class MojaKlasa
\s;{
\s; int m_int;
\s; string m_str;
\s; void MojaFunkcja()
\s; {
\s; InnaFunkcja(this);
\s; m_int = 2;
\s; }
\s;}
\s;
\s;void InnaFunkcja(MojaKlasa obj)
\s;{
\s; message(obj.m_str);
\s;}
\s;
\s;extern void object::Test()
\s;{
\s; MojaKlasa item();
\s; item.m_str = "Cześć";
\s; item.MojaFunkcja(); // wyświetla "Cześć"
\s;}
\n;
Można również umieścić \c;this\n; przed nazwą pola w metodzie, ale nie jest to konieczne. W powyższym przykładzie metody \c;MojaFunkcja()\n; następujące dwie linie mają identyczne znaczenie:
\c;
\s; m_int = 2;
\s; this.m_int = 2; // identyczne
\n;
Również w metodzie klasy \c;\l;object\u cbot\object;\n; można użyć \c;this.\n; przed nazwą pola.
\c;
\s;extern void object::Display()
\s;{
\s; message(orientation);
\s; message(this.orientation); // to samo ale
\s; // bardziej jednoznacznie
\s;}
\n;
Jednakże jeśli nazwa pola jest ukryta poprzez deklarację parametru lub zmiennej, należy użyć \c;this\n;. W następującym przykładzie nazwa parametru \c;value\n; jest taka sama jak nazwa pola \c;value\n; w \l;klasie\u cbot\class; \c;MojaKlasa\n;, wobec tego w celu rozróżnienia pola od parametru, konieczne jest napisanie \c;this.value\n;.
\c;
\s;public class MojaKlasa
\s;{
\s; int value;
\s; void Put( int value )
\s; {
\s; this.value = value;
\s; }
\s;}
\n;
\t;Zobacz również
\c;\l;class\u cbot\class;\n;
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

47
help/P/cbot/while.txt.bak
View File

@ -1,47 +0,0 @@
\b;Instrukcja \c;while\n;
Instrukcja \c;while () {}\n; jest używana do wielokrotnego powtarzania zbioru instrukcji.
\b;Podstawowe użycie
Najczęstsze użycie instrukcji \c;while\n; polega na nieskończonym powtarzaniu zbioru instrukcji. Aby to osiągnąć, należy napisać \c;while (true) {}\n;, a instrukcje, które mają być powtarzane zapisać w nawiasach klamrowych \c;{}\n;. Oto przykładowy program powtarzający w nieskończoność następujące czynności:
o znajdź pająka,
o obróć się w jego stronę,
o strzelaj.
\c;
\s; while (true)
\s; {
\s; item = \l;radar\u cbot\radar;(AlienSpider);
\s; \l;turn\u cbot\turn;(direction(item.position));
\s; \l;fire\u cbot\fire;(1);
\s; }
\n;
Wystarczy raz uruchomić ten program, a zabije on wszystkie pająki dookoła robota.
\b;Dla specjalistów
Składnia:
\s;\c;while ( warunek )
\s;{
\s; \n;Instrukcje ...\c;
\s;}
\n;
Instrukcja ta pozwala na wielokrotne powtarzanie instrukcji wewnątrz \l;bloku\u cbot\bloc;.
Nie należy mylić instrukcji \c;while( ) { }\n; z instrukcją \c;\l;do\u cbot\do; { } while( );\n;; ta druga sprawdza warunek dopiero po pierwszym wykonaniu instrukcji w bloku.
\t;\c;warunek\n;
Instrukcje w bloku są wykonywane tak długo, jak długo prawdziwy jest \l;warunek\u cbot\cond;.
Oto przykład:
\s;\c;int i = 0;
\s;while ( i < 10 )
\s;{
\s; \n;Instrukcje...\c;
\s; i = i+1;
\s;}
\n;
\t;Uwaga
Na końcu instrukcji \c;while ( )\n; nie należy umieszczać \l;średnika\u cbot\term;.
Instrukcje \c;\l;break\u cbot\break;\n; i \c;\l;continue\u cbot\continue;\n; mogą być przydatne wewnątrz bloku instrukcji \c;while ( )\n;.
\t;Zobacz również
\l;Instrukcje\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

21
help/P/cbot/writeln.txt.bak
View File

@ -1,21 +0,0 @@
\b;Instrukcja \c;writeln\n;
Zapisuje linię tekstu do otwartego pliku w folderze files/. Jest to metoda klasy \c;\l;file\u cbot\file;\n;, dlatego też zawsze należy używać konstrukcji \c;handle.writeln()\n;Ś:
\c;
\s; handle.writeln("abc");
\n;
Plik musi być otwarty do zapisu (\c;"w"\n;) przy użyciu instrukcji \c;\l;open\u cbot\open;\n;. Zapisywany wiersz zostanie automatycznie zakończony znakami końca linii 0x0D (CR) i 0x0A (LF).
SkładniaŚ:
\s;\c;handle.writeln ( string );\n;
PrzykładyŚ:
\c;
\s; writeln("Linia tekstu");
\s; string s1 = "abc";
\s; string s2 = "def";
\s; writeln(s1 + " " + s2);
\n;
\t;Zobacz również
\c;\l;file\u cbot\file;\n;, \c;\l;open\u cbot\open;\n;, \c;\l;close\u cbot\close;\n;, \c;\l;readln\u cbot\readln;\n; i \c;\l;eof\u cbot\eof;\n;.
\l;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.

14
help/P/object/STONSPOT.TXT.bak
View File

@ -1,14 +0,0 @@
\b;Podziemne złoże tytanu
\image stonspot 4 4;
Czerwony plus oznacza występowanie w podglebiu pokładów \l;rudy tytanu\u object\titanore;. Można ją wydobyć używając \l;kopalni\u object\derrick;.
Robot \l;szperacz\u object\botsr; zostawia czerwony plus w miejscu odkrycia złoża. \l;Robot szperacz\u object\botsr; może również wykrywać obecność \l;rudy uranu\u object\uranore; oznaczonej \l;żółtym kółkiem\u object\uranspot; oraz energii oznaczonej \l;zielonym plusem\u object\enerspot;.
\t;Transport
Niemożliwy.
\t;\l;Kategoria\u cbot\category; obiektu
\c;TitaniumSite\n;
\t;Zobacz również
\l;Język CBOT\u cbot;, \l;zmienne\u cbot\type; i \l;kategorie\u cbot\category;.

14
help/P/object/TITAN.TXT.bak
View File

@ -1,14 +0,0 @@
\b;Tytan
\image titan 4 4;
Tytan jest niezastąpiony przy konstrukcji budynków, \l;robotów\u object\factory; oraz \l;zwykłych ogniw elektrycznych\u object\energy;. Zwykle jego niewielkie ilości można znaleźć na \l;statku kosmicznym\u object\base; na początku każdej misji.
Jeśli potrzeba więcej, należy \l;przetopić\u object\convert; kawałki \l;rudy tytanu\u object\titanore; w użyteczne kostki tytanu.
\t;Transport
Wszystkie \l;transportery\u object\botgr; oraz \l;astronauta\u object\human;.
\t;\l;Kategoria\u cbot\category; obiektu
\c;Titanium\n;
\t;Zobacz również
\l;Język CBOT\u cbot;, \l;zmienne\u cbot\type; i \l;kategorie\u cbot\category;.

14
help/P/object/TITANORE.TXT.bak
View File

@ -1,14 +0,0 @@
\b;Ruda tytanu
\image titanore 4 4;
\l;Tytan\u object\titan; jest niezastąpiony przy konstrukcji budynków, \l;robotów\u object\factory; oraz \l;zwykłych ogniw elektrycznych\u object\energy;. Tytan widziany przez \l;astronautę\u object\human; w jego użytkowej, sześciennej postaci powstał przez \l;przetopienie\u object\convert; surowych kawałków rudy tytanu.
Rudę tytanu można znaleźć na powierzchni lub w podglebiu. W drugim przypadku najpierw należy ją zlokalizować i zidentyfikować przy pomocy robota \l;szperacza\u object\botsr;, a następnie wydobyć używając \l;kopalni\u object\derrick;. W miejscu znalezienia rudy tytanu robot szperacz pozostawia \l;czerwony plus\u object\stonspot;.
\t;Transport
Wszystkie \l;transportery\u object\botgr; oraz \l;astronauta\u object\human;.
\t;\l;Kategoria\u cbot\category; obiektu
\c;TitaniumOre\n;
\t;Zobacz również
\l;Język CBOT\u cbot;, \l;zmienne\u cbot\type; i \l;kategorie\u cbot\category;.

12
help/P/object/TNT.TXT.bak
View File

@ -1,12 +0,0 @@
\b; Ładunek wybuchowy (TNT)
\image tnt 4 4;
Ładunek TNT jest bardzo czuły. Należy zbliżać się do niego bardzo ostrożnie, aby nie uderzyć go ani nie narażać na jakiekolwiek wstrzšsy. Po chwyceniu ładunku przez ramię \l;transportera\u object\botgr; ryzyko jest już minimalne.
\t;Transport
Wszystkie \l;transportery\u object\botgr; oraz \l;astronauta\u object\human;.
\t;\l;Kategoria\u cbot\category; obiektu
\c;TNT\n;
\t;Zobacz również
\l;Język CBOT\u cbot;, \l;zmienne\u cbot\type; i \l;kategorie\u cbot\category;.

22
help/P/object/TOWER.TXT.bak
View File

@ -1,22 +0,0 @@
\b;\button 165; Wieża obronna
\image tower 8 8;
Wieża umożliwia najlepszą obronę przeciwko atakom \l;wrogów\u object\mother;, zarówno naziemnych, jak i powietrznych.
Do działania wieży potrzebne jest \l;zwykłe\u object\power; lub \l;atomowe\u object\atomic; ogniwo elektryczne. Zwykłe ogniwo elektryczne umożliwia oddanie 8 strzałów. Oczywiście dużo lepsze jest ogniwo atomowe. Gdy skończy się energia, wieża sygnalizuje to miganiem.
Wieża ma zasięg 40 metrów. Aby go wyświetlić na powierzchni planety, należy zaznaczyć wieżę i nacisnąć przycisk <zasięgu> \button 41;. Czerwone kropki wyróżnią kolistą strefę przez 20 sekund.
\t;Wymagania
Płaska powierzchnia szeroka na minimum 3,5 metra.
\t;Źródło zasilania
Zwykłe lub atomowe ogniwo elektryczne.
\t;Czas działania
1 sekunda.
\t;\l;Kategoria\u cbot\category; obiektu
\c;DefenseTower\n;
\t;Zobacz również
\l;Język CBOT\u cbot;, \l;zmienne\u cbot\type; i \l;kategorie\u cbot\category;.

16
help/P/object/URANORE.TXT.bak
View File

@ -1,16 +0,0 @@
\b;Ruda uranu
\image uranore 4 4;
Uran jest niezbędny do produkcji \l;atomowych ogniw elektrycznych\u object\atomic;.
Rudę uranu można znaleźć na powierzchni lub w podglebiu. W drugim przypadku, najpierw należy ją zlokalizować i zidentyfikować przy pomocy robota \l;szperacza\u object\botsr;, a następnie wydobyć używając \l;kopalni\u object\derrick;. W miejscu znalezienia rudy uranu robot szperacz pozostawia \l;żółte kółko\u object\uranspot;.
\l;Elektrownia atomowa\u object\nuclear; może przetwarzać rudę uranu na nowe, w pełni naładowane\l;atomowe ogniwa elektryczne\u object\atomic;.
\t;Transport
Wszystkie \l;transportery\u object\botgr;. \l;Astronauta\u object\human; nie może przenosić rudy uranu z powodu jej radioaktywności.
\t;\l;Kategoria\u cbot\category; obiektu
\c;UraniumOre\n;
\t;Zobacz również
\l;Język CBOT\u cbot;, \l;zmienne\u cbot\type; i \l;kategorie\u cbot\category;.

15
help/P/object/URANSPOT.TXT.bak
View File

@ -1,15 +0,0 @@
\b; Podziemne złoże uranu
\image uranspot 4 4;
Żółte kółko oznacza występowanie w podglebiu pokładów \l;rudy uranu\u object\uranore;. Można ją wydobyć używając \l;kopalni\u object\derrick;.
Robot \l;szperacz\u object\botsr; zostawia żółte kółko w miejscu odkrycia złoża. \l;Robot szperacz\u object\botsr; może również wykrywać obecność \l;rudy tytanu\u object\titanore; oznaczonej \l;czerwonym plusem\u object\stonspot; oraz energii oznaczonej \l;zielonym plusem\u object\enerspot;.
\t;Transport
Niemożliwy.
\t;\l;Kategoria\u cbot\category; obiektu
\c;UraniumSite\n;
\t;Zobacz również
\l;Język CBOT\u cbot;, \l;zmienne\u cbot\type; i \l;kategorie\u cbot\category;.

11
help/P/object/WASP.TXT.bak
View File

@ -1,11 +0,0 @@
\b;Osa
\image wasp 8 8;
Osy sš obcš formš wrogiego życia, bardzo trudnš do zestrzelenia z powodu częstych zmian kierunku lotu. Osy przenoszš kule \l;materii organicznej\u object\bullet;, które zrzucajš z góry na roboty, budynki i astronautę.
Najłatwiej pozbyć się ich budujšc \l;wieżę obronnš\u object\tower;.
\t;\l;Kategoria\u cbot\category; obiektu
\c;AlienWasp\n;
\t;Zobacz również
\l;Język CBOT\u cbot;, \l;zmienne\u cbot\type; i \l;kategorie\u cbot\category;.

12
help/P/object/WAYPOINT.TXT.bak
View File

@ -1,12 +0,0 @@
\b;Punkt kontrolny
\image waypoint 4 4;
W ćwiczeniach niebieskie plusy oznaczają pozycje, które należy zaliczyć. Znikają one natychmiast po przejściu przez nie \l;robota treningowego\u object\bottr;.
\t;Transport
Niemożliwy.
\t;\l;Kategoria\u cbot\category; obiektu
\c;WayPoint\n;
\t;Zobacz również
\l;Język CBOT\u cbot;, \l;zmienne\u cbot\type; i \l;kategorie\u cbot\category;.

11
help/P/object/WORM.TXT.bak
View File

@ -1,11 +0,0 @@
\b;Robal
\image worm 8 8;
Robale zarażajš wirusami zaprogramowane roboty. Wirusy modyfikujš programy w stopniu uniemożliwiajšcym ich prawidłowe działanie lub powodujšcym przerwanie ich działania.
Robale żyjš w podglebiu, choć czasem wychodzš i pełzajš po powierzchni. Gdy sš pod ziemiš sš niewykrywalne i niezniszczalne.
\t;\l;Kategoria\u cbot\category; obiektu
\c;AlienWorm\n;
\t;Zobacz również
\l;Język CBOT\u cbot;, \l;zmienne\u cbot\type; i \l;kategorie\u cbot\category;.

10
help/P/object/WRECK.TXT.bak
View File

@ -1,10 +0,0 @@
\b;Pozostałości robota
Wrak robota to pozostałości po robocie uszkodzonym przez \l;pająka\u object\spider; lub ogień własnych robotów.
Z wraku robota można odzyskać pełnowartościową \l;kostkę tytanu\u object\titan; przy użyciu robota \l;recyklera\u object\botrecy;.
\t;\l;Kategoria\u cbot\category; obiektu
\c;Wreck\n;
\t;Zobacz również
\l;Język CBOT\u cbot;, \l;zmienne\u cbot\type; i \l;kategorie\u cbot\category;.

11
help/P/object/ant.txt.bak
View File

@ -1,11 +0,0 @@
\b;Mrówka
\image ant 8 8;
Mrówki strzelają małymi żrącymi kulkami które wgryzają się w osłony ochronne robotów i budynków, powodując ich zniszczenie.
\l;Człowiek\u object\human; może znacznie dłużej wytrzymać ich ataki niż większość budynków i robotów, gdyż Twoja osłona ochronna odnawia się, gdy goją się jego rany. Jednkaże, jeśli zostaniesz zbyt długo w ich zasięgu lub gdy jest ich zbyt dużo, Twoje życie może być w wielkim niebezpieczeństwie.
\t;\l;Kategoria\u cbot\category; obiektu
\c;AlienAnt\n;
\t;Zobacz również
\l;Język CBOT\u cbot;, \l;zmienne\u cbot\type; i \l;kategorie\u cbot\category;.

15
help/P/object/atomic.txt.bak
View File

@ -1,15 +0,0 @@
\b;Atomowe ogniwo elektryczne
\image atomic 4 4;
Atomowe ogniwo elektryczne dostarcza energii robotom i niektórym budynkom.
Jego pojemność jest 100 razy większa od pojemnośći \l;zwykłego ogniwa elektrycznego\u object\power;.
Atomowe ogniwa elektryczne nie mogą być jednak ponownie ładowane ani przetwarzane. Do wytworzenia nowego, w pełni naładowanego atomowego ogniwa elektrycznego potrzebna jest \l;elektrownia atomowa\u object\nuclear; oraz nieco \l;rudy uranu\u object\uranore;.
\t;Transport
Wszystkie \l;transportery\u object\botgr; oraz \l;astronauta\u object\human;.
\t;\l;Kategoria\u cbot\category; obiektu
\c;NuclearCell\n;
\t;Zobacz również
\l;Język CBOT\u cbot;, \l;zmienne\u cbot\type; i \l;kategorie\u cbot\category;..

8
help/P/object/barrier.txt.bak
View File

@ -1,8 +0,0 @@
\b;Bariera
Bariera to nic innego niż używana w ćwiczeniach przeszkoda.
\t;\l;Kategoria\u cbot\category; obiektu
\c;Barrier\n;
\t;Zobacz również
\l;Język CBOT\u cbot;, \l;zmienne\u cbot\type; i \l;kategorie\u cbot\category;..

11
help/P/object/base.txt.bak
View File

@ -1,11 +0,0 @@
\b;\button 171; Statek kosmiczny
\image base 8 8;
\l;Twój\u object\human; środek transportu pomiędzy planetami, jedyny sposób bezpiecznego podróżowania w kosmosie i wypełnienia misji.
Poza astronautą, statek kosmiczny może przewozić roboty oraz surowce. Po zakończeniu misji, należy zanaczyć statek kosmiczny, a następnie kliknąć polecenie odlotu \button 28;.
\t;\l;Kategoria\u cbot\category; obiektu
\c;SpaceShip\n;
\t;Zobacz również
\l;Język CBOT\u cbot;, \l;zmienne\u cbot\type; i \l;kategorie\u cbot\category;..

14
help/P/object/bbox.txt.bak
View File

@ -1,14 +0,0 @@
\b;Czarna skrzynka
\image bbox 4 4;
Czarna skrzynka tak naprawdę jest pomarańczowa, żeby łatwiej można ją było rozpoznać i znaleźć. Każdy \l;statek kosmiczny\u object\base; wyposażony jest w czarną skrzynkę zapisującą i przechowującą informacje o przebiegu lotu.
Czarna skrzynka może być także użyta do pozostawienia ważnych informacji. Pierwsza ekspedycja zostawiła na każdej z planet czarną skrzynkę zawierającą współrzędne planety, do której zmierzała w następnej kolejności.
\t;Transport
Wszystkie \l;transportery\u object\botgr; oraz \l;astronauta\u object\human;.
\t;\l;Kategoria\u cbot\category; obiektu
\c;BlackBox\n;
\t;Zobacz również
\l;Język CBOT\u cbot;, \l;zmienne\u cbot\type; i \l;kategorie\u cbot\category;..

20
help/P/object/botfc.txt.bak
View File

@ -1,20 +0,0 @@
\b;\button 144; Działo na gąsienicach
\image botfc 8 8;
Robot na gąsienicach strzelający kulami ognia.
Działko strzelające kulami ognia jest skuteczną bronią przeciwko większości \l;wrogów\u object\mother;. Należy używać go z rozwagą, z uwagi na duże zużycie energii. \l;Zwykłe ogniwo elektryczne\u object\power; wystarcza na oddanie tylko 4 serii strzałów.
Porada: poruszanie myszą podczas strzelania spowoduje ogarnięcie strzałami większego obszaru.
Roboty na gąsienicach mogą pokonywać strome pochyłości ale są raczej powolne i zużywają mnóstwo energii. Na płaskim terenie na krótszych dystansach lepszym wyborem jest \l;działo na kołach\u object\botfr;. Gdy jest to możliwe, zbudowanie \l;robota latającego\u object\botfj; jest najlepszym sposobem pokonywania dużych odległości.
\t;Programowanie
Do zaprogramowania poruszania robotem można używać następujących instrukcji: \c;\l;move\u cbot\move;\n;, \c;\l;turn\u cbot\turn;\n;, \c;\l;motor\u cbot\motor;\n;, \c;\l;goto\u cbot\goto;\n;.
Do zaprogramowania działka strzelającego kulami ognia służy instrukcja \c;\l;fire\u cbot\fire;\n;. Lufę można podnieść lub opuścić używając instrukcji \c;\l;aim\u cbot\aim;\n;.
\t;\l;Kategoria\u cbot\category; obiektu
\c;TrackedShooter\n;
\t;Zobacz również
\l;Język CBOT\u cbot;, \l;zmienne\u cbot\type; i \l;kategorie\u cbot\category;.

Some files were not shown because too many files have changed in this diff Show More