FAQ - Frequently Asked Questions
Artykuły:
Q: Chciałbym umieścić artykuł na stronie, czy to jest możliwe?
A: Jak najbardziej. Artykuły umieszczone na stronie wymagają formatowania zgodnego z HTML, jednak tym mogę się zająć osobiście. Dodatkowo proszę o przysłanie artykułu w formacie *.txt i ewentualnie *.pdf - będę się starał umieszczać linki do nich bezpośrednio pod tekstami na stronie, do wykorzystania offline przez użytkowników.
Q: Próbuję przepisać niektóre programy z artykułów, jednaknie chcą mi zadziałać?
A: Programy w artykułach, jak i procedury w przykładach są często wyrwane z kontekstu, niekompletne. Zdarzają się też przypadki, że programy opisane "Styl Atari Basic" nie chodzą pod Atari Basic-em, ale pod TB XL pójdą (w większości przypadków są sprawdzane). Chodzi o budowę konstrukcji AB w stosunku do idei TB XL (na przykład GET kontra BGET), często wystarczy prosta zmiana adresów (z szesnastkowych na dziesiętne), aby przykład zadziałał w oryginalnym AB.
Procedury:
Q: Chciałbym umieścić procedurę w wybranym języku na stronie, czy to jest możliwe?
A: Oczywiście. Proszę o przesłanie procedury do wyświetlenia w czystym tekście, kodowanie tekstu w UTF-8.
Q: Czy procedury muszą być przygotowane w jakiś specjalny sposób?
A: Tak, w miarę możliwości proszę o dokładne komentarze w kodzie procedury lub - co według mnie będzie lepszym wyjściem - dokładny opis bezpośrednio po kodzie programu. Opis jest przeznaczony dla nowych programistów, którzy - w miarę nabywania doświadczenia - mogą się nauczyć pisać własne, być może lepsze rozwiązania.
Turbo Basic XL
Q: Mam listing TB XL w formie pliku tekstowego, czy muszę go przepisywać ręcznie?A: Nie, należy tylko zadbać, aby końce linii były w formacie Atari, a nie PC/MAC. Taki program wczytujemy instrukcją LOAD"D:NAZWA_PROGRAMU.NAZWA_ROZSZERZENIA".
Q: Jak zamienić koniec linii tekstu w formacie PC na format Atari?
A: Można skorzystać na przykład z Atari 800 Win: Misc==>Convert==>ASCII to ATASCII, następnie wybieramy plik i zaznaczamy opcję EOL only. Tak uzyskany tekst możemy już użyć na Atari.
Q: Ile jest dostępnej pamięci RAM dla programisty?
A:Turbo BASIC XL jest jednym z niewielu języków, który udostępnia użytkownikowi większą ilość pamięci niż zwykle, a najczęściej jest to pamięć wolna do $A000 (tak jak to robi Atari BASIC). Turbo BASIC XL zaraz po uruchomieniu podaje (komenda ? fre(0)), że dostępnych jest 34021 bajtów.
Zwykle display lista zaczyna się od adresu $9C20 = 39968 (w Action!, Atari BASIC i wielu innych), jednak w Turbo BASIC XL zaczyna się aż od $BC20 = 48160 dla 0 trybu graficznego.
Na pierwszy rzut oka, ilość dostępnej pamięci na kod i dane w Turbo BASIC XL jest większa niż w Action! Jednak nie do końca jest to prawdziwe:
- W Turbo BASIC XL nie da się odzyskać pamięci znajdującej się pod systemem Atari (zarówno w z poziomu interpretera oraz runtime), a w Action! nie stanowi to problemu
- W Action! co prawda nie można przejąć pamięci $A000-$BFFF z poziomu samego języka, jednak da się tak napisać program, aby całą tę przestrzeń odzyskać w uruchomionym programie (w grach Tdc traci się jedynie ~700 bajtów, w celu przejęcia tej pamięci przy równoczesnym zachowaniu całkowitej funkcjonalności niezbędnej do programowania gier i dem).
Dlatego podsumowując: pracując w środowisku języka programowania w Turbo BASIC XL jest dostępne więcej pamięci niż w innych językach (w tym w Action!), jednak jeśli potrzebujemy jeszcze więcej pamięci niż dostępne do adresu $BFFF, to jest to bardzo utrudnione, natomiast w Action! nie stanowi problemu zarządzanie całą dostępną pamięcią, podobnie jak to ma miejsce w asemblerze.
Q: Co nowego ma Turbo BASIC XL w stosunku do Atari BASICa ? A:Po pierwsze Turbo BASIC XL jest zgodny w dół z Atari BASICem, więc (prawie) każdy program napisany dla tego ostatniego można uruchomić w tym pierwszym (można mieć nadzieję, że zadziała znacząco szybciej). Jednak Turbo BASIC XL udostępnia wiele dodatkowych instrukcji i możliwości, które są bardzo praktyczne. Wymienić tutaj warto:
- możliwość wykorzystywania szesnastkowego zapisu liczb (tzw. HEX), jednak w specyficznych warunkach może to nie działać prawidłowo
- instrukcja dump - wyświetla wszystkie zmienne (bardzo pomocne w debugowaniu programu)
- możliwość wykorzystywania procedur (w nie tak pełnym wymiarze jak w Action!)
- możliwość używania krótszego zapisu RAND(x) zamiast INT(RND(0)*x)
- możliwość opuszczania pętli i procedur za pomocą instrukcji EXIT. Instrukcja ta powoduje przeskoczenie do wykonywania pierwszej instrukcji znajdującej się za końcem procedury lub pętli.
- w Turbo BASIC XL jest zdefiniowanych kila nowych kodów błędów (od 22 do 30)
- jest dostępnych kilka nowych instrukcji graficznych np. circle x,y,r, fcolor n, paint x,y, text x,y,a$
- jest dostępna nowa instrukcja DSOUND n,f,d,v - łączy kanały dźwiękowe w celu zwiększenia zakresu częstotliwości
- instrukcja RENUM n,i,j umożliwia renumerację numerów linii w kodzie programu (czyli łatwe przenoszenie fragmentów kodu w ramach tego samego programu)
- instrukcje DPOKE i DPEEK umożliwiają operowanie na 16bitowych wartościach
- instrukcja MOVE m,m1,m2 - umożliwia szybkie przenoszenie fragmentów pamięci, odbywa się to nieco na wzór procedury MOVEBLOCK(adr1,adr2, rozmiar) dostępnej w Action! W Turbo BASIC XL, MOVE jest bardzo szybkie nadaje się do wykorzystywania w szybkich operacjach graficznych, w Action! MOVEBLOCK() jest super szybkie.
Q: Ile mogę maksymalnie użyć zmiennych?
A: W Turbo BASIC XL można użyć tylko 256 zmiennych. Wszystkie zmienne są zmiennopozycyjne (zajmują dużo pamięci oraz spowalniają program).
Należy pamiętać, że każde użycie zmiennej powoduje jej automatyczne zadeklarowanie (inaczej niż w Action! gdzie każdą należy jawnie deklarować, co uniemożliwia takie problemy jak w BASICu oraz umożliwia wybór typu zmiennej). Nawet jeśli zmiennej użyjemy w trybie natychmiastowego wykonania (a nie użytej w kodzie programu przechowywanego w pamięci RAM), to zmienna ta już zajmuje miejsce i nigdy nie zostanie usunięta (w celu wyeliminowania tego problemu należy program zapisać w formie tekstowej, a następnie ponownie wczytać do pamięci).
To jest błąd charakterystyczny dla Turbo BASICa XL.
Q: Jak można zapisać i odczytać program jako tekst?
A:Turbo BASIC XL podobnie jak Atari BASIC umożliwia zapis i odczyt programów jako pliki tekstowe. Zapisywanie programu:
LIST"D:nazwa.lst"oraz odczyt:
ENTER"D:nazwa.lst"Q: Jak zapisać i odczytać dane w wybranym miejscu pamięci?
A:Operacje tego typu można wykonywać w następujący sposób:
Zapis:
OPEN #1,8,0,"D:NAZWA" BPUT #1,skąd,ile CLOSE #1Odczyt:
OPEN #1,4,0,"D:NAZWA" BGET #1,skąd,ile CLOSE #1Dodatkowo nowością w stosunku do Atari BASICa jest możliwość użycia nowej instrukcji BLOAD, która wczytuje plik binarny:
BLOAD"D:NAZWA"Oraz instrukcja:
BRUN"D:NAZWA"umożliwia wczytanie i uruchomienie programu w kodzie maszynowym.
Q: Czy Turbo BASIC XL używa 6 strony pamięci ?
A:Sam język nie używa. Należy jednak pamiętać, że po skompilowaniu runtime używa 6 strony pamięci przed uruchomieniem programu, potem gdy program się już uruchomi 6 strona jest dostępna dla programisty.
Rozwiązanie: można sobie wczytać dane do innego miejsca pamięci, a potem skopiować na 6 stronę pamięci.
Q: Jak używać procedur ?
A:Nowością w stosunku do Atari BASICa jest możliwość używania procedur, co może w uproszczeniu prezentować się następująco:
PROC RYSUJ:plot x,y:drawto x1,y1: ENDPROCNastępnie taką procedurę można wywołać poprzez:
EXEC nazwa_proceduryCzyli w tym przypadku:
EXEC RYSUJZalety, jeśli nie mamy potrzeby programu kompilować, to wywołania procedur działają szybciej niż wywołania podprogramów GOSUB.
Q: Czy mogę używać ELSE ?
Q:Tak, rozwinięciem w stosunku do Atari BASICa jest między innymi dodanie bardziej praktycznych warunków, co może wyglądać następująco:
IF a$=chr$(r):goto 90:ELSE:goto 100:ENDIFZaletą tego rozwiązania jest to, że można w jednej linii zmieścić kilka oddzielnych warunków (co oszczędza pamięć zajmowaną przez program), z drugiej strony niestety warunek taki musi się zmieścić w jednej linii. (pewnym rozwiązaniem może być konstrukcja łączona: ELSE IF - tworząca kolejny warunek, wtedy nie mamy ograniczenia do jednej linii).
Q: Co można zrobić w celu przyspieszenia działania programu?
A:W ramach środowiska Turbo BASIC XL (czyli bez kompilacji) spotykamy wiele problemów, które są charakterystyczne dla języków BASIC. W szczególności są to:
- Warto zamiast numerów linii używać etykiet, np.
1000 #UJMIJ .. 5000 GO#UJMIJBędzie to działać szybciej niż:
1000 ... .. 5000 GOTO 1000Wynika to z tego, że interpreter przeszukuje program od początku w celu znalezienia odpowiedniego numeru linii. (po kompilacji problem nie ma znaczenia). Wadą tego rozwiązania jest zmniejszanie się ilości dostępnych zmiennych.
Q: Jakie są znane techniki dla zaoszczędzenia pamięci ?
A:Jest wypracowanych wiele metod na drodze empirycznej:
- używać nazw zmiennych zamiast wartości, bo zapis w pamięci nazwy zmiennej mniej zajmuje miejsca niż wartość, która jest zapisywana w formie zmiennopozycyjnej (obszernej).
- zapisując stałe liczbowe można zamienić wartości od 0 do 3 na %0, %1, %2 i %3, które wymuszają oszczędny zapis w pamięci (wielka szkoda że nie można tak zrobić z innymi wartościami, a jedynie tymi podanymi tutaj). Na każdym takim zapisie oszczędza się 6 bajtów pamięci.
- warto programować tak aby jak najwięcej kodu mieściło się w jednej linii, podobnie jak w Atari BASICu zaoszczędzi to nieco rozmiar programu. Wynika to z tego że numer linii jest tak przechowywany w pamięci, że lepiej jest mieć program z mniejszą ilością (numerowanych) linii. Warto tu zwrócić uwagę na możliwość przesunięcia lewego marginesu ekranu (POKE 82,0 - zyskujemy 2 znaki w linii) i możliwość stosowania przy edycji skrótów instrukcji.
- refaktoryzacja: połączenie dwóch linii w jedną zaoszczędza nieco pamięci (w ramach całego programu oszczędności mogą być bardzo duże). Przykładowo połączenie krótkiej linii z wcześniejszą oszczędza 3 bajty.
Q: Jakie są znane problemy z kompilatorem Turbo BASIC XL (Turbo BASIC XL Compiler)
A: Jest znanych kilka problemów, w tym kilka krytycznych:
- runtime wykorzystuje przed uruchomieniem programu 6 stronę pamięci - następnie jest już dostępna
- Rozbudowane wyrażenia określające indeks tablic liczbowych kończą się zgłoszeniem błędu numer 9
- Nieprawidłowe działanie instrukcji Sound bez parametrów
Q: Czy są znane błędy w interpreterze Turbo BASICa XL?
A: Tak, oto one (część z błędów może być specjalnie zaimplementowana aby zachować zgodność w dół z Atari BASICem):
- Interpreter nie przyjmuje słów kluczowych %GET, %PUT i -MOVE jeśli są wpisane małymi literami
- Język przyjmuje jako poprawne zmienne tekstowe wykorzystane w instrukcji GET, mimo że ta może przyjmować jedynie wartości numeryczne
- Podobnie jak w Atari BASICu, interpreter przyjmuje znak Esc (kod ASCII 27) jako dwukropek oddzielający instrukcje.
- Kod w postaci 10 TRAP 10:GET #1,A, całkowicie zapełnia stos procesora (doprowadzając do jego nadpisywania z drugiej strony). Celem instrukcji TRAP jest zdejmowanie tych danych ze stosu, jednak zdejmowana jest nieprawidłowa ilość. Błąd ten posiada również Atari BASIC.
- Podobnie jak w Atari BASICu, porównanie dwóch funkcji CHR$ w tym samym wyrażeniu, daje w wyniku zawsze "true", np. IF CHR$(1)=CHR$(2) THEN END, zawsze zatrzyma program.
- Jeśli funkcji DEC przekażemy liczbę szesnastkową zawierającą małe litery, to zwracany wynik funkcji jest nieprawidłowy.
- Jeśli na końcu łańcucha tekstowego znajduje się znak Control+R (kod ASCII 18) to powoduje to łącznie łańcuchów wyświetlanych na ekranie (tak jak działanie ";").
Action!
Q: jak przenosić programy z BASICa do Action?
A:Jeśli program jest długi to warto sobie taki program wczytać do edytora Action! Aby tego dokonać należy zapisać program w BASICu jako tekst, co wykonać można instrukcją
LIST"D:nazwa.lst"Następnie w edytorze Action! kombinacją klawiszy Shift+Control+R, należy taki plik wczytać (warto od razu go zapisać już jako źródło w Action! czyli zapisujemy plik kombinacją Shift+Control+W i podać nazwę pliku z rozszerzeniem act). Od tej pory można przerabiać sobie ten program tak aby był zgodny ze składnią Action! Język ten jest wyposażony w pełnoekranowy edytor oraz jest kompilatorem typu strukturalnego (procedury i moduły), dlatego w pierwszej kolejności należy z programu usunąć numery linii oraz znaki ":" oddzielające instrukcje (to ostatnie nie jest wymagane). To duża zaleta Action! że nie wymaga żadnych znaków separujących kolejne operacje (tak dobrze nie ma nawet w C/C++, Javie i wielu innych współczesnych językach programowania).
Wszelkie wywołania procedur (z Turbo BASIC XL) lub wywołań GOSUB (dostępne we wszystkich odmianach BASICa), powinno się w pierwszej kolejności zamienić na procedury Action! Dane odczytywane READ, RESTORE zapisane w liniach DATA, należy albo zapisać w tablicach, albo zapisać do pliku a następnie wczytywać do pamięci. W obu przypadkach przyspieszenie dostępu do tych danych będzie gigantyczne.
Największym problemem będą operacje matematyczne (np. trygonometryczne) oraz wszelkie operacje na ułamkach (np. proste A=A+0.1 jest standardowo niewykonalne w Action!). Jeśli to jest w programie bardzo istotne należy napisać sobie odpowiednie typy danych i procedury albo ściągnąć z internetu odpowiednią bibliotekę.
Sporym problemem jest fakt, że każda zmienna w Action! musi być zadeklarowana, w językach BASIC panuje tutaj pełna swoboda (co jest dość wygodne), więc niestety trzeba wszystkie zmienne w programie wyszukać i zadeklarować w programie Action! (warto to zrobić za pomocą polecenia dump w Turbo BASICu XL). Oto Action!owy przykład deklaracji zmiennych:
int a,b,c card d,e byte z byte array tablica1, tablica2 card array tablica_card int array tablica_intDane typu byte to wartości z przedziału 0-255 (bajt), a card to wartości od 0 do 65535 (dwa bajty). Int (czyli integer) podobnie jak card zapisany jest w dwóch bajtach, ale wartości są z przedziału -32768 do 32767.
Następnie należy zamienić wszystkie podstawowe elementy (każdego) języka programowania na ich odpowiedniki w Action! (ma on wszystkie niezbędne instrukcje, konstrukcje oraz operacje), czyli: warunki i pętle. Kolejnym krokiem może być zamienienie wywoływania instrukcji BASIC na ich odpowiedniki w Action! podstawową zasadą jest to, że w Action! najczęściej wszelkie parametry podajemy w nawiasach, np.
Print "Poturbowany przez BASIC XL"
należy zamienić na:
PRINTE("Poturbowany przez BASIC XL")
Oto lista podstawowych odpowiedników instrukcji BASIC w Action!| Zapis w BASICu | Notacja stosowana w Action! |
| ZMIENNA=ZMIENNA+1 | ZMIENNA==+1 |
| A = A & $F | A==& $F |
| A = A LSH 4 | A==LSH 4 |
| IF A <> 10 THEN B=10 | IF A <> 10 THEN B=10 FI |
| 10 IF A=10 THEN B=1 : GOTO 30 20 B=2 30 REM | IF A=10 THEN B=1 ELSE B=2 FI |
| FOR A=1 TO 100 ... NEXT I | FOR A=1 TO 100 DO ... OD |
| PRINT "POTURBOWANY BASIC" | PrintE("POTURBOWANY BASIC") |
| PRINT "ALA"; | Print("ALA") |
| PRINT #5;"ALA" | PrintDE(5, "ALA") |
| PRINT #5;"ALA"; | PrintD(5, "ALA") |
| PRINT A | PrintIE(A) |
| PRINT "A=";A | PrintF("A=%I%E", A) |
| PRINT #3; A*3; | PrintBD(3, A*3) |
| INPUT A | Put('?) A=InputI() |
| INPUT B$ | Put('?) InputS(B) |
| PUT #0,65 | Put('A) lub Put(65) LUB Put($41) |
| GET #C,B | B = GetD(c) |
| OPEN #1,4,0,"D:" | Open(1,"D:", 4, 0) |
| CLOSE #1 | Close(3) |
| NOTE #1, C, B | Note (1, @C, @B) |
| POINT #1, C, B | Point (1, C, B) |
| XIO 18, #6, 0, 0, "S:" | XIO(6, 0, 18, 0, 0, "S:") LUB Fill(...) |
| B=PEEK(C) | B = Peek(C) lub BA = C B=BA^ |
| POKE C,B | Poke(C, B) |
| DPOKE C,B (TB XL) | PokeC(C, B) |
| GRAPHICS 8 | Graphics(8) |
| COLOR 3 | color =3 ("color" jest systemową zmienną predefiniowaną w Action!) |
| DRAWTO C, D | DrawTo(C, D) |
| LOCATE C, D, E | E = Locate(C, D) |
| PLOT C, D | Plot(C, D) |
| POSITION C, D | Position(C, D) |
| SETCOLOR 0, 1, C | SetColor(0, 1, C) |
| SOUND 0, 122, 10, 15 | Sound(0, 122, 10, 15) |
| C=PADDLE (B) | C=Paddle(B) |
| C=PTRIG(B) | C=Ptrig(B) |
| C=STICK(B) | C=Stick(B) |
| C=STRIG(B) | C=Strig(B) |
| B$=C$ | Scopy(BA, C) |
| B$ = C$ (2, 4) | ScopyS(BA, C, 2, 4) |
| B$(2, 4) = C$ | Sassign(BA, C, 2, 4) |
| B=INT(RND(0)*10)+1 | B=Rand(6)+1 |
| FOR A=4000 TO 5000: POKE A, 0:NEXT A | Zero(4000, 1001) |
| STOP | Break() |
| B$ = STR$(I) | StrI(I, BA) |
| I = VAL (C$) | I = ValI(C) |
Oczywiście to jeszcze nie wszystko, im większy i bardziej skomplikowany program tym więcej problemów może wystąpić. Czasami pewne charakterystyczne dla BASICa konstrukcje (np. nieudokumentowane sztuczki) mogą sprawiać problemy, dlatego warto głębiej zainteresować się jak należy programować w Action! W tym celu polecam przeczytanie np. "ACTION Reference Manual" dostępny w internecie jako plik PDF.
Q:- Zaginęła prędkość Action! / Przeniosłem program z Basic i jest tylko trochę szybszy :-/
A:Język Action! oferuje niezwykłą wydajność kodu, jednak trzeba spełnić kilka warunków. Po pierwsze należy unikać wykorzystywania biblioteki procedur Action! (tych które się znajdują w pamięci ROM na cartridge'u). Jeśli przeniosłeś program z jakiejś odmiany Basica to pewnie bardzo często korzystasz z takich procedur jak: print, locate, plot, drawto, graphics itp. Te procedury w Action! działają sporo szybciej niż w językach Basic, ale pewnie nie takiej wydajności się spodziewałeś.
Aby program działał z pełną prędkością, należy unikać takich powolnych procedur (również tych które wykorzystują procedury zawarte w systemie Atari). Powolne są też inne niektóre operacje np. dwu bajtowe mnożenie i dzielenie (warto napisać własne lub użyć gotowych z internetu).
Jednym ze sposobów pominięcia powolnych systemowych procedur, jest napisanie ich sobie samodzielnie, co jest świetną zaletą Action! dzięki jego wydajności bez korzystania z asemblera można napisać sobie własne procedury PRINT(), które będą działały drastycznie szybciej od tych bibliotecznych! Przykładowo próba napisania szybkiego wstawiania znaku o podanych współrzędnych w Turbo BASICu XL nawet po kompilacji programu nie przyniesie zadowalających rezultatów.
Przykładem prędkości Action! może być wykorzystanie jednej z dostępnych w internecie bibliotek operujących na sprzętowych duszkach Atari (biblioteki tego typu się łatwo robi, można sobie taką napisać samodzielnie). Jeśli wykorzystamy ją bez używania wspomnianych procedur, to taki program będzie bardzo szybko działał, nie będzie stanowiło problemu, aby animować duże ilości obiektów przy zachowaniu pełnej płynności animacji. I oto mamy świetny szkielet do fajnej, dynamicznej gry!
Warto jeszcze dodać, że Turbo BASIC XL oraz Atari BASIC nie umożliwiają wsparcia dla animowania duszków oraz nigdy nie mogły się równać pod względem wydajności.
Dodatkową zaletą definitywnego pożegnania się z biblioteką procedur Action! jest to że taki program po kompilacji do pliku wykonywalnego nie wymaga cartridge Action! lub tzw. runtime (więcej szczegółów tego zagadnienia będzie opisane w odrębnym artykule).