----------Fragmenty w >...< -- wytîuszczone (bold)--------------------


AMAL

<lead>W wielu listach proszono mnie, abym opisaî AMAL-a. A cóû to
jest ten... AMAL? No tak, musi to byê naprawdë dziwny system,
skoro niczego podobnego nie zawierajâ ûadne inne (znane mi)
jëzyki programowania. A skoro tak, to po co go wsadzili do
naszego kochanego AMOS-a? Aaaaach -- ja niewierny...

<a>Krzysztof Prusik

<txt>Skrót AMAL oznacza AMos Animation Language, czyli Animacyjny
Jëzyk AMosa. A cóû to oznacza w praktyce? Otóû producenci AMOS-a
przeanalizowali programy pisane przez ludzi (dla ludzi) i doszli
do mâdrego wniosku, ûe we wszelkiego rodzaju demach, grach itp.
najwiëcej czasu komputera zabiera animacja, czyli wyôwietlanie
obiektów (sprite'ów i BOB-ów) w róûnych punktach ekranu, scroll
pasków (barów), przesuwanie ekranu itp. Zwykle hackerzy muszâ sië
mocno natrudziê, ûeby zmieôciê niezliczone przesuwania obiektów
podczas jednego pionowego wygaszania ekranu. Juû oni dobrze
wiedzâ, ûe kaûda jednostkowa operacja animacyjna powinna sië
odbyê raz na 1/50 sekundy (synchronizacja!), co zapewni
odpowieniâ pîynnoôê ruchów. Wiedzâ teû, jak bardzo jest to
trudne.

Twórcy AMOS-a rozumieli dobrze te (i inne) bolâczki producentów
demosów i opracowali system (AMAL), który zwalnia programistów
(koderów) od obowiâzku zastanawiania sië, co, kiedy i w którym
momencie wyôwietliê na ekranie. Jednoczeônie jednak AMAL jest
bardzo prosty (udostëpnia maîâ liczbë rozkazów sterujâcych
obiektami), ale wîaônie dziëki temu zapewnia dostatecznâ szybkoôê
wykonywanym programom (skompilowany kod zbliûony do "generowanego
przez asembler"). Oczywiôcie nie muszë chyba przypominaê, ûe AMOS
ma wewnëtrzny kompilator programów AMAL-a, przez co programy
AMAL-a sâ szybkie nawet wtedy, gdy je uruchomimy w ôrodowisku
AMOS-a (bez uprzedniej kompilacji).

I najwaûniejsze: programy AMAL-a pracujâ w multitaskingu (sic!).
Kaûdy program obsîuguje jeden obiekt, którym moûe byê BOB (duszek
blittera), sprite (duszek sprzëtowy), ekran (wielkoôê, rozmiar,
offset) lub rainbow (tëcza). Uwaga wiëc! Odpalajâc kilka
programów AMAL-a, powodujemy ruch wszystkich obiektów
jednoczeônie! (Patrz rys. 1.) Zwalniamy sië w ten sposób z
obowiâzku pilnowania faz ruchu poszczególnych obiektów. Po prostu
dla kaûdego obiektu tworzymy odpowiedni program, uruchamiamy
go... i tyle. Teraz wszystko dzieje sië juû samo, a my moûemy sië
zajâê czymô innym.

--------------------!Rys.1!-----------------------------------------

<sr>Pierwszy przesuwany obiekt

<txt>Weúmy takiego... BOB-a. Chcemy, ûeby sië przesuwaî po
ekranie. Jak to zrobiê? Ano trzeba napisaê program AMAL-a, a
nastëpnie odpaliê go. Moûe to wyglâdaê np. tak:

<l>'-------- îadujemy obrazy BOB-ów do pamiëci

Load "AMOSPro_Tutorial:Objects/Amal_bobs.ABK"

'

'-------- piszemy program dla AMAL-a

A$=""

A$=A$+" Let R0=1 predkosc x   "

A$=A$+" Let R1=1 predkosc y   "

A$=A$+"                       "

A$=A$+" AUtotest( petla       "

A$=A$+"                       "

A$=A$+"  Let X=X+R0 poziom    "

A$=A$+"  Let Y=Y+R1 pion      "

A$=A$+"                       "

A$=A$+"  If X>319 Direct Lewo "

A$=A$+"  If X<0 Direct Prawo  "

A$=A$+"  If Y>199 Direct Gora "

A$=A$+"  If Y<0 Direct Dol    "

A$=A$+"                       "

A$=A$+")Wait powrot do petli  "

A$=A$+"                       "

A$=A$+"Lewo:                  "

A$=A$+"  R0=-1 ruch w lewo    "

A$=A$+"  Wait powrot do petli "

A$=A$+"                       "

A$=A$+"Prawo:                 "

A$=A$+"  R0=1 ruch w prawo    "

A$=A$+"  Wait powrot do petli "

A$=A$+"                       "

A$=A$+"Gora:                  "

A$=A$+"  R1=-1 ruch w gore    "

A$=A$+"  Wait powrot do petli "

A$=A$+"                       "

A$=A$+"Dol:                   "

A$=A$+"  R1=1 ruch w dol      "

A$=A$+"  Wait powrot do petli "

A$=A$+"                       "

'- kompilujemy program

Amal 1,A$

'- przyporzâdkowujemy BOB-owi

Channel 1 To Bob 1

'- odpalamy go

Amal On 1

'- wyôwietlamy BOB-a

Bob 1,100,100,1

'- wszystko sië rusza, a my

'- w tle robimy coô innego

Repeat

   Print "SAI BABA ";

Until Mouse Key


<txt>A teraz miniwyjaônienie zasady dziaîania programu:

1. Do pamiëci îadujemy bank z obrazami BOB-ów (>Load...<). AMOS
poprosi o wîoûenie odpowiedniego dysku z przykîadami BOB-ów. Skâd
taki dysk wziâê? Jeôli mamy caîego AMOS-a, mamy równieû i ten
dysk (patrz któryô tam Magazyn AMIGA, artykuî: "Co to jest
AMOS?"). Oczywiôcie jeôli chcemy, moûemy bank bobów zmieniê na
inny.

2. Tworzymy zmiennâ tekstowâ z programem AMAL-a (>A$=...<).

3. Kompilujemy pierwszy program AMAL-a (>Amal 1,A$<).

4. Przyporzâdkowujemy pierwszy program AMAL-a odpowiedniemu
obiektowi (Channel To...), w tym wypadku pierwszemu BOB-owi.

5. Odpalamy pierwszy program AMAL-a (>Amal On 1<). Od tej pory na
ekranie porusza sië "niewidoczny" BOB.

6. Wyôwietlamy BOB-a na ekranie (>Bob...<). Teraz juû ruch jest
widoczny.

7. W pëtli AMOS-a, bez przerwy wyôwietlamy napis "SAI BABA".
Program koïczy swoje dziaîanie, gdy naciôniemy którykolwiek
przycisk myszy.

Czy wszystko proste, piëkne i przyjemne? To w takim razie
przechodzimy do sedna sprawy, czyli: a co w ôrodku? Co to za
dziwne znaczki zostaîy zapisane w zmiennej >A$<?

<sr>Rozkazy AMAL-a

<txt>Pierwsza i najwaûniejsza rzecz: rozkazy AMAL-a pisane sâ
duûymi literami, a wszystko inne traktowane jest jako komentarz
(patrz tekst programu). Wiemy juû, ûe kaûdy program AMAL-a
steruje dokîadnie jednym obiektem (np. BOB-em). Nic nie stoi na
przeszkodzie, aby sië dowiedzieê, ûe kaûdy program AMAL-a ma
swoje zmienne specjalne >X,Y,A<, które umoûliwiajâ nam
bezpoôrednie kierowanie obiektem. Zmieniajâc wiëc wartoôê >X,Y< w
naszym programie, powodujemy zmianë miejsca pobytu BOB-a.  A
teraz krótki opis komend:

>AUtotest(...)Wait< -- pëtla analogiczna do >Do...Loop< (AMOS), z
tym ûe wykonanie wszystkich rozkazów w niej zawartych
synchronizowane jest z wygaszaniem pionowym ekranu (aû promieï
wizji wyôwietli caîy obraz). Zwykle kaûdy program AMAL-a zawiera
jednâ (gîównâ) pëtlë AUtotest, w której przeprowadzane sâ
wszystkie operacje.

>Let X=X+R0< -- coô rodem ze starego Spectrum. Powoduje
zwiëkszenie/zmniejszenie pozycji x obiektu o R0 (rejestr AMAL-a).
Odpowiada to instrukcji AMOS-a >X=X+R0<.

>If X>319 Direct Lewo< -- jeôli pozycja X sterowanego obiektu
jest wiëksza niû 319 (wyszedî poza ekran), skocz (>Goto<) do
etykiety >Lewo<. W AMOS-ie podobnâ instrukcjë zapisalibyômy
nastëpujâco: >If X>319 Then Goto LEWO<. Uwaga! Etykiety AMAL-a
mogâ byê tylko jednoliterowe (tylko duûe znaki sâ brane pod
uwagë).

>Wait< -- powoduje powrót do pëtli AUtotest.

I tyle! Oto algorytm w pseudokodzie, który powinien ostatecznie
rozjaôniê wszystkie wâtpliwoôci.

<l>Powtarzaj w pëtli:

    Przesuï obiekt w X

    Przesuï obiekt w Y

    Jeôli X wyjdzie poza ekran

       zmieï kierunek ruchu w X na przeciwny

    Jeôli Y wyjdzie poza ekran

       zmieï kierunek ruchu w Y na przeciwny

<txt>Jak îatwo sië domyôliê, program przesuwa po ekranie
"piîeczkë", która odbija sië od ôcian ekranu.

<sr>Modyfikacje

---------------------------!Rys.2!-------------------------------

<txt>A gdybyômy chcieli na ekranie poruszaê 15 obiektów (rys. 2.)
i uzyskaê zîudzenie, ûe wszystkie poruszajâ sië losowo? Nic
prostszego! Program w AMAL-u mamy napisany (zmienna A$), teraz
pozostaîo tylko przypisaê go 15 BOB-om, a nastëpnie to wszystko
uruchomiê. Zamiast ostatnich trzynastu linii poprzedniego
programu wpisujemy wiëc np. coô takiego:

<l>
For K=1 To 15
   '- kompilujemy program
   Amal K,A$
   '- przyporzâdkowujemy BOB-owi
   Channel K To Bob K
   '- odpalamy go
   Amal On K
   '- wyôwietlamy BOB-a
   Bob K,100,100,1
Next
'- wszystko sië rusza, a my
'- w tle robimy coô innego
Repeat
   Print "SAI BABA ";
Until Mouse Key

<txt>Pomiëdzy 6. a 5. liniâ programu (liczâc od koïca), moûemy
wstawiê rozkaz >Wait Key<, co spowoduje, ûe bëdziemy lepiej
widzieli, jak puszczane sâ w ruch kolejne obiekty.

Jeûeli chcemy spowodowaê nie tylko ruch obiektów, ale równieû
animacjë poklatkowâ (pokazywanie kolejnych klatek animacji, czyli
wyôwietlanie kolejnych obrazów BOB-a -- rys. 3.), wystarczy, jak
pomiëdzy piâtym a szóstym wierszem programu dopiszemy linië:

---------------------!Rys.3!------------------------------

<l>A$=A$+" Anim 0,(1,2)(2,2)(3,2)(4,2)"

<txt>No dobrze, a teraz wciônijmy [F1], co spowoduje uruchomienie
programu AMOS-a. No i...? Uups! Piëtnaôcie obiektów moûe sië i
porusza, ale wszystkie startujâ z tego samego punktu (100,100) i
majâ ten sam kierunek oraz zwrot, przez co na ekranie widzimy
tylko jednego poruszajâcego sië BOB-a (przykrywajâcego wszystkie
pozostaîe -- patrz rys. 4.). Zmodyfikujmy wiëc siódmâ linië
programu (od koïca) nastëpujâco:

<l>Bob K,Rnd(319),Rnd(199),1

---------------------!Rys.4!------------------------------------

<txt>Teraz juû lepiej. Gdyby tak jeszcze obiekty podczas startu
poruszaîy sië w róûnych kierunkach... (a nie, jak gîupie,
wszystkie w kierunku prawego górnego rogu ekranu). Ha! I tu z
pomocâ przychodzi moûliwoôê zmiany zmiennych AMAL-a, z poziomu
AMOS-a. Wiemy, ûe kaûdy z programów AMAL-a, swojâ prywatnâ
prëdkoôê ruchu poziomego przechowuje w rejestrze (zmiennej) >R0<,
a pionowego w >R1<. Jeûeli chcemy zmieniê ich zawartoôê z poziomu
AMOS-a, wystarczy uûyê rozkazu >Amreg<:

>Amreg(REJ,NR)=WAR< -- podstawienie wartoôci WAR, rejestrowi REJ
(0..9) programu AMAL-a numer NR.

>WAR=Amreg(REJ,NR)< -- przypisanie zmiennej WAR, wartoôci
przechowywanej w rejestrze REJ, programu NR.

A co w naszym wypadku? Trzeba skasowaê niepotrzebne przypisania
na poczâtku programów AMAL-a (pierwsze dwie linie, zmienna >A$<),
a zamiast tego inicjowaê rejestry AMAL-a z poziomu AMOS-a, czyli
przed instrukcjâ:

<l>Amal On K

<txt>wstawiê

<l>Amreg(0,K)=1-Rnd(2) : Rem Let R0=

Amreg(1,K)=1-Rnd(1) : Rem Let R1=

<txt>Gdzie: >1-Rnd(2)< wyznacza losowo liczbë ze zbioru {-1,0,1}.

Ok? A tak przy okazji: to, co zrobiliômy, moûna byîo, zamiast
wykorzystywania >Amreg<, uzyskaê innâ metodâ. Jak myôlisz, jakâ?


<sr>Obsîuga joysticka w AMAL-u

<txt>A gdybyômy tak sami chcieli poruszaê stworzonym przez nas
obiektem? Czy byîoby to moûliwe? Pewnie! Chyba nie ma rzeczy,
której nie moûna by zrobiê w AMAL-u. Program moûe wyglâdaê np.
tak:

<l>
...

A$=A$+" AUtotest( petla       "

A$=A$+"                       "

A$=A$+"  If J1=4 Direct Lewo  "

A$=A$+"  If J1=8 Direct Prawo "

A$=A$+"  If J1=1 Direct Gora  "

A$=A$+"  If J1=2 Direct Dol   "

A$=A$+"                       "

A$=A$+")Wait powrot do petli  "

A$=A$+"                       "

A$=A$+"Lewo:                  "

A$=A$+"  Let X=X-1 ruch w lewo"

A$=A$+"  Wait powrot do petli "

A$=A$+"                       "

A$=A$+"Prawo:                 "

A$=A$+"  Let X=X+1 w prawo    "

A$=A$+"  Wait powrot do petli "

A$=A$+"                       "

A$=A$+"Gora:                  "

A$=A$+"  Let Y=Y-1 w gore     "

A$=A$+"  Wait powrot do petli "

A$=A$+"                       "

A$=A$+"Dol:                   "

A$=A$+"  Let Y=Y+1 w dol      "

A$=A$+"  Wait powrot do petli "

A$=A$+"                       "

...

<txt>Pojawiîa sië nowa funkcja >J1<. Cóû ona robi? Ano podaje nam
stan joysticka, podîâczonego do portu pierwszego (analogicznie
>J0< -- zerowego). Moûliwe stany pokazane sâ na rys. 5. Program
dziaîa nastëpujâco: jeûeli przesuniemy dúwignië joysticka w
którâkolwiek stronë, wtedy on w odpowiednim kierunku przesuwa
obiekt (o 1).

------------------------------!Rys.5!-------------------------------

<sr>Myszka

<txt>Analogiczne funkcje obsîugujâ myszkë w AMAL-u. Jak
wyglâdaîby program, którego zadaniem byîoby przesuwanie obiektu
do punktu poîoûenia wskaúnika myszki, natychmiast po tym, jak
"ktoô" wciônie lewy jej przycisk? Spójrzmy niûej:

<l>
...

A$=A$+" AUtotest( petla       "

A$=A$+"                       "

A$=A$+"  If K1=-1 Direct Ruch "

A$=A$+"                       "

A$=A$+")Wait powrot do petli  "

A$=A$+"Ruch:                  "

a$=A$+"  Move XM-X,YM-Y,30    "

A$=A$+"  Wait powrot do petli "

...

<txt>Nowe funkcje to: 

>K1< -- podaje stan lewego przycisku myszy (-1 wciôniëty, 0 --
nie). Analogicznie >K2< odnosi sië do przycisku prawego.

>XM< -- podaje wspóîrzëdnâ X wskaúnika myszki.

>YM< -- analogicznie podaje wspóîrzëdnâ Y.

>Move XM-X,YM-Y,30< -- przesuwa obiekt do miejsca pobytu
wskaúnika myszki w trzydziestu krokach.

Skoro tyle wiemy, moûemy zrobiê juû prawie wszystko. Na przykîad
kazaê komputerowi przesuwaê wszystkich piëtnaôcie obiektów
zgodnie ze wskazaniami joysticka albo myszki. Ômieszne to,
prawda? Stadko obiektów poruszajâce sië na nasze zawoîanie.
Proponujë jednak zrobiê coô innego. Niech pierwszych trzynaôcie
BOB-ów bezmyôlnie odbija sië od ôcianek. Czternasty niech bëdzie
obsîugiwany joystickiem, a piëtnasty myszkâ. Zróbmy to! Juû?

To teraz

<sr>niespodzianka

<txt>Uruchom program, popatrz na efekt jego dziaîania, po czym
naciônij lewy przycisk myszy, a nastëpnie [Esc] (przejdziemy w
ten sposób do bezpoôredniego trybu AMOS-a). Czy widzisz, ûe BOB-y
nadal poruszajâ sië po ekranie? Wpisz komendë:

<l>Print "Ala ma kota"

<txt>Zadziaîaîo? Przesuï okno trybu bezpoôredniego myszkâ.
Dziaîa? Poruszaj joystickiem -- obiekt rusza sië zgodnie z
naszymi wachniëciami? I to jest wîaônie to, czego nie majâ
wîaôciciele pecetów -- multitasking w peînej krasie. Moûesz to
pokazaê jakiemuô zatwardziaîemu facetowi z niebieskimi klapkami
na oczach, a rëczë, ûe jego oczy wyjdâ z orbit (i przebijâ te
niebieskie klapki). Nie ma to, jak porównywanie mîotka do
siekierki czy, jak kto woli, siekierki do mîotka...

Jak to sië mówi, przyganiaî kocioî garnkowi...