ZX Spectrum Tippek és Trükkök

Tartalom

Előszó

Ha a légi közlekedés az utóbbi években annyit fejlődött volna, mint a számítógépipar, akkor ötven márkáért félóránál rövidebb idő alatt repülhetnénk Frankfurtból Tokióba. A számítógépek meghódították az egész világot. Életünk ma már elképzelhetetlen a számítógépek nélkül. CLIVE SINCLAIR a ZX 81-es és a ZX Spectrum kifejlesztésével jelentős részt vállalt a számítógépek széles körű elterjesztésében. Számítógépei gazdaságosak és kezdőknek kiválóan alkalmasak.
Ez a könyv a jelenlegi és jövőbeli Spectrum tulajdonosokhoz szól. A könyvből megismerhetjük a BASIC nyelv elemi fogásait, és ha már programozni is tudunk, akkor nagyon sokféleképpen használhatjuk majd számítógépünket. A könyv sok útmutatást, tippet, trükköt és programot mutat be a számítógép használatához. A programokat igényeink szerint elhelyezhetjük programkönyvtárunkba, hogy megkönnyítsük velük programjaink írását.
Néhány rövid program bemutatása után egy hosszabb játékprogram készítése következik, amelynek során nem az ellenséget kell lelőni minél nagyobb számban, hanem elsősorban a probléma megoldásán kell gondolkozni. A következő programban a Spectrum grafikus lehetőségeit használjuk ki. A világtérkép megrajzolása után a Nap mindenkori állását, a nappali és éjszakai zónákat is bejelölhetjük a tv képernyőjén.
A gazdaságos és gyors tömegtárolók, a kazettás egységek megjelenésével a Spectrum alkalmazási lehetőségei jelentősen kibővültek. Az alkalmazási lehetőségeket a különböző cégek által nagy választékban kínált tartozékok is (különösképpen a billentyűzetek) növelik. A kiegészítő berendezésekről részletesen tájékoztat a könyv.
A könyv további fejezeteiben olyan ötleteket és programokat mutatunk be, amelyek kisebb üzemekben is jelentősen megkönnyítik a munkát. Ilyenek pl. a raktár- és forgalomnyilvántartó, a vásárló adatnyilvántartó és a diagramokat rajzoló program. A Spectrumot még hirdetések készítésére is felhasználhatjuk, ha a kívánt szövegeket különböző színben és nagyságban megjelenítjük a képernyőn.
A könyv a különböző érdeklődésű olvasóknak segítséget, ötleteket ad és nem utolsósorban kellemes szórakozást nyújt.

1. A Spectrumról általában

1.1 Bevezetés

A ZX Spectrum viszonylag olcsó, sokoldalú számítógép. Segítségével egyrészt örömet lelhetünk a játékokban, másrészt sokat megtudhatunk a számítógépekről is. Ha megfelelően alkalmazzuk, akkor hasznos segítőtársunk lesz. Teljesen kezdőknek először a Spectrum kézikönyv alapos tanulmányozását javasoljuk. A kézikönyv kezdők és haladók számára egyaránt fontos információkat nyújt.
A Spectrum szíve, vagy inkább az agya a ZILOG cég által gyártott Z80-as proceszszor. Ez a 8 bites processzor egy 64 kbyte-os tár címzésére alkalmas. A tárból 16 kbyte-ot az operációs rendszer foglal el, amelyet egy ROM-ban helyeztek el.
Mit jelent az operációs rendszer? Mit tartalmaz a ROM? Az operációs rendszer egy program, tehát szoftver, amely a processzor és a külvilág kapcsolatát teremti meg. Külvilág alatt a számítógép üzemeltetőjét, valamint az egyéb készülékeket (a televíziót, a kazettás egységet és a számítógép billentyűzetét) értjük. A Spectrumnak tudnia kell, hogy mit akarunk tőle. Ezt a megfelelő billentyűk lenyomásával adhatjuk tudomására. Az operációs rendszer felismeri és értelmezi a mindenkori bevitelt. A használó a bevitelnél adott szabályokhoz tartja magát, így az operációs rendszer el tudja dönteni, hogy új program írásáról vagy egy közvetlen végrehajtandó parancsról van-e szó.
Az újonnan megírt programot először tárolni kell, hogy később szükség szerint felhasználhassuk. A Spectrum programnyelve a BASIC. Ez a Beginners Allpurpose Symbolic Instruction Code rövidítése. A processzor nem ezt a nyelvet, hanem saját gépi kódját érti. Ezért a BASIC nyelven írt programokat le kell fordítani, értelmezni kell. Az értelmezőprogramot angolul interpreternek hívják és az operációs rendszer része. Sok számítógép típusnál az operációs rendszer és az értelmezőprogram élesen elkülönül egymástól, a Spectrumban azonban ezek nem választhatók szét.
A számítógépek beépített programjai a használó számára nagyon fontosak, és a számítógépnek megváltoztathatatlan alkotórészei. Ezért ezeket a tárnak egy olyan részében helyezik el, ahonnan csak olvasni lehet. Innen ered a neve is, Read Only Memory, röviden ROM, ami magyarul azt jelenti, hogy csak olvasásra használható tár. Ha az egész tár csak olvasásra lenne alkalmas, akkor saját programjainkat nem tudnánk beírni, és nem beszélhetnénk számítógépről. A tárnak azonban olyan része is van, amibe tetszés szerint írhatunk és amit tetszés szerint törölhetünk. Ezt Random Access Memory-nak, röviden RAM-nak nevezzük (magyarul: véletlen bemeneti memória).

A Spectrumban a ROM-ban elhelyezett programok 16 kbyte-ot foglalnak el. Így a RAM-ban 48 kbyte-ot használhatunk. A tárban a 23685-ös címtől kezdve lehet dolgozni. Az 16385-től a 23685-ig terjedő helyeket a képernyőtár, a rendszerváltozók stb. foglalják le.
Mivel a Spectrum képernyője 256 * 192 pontból áll, és minden 8 x 8-as mátrixot el lehet látni egy színjelzővel, a képernyőtár 6144 helyet igényel, további 704 helyet a színinformációknak kell fenntartani.
A Spectrum teljes karakterkészletének (256 karakter) kódja 0-tól 255-ig terjed. Az első 128 karakter az általános ASCII szabványnak felel meg. A 165-255 között vannak a Spectrum gépen használható BASIC parancsok kódjai. Ez teszi lehetővé, hogy egy parancsot egyetlen billentyű, ill. egy billentyűkombináció lenyomásával beírjunk. A Spectrum billentyűzete nem hasonlít az írógép billentyűzetéhez, a gépbe programozott BASIC parancsok végrehajtása egyszerűbb. Ennek előnye, hogy a beíráskor nem követhetünk el gépelési hibát, ugyanakkor a parancsszavak a tárban csak 1 byte-ot foglalnak el. Más számítógépek sokszor minden betű tárolásához 1 byte-ot igényelnek.
Miként vesz tudomást a Spectrum agya, a Z80 arról, hogy melyik billentyűt nyomtuk le, és hogy az mit jelent? A gép belsejében a billentyűket huzalrendszer köti össze, egy 5 * 8-as háló formájában. Egy billentyű működtetése adott áramköri kombinációnak felel meg. A Spectrum egy speciális chipje az ULA (Uncommitted Logical Array, magyarul: nem lekötött logikai tömb) érzékeli azt, hogy melyik kombinációról van szó. A billentyűknek több jelentése van. A rendszerváltozók határozzák meg a Z80-as számára a billentyűk aktuális értékét, valamint azt is, hogy milyen beviteli rendszerben dolgozunk. A billentyű jelentésének értékelése után jelenik meg az információ a képernyőn.
A Spectrumot BASIC-ben és gépi kódban is lehet programozni. Könyvünkben főként a BASIC nyelvű programozással foglalkozunk. A programozás elkezdése előtt röviden tekintsük át a jó öreg ZX 81-es és a Spectrum közötti eltéréseket. Az eltérések bemutatásával a haladók és az egyéb rendszereket már ismerők tanulási idejét szeretnénk lerövidíteni.

1.2 A ZX 81-estől a ZX Spectrumig

A Sinclair ZX 81-esről a Spectrum programozására könnyű az áttérés, csak azt kell megszoknunk, hogy egy sokkal gazdagabb nyelven, a BASIC-en programozhatunk. A Spectrum használatakor - ellentétben a ZX 81-essel - lehetőségünk van arra, hogy egy sorszám alatt több utasítást írjunk, vagy közvetten üzemmódban utasításokat kettősponttal elválasztva adjunk be. A SLOW és a FAST üzemmód között nincs különbség, a Spectrum mindig FAST módban dolgozik. A SCROLL parancsra sincs többé szükség. Ha a képernyő tele van, akkor automatikusan megáll, és felteszi a SCROLL? kérdést. Új sor kiírását egy billentyű lenyomásával érhetjük el. A SCROLL utasítást a RAND USR 3582-os ROM rutinnal pótolhatjuk.
A Spectrum jóval nagyobb grafikus felbontóképessége miatt a PLOT utasítás alkalmazásánál lényeges különbségek vannak. Az UNPLOT utasítást nem ismeri a Spectrum, de sok olyan grafikus parancs van, ami a ZX 81-esnél még nem létezett. (A BASIC utasítások teljes listáját és magyarázatát az 1. függelék tartalmazza.)
A Spectrumnak ugyan kevesebb rögzített grafikus karaktere van, viszont 21 szabadon meghatározható és mindig hívható karakterrel rendelkezik. Kis ügyességgel teljesen új karakterkészletet határozhatunk meg, vagy több karakterkészletet egymás mellett is használhatunk. A harmadik, és főként a negyedik fejezetben erre még visszatérünk. Egy rutint mutatunk be, amivel a Spectrum 64 karaktert tud soronként a képernyőn megjeleníteni.
A Spectrum - ellentétben a ZX 81-essel - ASCII kódban dolgozik.
A ZX Spectrumnál a CLEAR utasítással a RAMTOP lejjebb hozható. A CLEAR utasításban a cím maximális értékét decimálisan kell megadni. A használó által meghatározott karakterek, az UDG-k, mindig egy NEW törlési parancstól védett területre kerülnek.
A Spectrum hatszor gyorsabban veszi fel a programokat kazettára, mint a ZX 81-es, ezért a tárolás problémamentesebb. A SAVE parancs végrehajtását VERIFY paranccsal ellenőrizhetjük, így az adatok elvesztése kizárt. Ha a programokat egy LINE utasítással kiegészítve visszük fel, akkor azok betöltés után az adott sortól kezdve automatikusan íródnak be. Betöltéskor a program neve megjelenik a képernyőn.
A rendelkezésre álló 8 színen kívül a Spectrum hangokat is ad a BEEP utasítás hatására. Természetesen sem a PINK FLOYD, sem a Bécsi Filharmonikusok nem vállaltak keresztapaságot az utasítás kidolgozásában, mégis érdekes hangeffektusokat lehet létrehozni. Egy sakkprogramban (Spectrum Voice Chess) pl. az emberi beszédre hasonlító hangokat fedezhetünk fel.
A SCRENN$ paranccsal a képernyő teljes tartalmát tárolhatjuk szalagon, abban az esetben is, ha nagy felbontású grafikáról van szó. Ez azért lehetséges, mert a Spectrum a BASIC programokon kívül byte-ok tárolását és betöltését is lehetővé teszi. A SAVE "Név" SCREEN$ a SAVE "Név" CODE 16384, 6912 paranccsal azonos. A képernyő file a 16384-es címtől kezdődik és pontosan 6912 byte hosszú. A képernyő file tehát rögzített hosszúságú, ellentétben a ZX 81 -essel.
A SCREEN$ parancs másképp is felhasználható, ha ellátjuk két argumentummal. Az egyik a sor-, a másik az oszlopszámot jelenti, eredményül pedig azt a karaktert kapjuk, ami a képernyőnek ezen a helyén található. Hasonló feladata van a POINT (sor, oszlop) parancsnak is. Le lehet kérdezni vele, hogy a képpontnak éppen írás - vagy háttérszíne van-e. Ebben az esetben a sorok és az oszlopok értékei a grafikus rendszerben értendők, tehát a 0-tól 255-ig, ill. 175-ig terjedő számok.
A Spectrumba a számokat bináris alakban is beadhatjuk a BIN utasítással. Így a PRINT BIN 00000100 utasítás a 4-es számot állítja elő. Ez különösen a karakterek meghatározásánál jelent nagy segítséget. A karaktert egyszerűen fel kell rajzolni egy 8 * 8-as rácsra, majd a megfelelő helyekre 1-eseket kell beírni. Így elmarad a tízes számrendszerbe való átszámítás, ami több karakternél sok munkával járna. Egy kis példával megvilágítjuk ezt a módszert. Ha az S betűt szeretnénk meghatározni, akkor a számokat az alábbiak szerint a megfelelő tárhelyekre kell bevinni, pl. USR "a"-tól USR "a"+7-ig.

BIN 00000000
BIN 11111111
BIN 10000000
BIN 10000000
BIN 11111111
BIN 00000001
BIN 00000001
BIN 11111111

A PRINT USR "a" a karakter helyes képét mutatja.
Adatokat DATA utasításokban tárolunk és READ utasításokkal olvasunk. RESTORE utasítással jelölhetjük ki azt a sort, amitől az olvasást kezdeni akarjuk.
A Spectrum ROM tárja nagyobb, minta ZX 81-esé, így a rendszerváltozók elhelyezkedése is más. A rendszerváltozókat, valamint a PEEK-ek és POKE-ok által nyújtott lehetőségeket a 3. fejezetben tárgyaljuk részletesebben.
Néhány eltérés a két gép külsejében is van, legszembetűnőbb a billentyűzeté.
A SINCLAIR cég Spectrumnál is szóba jöhető bővítési lehetőségei jelentősek. Az Interface bővítő egység és a kazettás egység olyan kiépítési lehetőségeket nyújt a Spectrumnak, hogy drágább készülékekkel összehasonlítva sem kell szégyenkeznie. A kazettás egységgel egy gazdaságos és relatíve gyors (gyorsabb, mint néhány lemezegység) háttértár áll rendelkezésünkre. A beépített RS 232-es csatlakozóhoz több nyomtató illeszthető közvetlenül, vagy adapteren (átvivőn) keresztül kapcsolat építhető ki más számítógépekkel. A gép érdekessége, hogy helyi hálózaton maximálisan 64 db Spectrum (és Sinclair QLS) közvetlenül összekapcsolható. Részletesen a 7. fejezet foglalkozik ezzel a problémával.

2. Tippek a BASIC nyelvű programíráshoz

2.1 Általános tudnivalók a BASIC nyelvről

A BASIC nyelvet eredetileg kezdő programozóknak szánták. Mint minden széles körben elterjedt programnyelvnek, a BASIC-nek is léteznek továbbfejlesztett változatai, amelyek - nagy rugalmasságuk miatt - különböző számítógép típusoknál alkalmazhatók. A BASIC programnyelvet bonyolult problémák megoldására is használhatjuk. Minél összetettebb egy program, annál nagyobb a lehetséges hibaforrások száma, és a programírás is több előkészítő munkát igényel.
A programozást módszeresen kell végezni. A folytonos javítgatás nem vezet végleges, jó programhoz. Az állandó átdolgozás fárasztó, unalmas munka és sok, nehezen észrevehető hibát okoz. A fölösleges munka elkerülésére és a hibák kiküszöbölésére a legtöbb esetben célszerű a feladatot papíron, ceruzával felvázolni. Minden feladatot fel lehet bontani részfeladatokra, és ezeket egyenként, egyszerűbben meg lehet oldani.
A hivatásos programozók a program menetét ún. folyamatábrán szokták ábrázolni. A folyamatábra mindig START blokkal kezdődik és STOP blokkal végződik. A kettő között van a lényeg. A program minden részfeladatához egy blokkot rendelünk, és a blokkokat nyilakkal kötjük össze. A nyilak a lehetséges programvégrehajtás irányát és sorrendjét mutatják meg. A blokkokban az egy-egy programrészben végrehajtandó feladatokat tüntetjük fel. Nagyobb programok készítésénél tanácsos a folyamatábrát vagy legalábbis feladatok részletes listáját elkészíteni. A 4. fejezetben a MASTERMIND programnál bemutatjuk a folyamatábra készítését. Ha az előkészítő munkákkal készen vagyunk, akkor a számítógépet már érdemes bekapcsolni.
A programba hasznos magyarázó megjegyzéseket iktatni, amelyeket REM-mel kezdődő sorokba kell írni. Itt a különböző programrészek jelzésein kívül a használt változók jelentését is elmagyarázhatjuk. Ha később megtelik a tár, akkor a REM-eket egyszerűen kitörölhetjük, de addig is sok segítséget nyújtanak.
A PASCAL programnyelv előnyös tulajdonsága az ún. eljárás-elv. Az eljárásokat programban tetszőleges néven határozhatjuk meg, és ezen a néven bármikor hívhatjuk. A BASIC néhány új változatában már megvalósították ezt az elvet, de a Spectrumnál még nem. A Spectrumnál is megvalósítható egy ehhez hasonló eljárás, ha a program elején a következőket írjuk:

LET menu=900
LET feladat1=1500
...
LET feladatn=6666

Ha a megfelelő programrészeket a RETURN utasítással fejezzük be, akkor az egyes feladatokat a GOSUB feladat1, GOSUB feladat2 ... stb. utasításokkal hívhatjuk. A program sokkal áttekinthetőbbé válik. Előnye az is, hogy a program átírásánál gyakran csak a sorszámot kell megváltoztatni, és a rutinok hívása helyes marad.
Ajánlatos a programokat egységesen összeállítani, és ehhez ragaszkodni. A menü-vezérelt programoknál pl. a menüt mindig a 9000-es sornál kezdjük. A különböző részfeladatok pedig kezdődhetnek az 1000-es, 2000-es stb. sorokban. A 100-astól a 999-esig terjedő sorokat szubrutinok írására használhatjuk, a 20-astól a 99-esig terjedő sorokban pedig a változókat tárolhatjuk. Az első sorokban határozhatjuk meg az írás, a háttér, a keret színét és a különböző részfeladatok kezdősorait.

1 CLEAR 65535
2 INK 0: PAPER 6: BORDER 3: CLS
3 LET keret=100: LET hiba=150: LET hang=200
10 LET menu=9000: GOTO menu
20 DIM a (100): DIM b(32)
30 DIM g$(17,3)
...
90 GOTO menu
100 REM keret
...
140 RETURN
150 REM rossz bevitel
...
190 RETURN
200 REM hang
...
290 RETURN
...
1000 REM elso rutin
...
1990 GO TO menu
...
9000 CLS: PRINT "Fomenu"
...

A programban a változók számára úgy biztosítunk tárhelyet, hogy egyszer az elején beadjuk a GOTO 20 közvetlen parancsot. A programot LINE 1 utasítással együtt tároljuk, így betöltés után automatikusan fut, anélkül, hogy a változókat törölné. Ha valamilyen hiba miatt a program leáll, akkor a GOTO 1-gyel újraindítható. Ha minden programnál így járunk el, akkor a fenti címet csak egyszer kell megjegyeznünk.
A programok könnyű átalakíthatósága és a hibakeresés miatt az áttekinthető programozáson kívül célszerű a programlistákat tagoltan szerkeszteni. Ez egyrészt sok REM utasítással, másrészt a színek variálásával, üres sorok beiktatásával érhető el. Egy REM utasítás pl. a következőképpen lesz jól látható:

100 REM **********

vagy

100          REM

Rövid alprogramokat (szubrutinokat) pl. a következőképpen írhatunk:

100 REM A 10-15 sorok torlese
110  FOR i=10 TO 15
120   PRINT AT 10,i,,
130  NEXT i
140 RETURN

A Spectrum kézikönyvben megtalálhatjuk a színek kódjait. A PRINT utasítással kiírandó szöveg színét ezekkel lehet meghatározni akkor, ha nem akarjuk az INK és a PAPER utasításokat használni. A lista tetszés szerinti helyén alkalmazhatjuk ezeket az utasításokat. A programrészek elejét pl. pirossal könnyen kiemelhetjük (a megfelelő sor előtt a CAPS SHIFT és a SYMBOL SHIFT billentyű egyszerre való lenyomásával), így bővített módba kerülhetünk. Ezután a CAPS SHIFT és a kettes billentyű lenyomásával a sor végén megszüntetjük az előző színt, és kijelöljük az alapszínt. Így elérhetjük egy sor vagy akár az egész lista villogását.
A kódokat egyszerű megjegyezni. Először is bővített módba kell kerülni, majd a 0-tól 7-ig terjedő számok lenyomásával a háttér megfelelő színét beállítani. A 8-as és a 9-es az élességet fogja befolyásolni. Ha a számokkal egy időben a CAPS SHIFT billentyűt is lenyomjuk, akkor az írás színét állítjuk be, ill. a 8-assal és a 9-essel a villogást kapcsolhatjuk ki és be.
Ha elkészítettük a programot, és az rendeltetésszerűen lefutott, akkor szánhatunk még egy kis időt arra is, hogy felrakjuk az i-re a pontot. Tegyük a programot olyan mutatóssá, amennyire csak lehet! A színek és a hangok (vagy helyesebben a BEEP-ek) is rendelkezésünkre állnak a Spectrumban, használjuk ezeket is! Még a fekete-fehér televízión is érdemes a különböző színeket használni, mivel a különböző tónusú szürke árnyalatok áttekinthetőbbé teszik a képernyőt. A zöld vagy a sárga írás fekete háttéren nagyon jól mutat, és hosszan tartó használatnál nem olyan fárasztó a szemnek, mint a fekete írás fehér alapon. Áttekinthetőbb lesz a képernyő, különösen akkor, ha azonos típusú információkhoz mindig azonos színeket rendelünk.
Alig van olyan hosszú program, amelyik valahol ne tartalmazna egy kis hibát. Mindenesetre célszerű a hibák számát a lehető legkisebbre csökkenteni. A hibák legtöbbször a programfutás szélsőséges eseteinél lépnek fel, pl. amikor az adatmező már tele van, és szeretnénk valamilyen műveletet végrehajtani az adatokon. Ritkán előforduló helyzetekben a probléma akkor is jelentkezhet, ha a művelet normál esetben mindig működik.
Ne sajnáljuk az időt az alapos tesztelésre, különösen akkor ne, ha az általunk írt programot más is használni fogja. Adjuk át programunkat olyan szakembernek, aki nem vett részt a programozásban, és különösebb tájékoztatás nélkül kérjük meg, hogy használja a "mestermunkát". Velünk kevésbé fordulhat elő, hogy saját magunk által készített programjaink használata során hibás adatokat adjunk be, vagy olyasmit műveljünk, amitől teljesen "fejre áll" a program.
Ha még van hely a tárban, akkor célszerű minél több bevitelt segítő magyarázatot a képernyőre kiíratni. Gyakran pár hét múlva már magunk sem emlékszünk pontosan az egyes programrészekre, így ezek a magyarázatok nekünk is segítenek.

2.2 A hatékony programozás

A programszerkesztéssel kapcsolatos eddigi meggondolásaink többé-kevésbé hatékony tárkihasználást eredményeztek. Sok lehetőségünk van még arra, hogy a tárhelyekkel takarékosan bánjunk. Egy kis példát már láthattunk. Tegyük fel, hogy szeretnénk a képernyő 10. sorát törölni. Ezt a

PRINT AT 10,0,"                         "

paranccsal végezhetjük el, azaz írunk egy 32 elemből álló üres füzért. A

PRINT AT 10,0,,

paranccsal ugyanezt érjük el, de 32 byte-tal kevesebb tárhelyre van szükségünk.
A számok tárolására a Spectrumban 5 byte van, a kulcsszavak csak 1 byte-ot foglalnak el. A változók tárolása is 1 byte-ot igényel. Ezért a fenti parancsot még hatékonyabban így írhatjuk:

PRINT AT 10,VAL "0"

vagy

PRINT AT 10,NOT PI,,

A PI/PI az 1, a NOT PI a 0 helyett áll. Ha egy hosszú programban megnézzük, hogy milyen gyakran szerepel a 0, ill. az 1-es, akkor könnyen kiszámíthatjuk, hogy esetünkben mennyi tárhelyet nyerhetünk a numerikus változók következetes helyettesítésével.
Ha az olyan utasítás sorszámát, amelyikre sokat hivatkozunk, változóra (lehetőleg rövidre) cseréljük fel, akkor szintén helyet nyerünk. Ilyen pl. annak az utasításnak a sorszáma, amiben a menü áll. Itt célszerű a 9000-t pl. m-mel helyettesíteni, vagyis GOTO 9000 helyett mindig a kisebb helyigényű GOTO m-et írni.
A rend kedvéért meg kell említenünk, hogy ez a módszer egy kicsit lassítja a program futását, mert a gépnek minden esetben ki kell keresnie a változó értékét. Ez az időbeli különbség azonban általában nem jelentős. Célszerű ugyanazt a változónevet annyiszor használni, ahányszor csak lehetséges, mivel az új változó plusz helyet foglal el. Vigyázni kell természetesen arra, hogy fölül ne írjuk azoknak a változóknak az értékét, amelyekre a későbbiekben még szükségünk lehet.
Ha egy programban sok olyan számot kell tárolnunk, amelyeknek értéke nem nagyobb mint 255, akkor ezeket a számokat azzal a karakterrel helyettesítsük, amelyik az adott számnak megfelel. Ez természetesen csak egész számoknál lehetséges. Egy szám tárolásához csak 1 és nem 5 byte-ra van szükség. A karakterből azután a szám értékét a CODE utasítással visszakaphatjuk.
Ha a számok értéke 65536-ig terjed, akkor is megéri azokat 2 byte-on karakterekként tárolni. Az egyik byte az INT (szám/256), a másik byte a szám - 256*INT (szám/256) érték tárolására való. A fenti módszerrel hivatkozik a Spectrum a 65536 tárhelyére. A következő fejezetben gyakran lesz dolgunk ezzel a címzéssel.

Az Interface 1-gyel, vagy anélkül, az egyszerű PRINT utasítás helyett a PRINT#-et is írhatjuk, ha a képernyő mellett a nyomtatót is szeretnénk adatkivitelre használni.
Egy szokásos ROM-nál 3 különböző csatorna van, amelyeket 1, 2, ill. 3-mal jelöltek. Az első csatornához, amelyet k-val jelöltek, a képernyő alsó része tartozik, ezen keresztül megy végbe a bevitel (INPUT). A második csatornát s-nek nevezzük, a képernyő felső, általában a nagyobbik részéhez rendelték, ezen keresztül végzik a képernyőre a megjelenítést (PRINT). A harmadik csatornához a nyomtató csatlakozik.
Ha az Interface 1-gyel dolgozunk, akkor további csatornák is vannak. Pl. az m a kazettás egységé, a t és a b a sornyomtatóé, az n pedig a hálózaté. A PRINT "hallo" utasítás tulajdonképpen a PRINT# 2,"hallo" utasítás rövidített formája. Az LPRINT "hallo" viszont a PRINT# 3,"hallo" utasítás megfelelője. Hasonlóan működik a LIST, ill. a LLIST utasítás is. Ezeket az utasításokat sok programnál ki lehet használni, és így egyszerűbben lehet a képernyőre írt információkat kinyomtatni.
Példa a fentiek megvilágítására:

100 REM kivitel
110 LET kivitel=2
120 FOR i=1 TO 200
130 PRINT# kivitel,a(i),b(i)
140 NEXT i
150 IF kivitel=2 THEN INPUT "nyomtatni I/N";m$
160 IF m$="i" THEN LET kiviel=3: GO TO 120
170 LET kivitel=2

Ha a programban a ciklus előtt a kiviteli változó értékét 2-re állítjuk, akkor a kiírás a képernyőn jelenik meg. A 150-es sorban meg kell válaszolnunk a kérdést, hogy kívánunk-e nyomtatni. Ha igen, akkor a kiviteli változó értéke 3-ra változik, és az eredmény megjelenik a nyomtatón. A módszer biztonságos, és különösen a sok PRINT utasítást tartalmazó programoknál hasznos, mivel időt takarítunk meg vele. A programteszteléshez papírt sem kell használnunk, hiszen a képernyőre íratunk.

3. PEEK-ek, POOK-ok és USR-ek

3.1 A Spectrum tárja

Az olvasó számára talán különösnek tűnik ennek a fejezetnek a címe, de a beavatottak már tudják, hogy miről van szó. Most egy kicsit a Spectrum tárjával kívánunk foglalkozni. A tárban minden helynek címe van. Ha meg akarjuk tudni, hogy egy adott helyen mi áll, pl. az 1000-es helyen, akkor ezt az utasítást kell írnunk:

PRINT PEEK 1000

Válaszként erre megjelenik a képernyőn egy 0 és 255 közötti szám, esetünkben a 9-es. A PEEK utasítás tehát a következőt jelenti: Nézz utána, mi áll az adott tárhelyen! Ha egy konkrét számot, pl. a 6-ot szeretnénk egy adott, pl. a 30000-es címen tárolni, akkor a

POKE 30000,6

utasítást írjuk.
Természetesen ezt csak a tár RAM területén lehet megtenni. Ha a ROM-ban is megtehetnénk, akkor az operációs rendszer tönkremenne.
A tár címei a lehető legegyszerűbbek, ui. 0-nál kezdődnek és a Spectrum típusától függően 32767-ig (16 kbyte), ill. 65535-ig (48 kbyte) terjednek. Az első 16 kbyte-ot, pontosabban az első 16383 helyet a ROM foglalja el. Erre a területre POKE utasítással nem írhatunk, csak a tartalmát olvashatjuk PEEK utasítással. A ROM-ból az operációs rendszer egyes rutinjait használhatjuk, programunkkal hívhatjuk. Ennek módszerét és az érdekesebb rutinokat a későbbiekben közelebbről is megmutatjuk.
A 16384-től 22527-ig terjedő tárhelyeken a képernyő-file, azaz a képernyőre vonatkozó információk helyezkednek el. Ez pontosan 256*192/8=6144 byte-ot jelent. A képernyőn minden 8*8-as mátrix egy nyomtatási pozíciónak felel meg, mindegyikhez hozzárendelhetünk egy adott színt is. Ez a 32*24=768 byte még a képernyő file-hoz tartozik, és a 22528-tól 23295-ig terjedő helyeket foglalja el a tárban. A nyomtató puffertárja 256 byte-os, és 23296-tól 23551-ig terjed. Ezután következnek a rendszerváltozók, amelyek fontos adatokkal segítik a programok szervezését. Nem minden adat található meg egy rögzített címen. Gyakran célszerűbb csak azt megjegyezni, ahol a keresett adatok címe már megtalálható. A fenti megoldás egy gyakran úton levő kereskedőhöz hasonlítható. A kereskedő útja során, ha új helyre érkezik, hazatelefonál és megadja az aktuális telefonszámot. A munkatársak gyakran nem tudják pontosan, hogy hol tartózkodik, de ha el akarják érni, tudnak egy állandó telefonszámot, az otthoni hivatalának számát, ahol megtudhatják az aktuális telefonszámot.
A rendszerváltozókhoz, amelyek az adatok helyéről tájékoztatnak, a kazettás egység tartalomjegyzéke és a csatorna információ csatlakozik. Ezután következik a tulajdonképpeni BASIC terület, ahol először a programot, majd a programban használt változókat tároljuk.
A teljes BASIC területen kívül még a UDG-k részére is van hely a tárban.

3.2 A rendszerváltozók

Az Interface nélküli Spectrumban a rendszerváltozók a tár 23552-es helyétől a 23733-asig találhatóak. Ha az Interface 1-gyel kazettás egységet, RS 232-es csatlakozót és hálózati csatlakozót is használunk, akkor a változók a 23734-től 23791-ig levő helyeken vannak. A változók közül néhányat ügyesen kiolvashatunk (PEEK) és be is írhatunk (POKE) utasítással, ez azonban meglepő eredményekhez, pl. a teljes leálláshoz vezethet.
A változókat nevekkel látjuk el, ezek azonban nem lehetnek azonosak a BASIC-ben használtakkal. Ha egy változó értékét meg akarjuk változtatni, akkor nem adhatunk pl. LET VALT=0 utasítást. A megfelelő értéket POKE utasítással vihetjük be a tárbeli címre. Ha olyan változóról van szó, ami 2 byte-ot foglal el, akkor mindig az első byte a kevésbé jellemző. Ha a d decimális számot a z 2 byte-os címre akarjuk beírni, akkor az utasítás:

POKE z,d-256*INT (d/256)
POKE z+1,INT (d/256)

Az előbb beírt érték olvasásához a

PRINT PEEK z+256*PEEK (z+1)

utasítást írjuk be. Az eredményt decimális alakban kapjuk meg.
A rendszerváltozók magyarázatát a Spectrum kézikönyvben találhatjuk meg. Most néhány rendszerváltozó jelentésével és a POKE utasítás hatásaival foglalkozunk.

3.3 Néhány tipp és trükk

A fejezet végén sok olyan tanácsot adunk és foglalunk össze, amelyek részben a programírásnál, részben a programtárolásnál szükségesek ahhoz, hogy a jogtalan használók ne készíthessenek listát róla.
A Spectrumot gépi kódban is lehet programozni. A gépi kódú programokat vagy programrészeket a BASIC programból a

RAND USR n

vagy a

PRINT USR n

utasításokkal hívhatjuk, ahol n a program kezdő címét jelöli. Egy ilyen gépi kódú program a RETURN utasítással (természetesen ennek gépi kódú alakjával) végződik.
A ROM-ot is gépi kódban írták. A program sok rutinból áll, amelyek általában RETURN utasítással zárulnak. Ezek hívható és használható rutinok. Ha nem akarjuk hidegindításhoz a gép csatlakozóját a hálózatból kihúzni (gyakori ismétlése nem használna a gépnek), akkor a következő ROM utasítást adjuk:

RAND USR 0

Az utasítást veszély nélkül kipróbálhatjuk pl. a képernyőtörlésnél. A

RAND USR 3435

utasítás törli a képernyőt.
A CLS utasítással egyszerűbben törölhettük volna a teljes képernyőt, a képernyő alsó részét azonban csak a

RAND USR 3652

utasítással törölhetjük.
A SCROLL? lekérdezéssel tudhatjuk meg, hogy a ROM-nak melyik részén vagyunk képernyőtörlés közben. A rutin a görgetést végzi. Attól függően, hogy hol lépünk be a SCROLL rutinba, különböző hatásokat érhetünk el.

RAND USR 3280 - Egy sort feljebb görget
RAND USR 3582 - Egy sort és a keretet feljebb görgeti
RAND USR 3652 - A kép alsó felét görgeti
RAND USR 3583 - A kép alsó felét a kerettel együtt görgeti
RAND USR 3330 - Az 1. sorba görget.

Az előző fejezetben már láttuk, hogyan lehet a keret és a képernyő utolsó két sorának színét egyszerre befolyásolni, és egyúttal a villogást is szabályozni. Ezt a

POKE 23624,n

utasítással értük el ahol n értéke 0-tól 255-ig terjedt. A nagyobb számok a látványosabb hatásokat eredményezték. A képernyő színének megváltoztatására a

POKE 23693,n

utasítást kell beírni.
Ha a programunkat védeni kívánjuk a jogtalan használóktól, akkor több trükkre van szükségünk. Vannak olyan cégek, amelyek a másolásvédelem szoftverjeinek írásával foglalkoznak. A tökéletes programvédelmet még nem sikerült megtalálni. A védelemmel együtt a védelem kijátszásának módszerei is fejlődnek. Ma még senki se gondot arra, hogy papírjának és a tintájának azonos színt válasszon, és ezzel az írását láthatatlanná tegye. Talán ez jó módszere volna a másolás elleni védekezésnek, de még senki sem gondolt rá.
Mindenesetre egy COPYRIGHT jelölést betehetünk a listába, ami a saját nevünket tartalmazza! Ha ezt az 1. sorba írjuk, és utána

POKE 23756,0

utasítást adunk, akkor az 1. sort átszámoztuk 0-ra és listázáskor ez többé nem jelenik meg. Megtréfálhatjuk a kezdőket, ha a

POKE 23606,20

vagy a

POKE 23606,111

utasításokat adjuk be (a szám tetszőleges lehet). Ezek az utasítások az írást olvashatatlanná teszik. A kiírás azért lesz olvashatatlan, mert a jelkészlet kezdő címét száműztük. Ha vissza akarjuk állítani, akkor a szám helyére 0-t kell írnunk. Természetesen a karakterkészlet kezdő címének ezt a megváltoztatását ki is használhatjuk, pl. saját karakterkészletünk meghatározására. A következő fejezetben ezt részletesen fogjuk tárgyalni.
A programból való kilépés megakadályozására egyszerűen a képernyő alsó sorainak számát (ami alapesetben 2) 0-ra változtatjuk. Ezt a

POKE 23659,0

utasítással érjük el.
Ilyenkor már nincs hely a hibaüzenet számára, a BREAK parancsot sem lehet meghívni és a program leáll. Hasonlóan működik a

POKE 23613,0: POKE 23614,0

utasítás is. Ilyenkor a program a hibaüzenetnél hidegindítást okoz. Az utasításnak egyetlen hátránya, hogy a változók értékei nem mindig maradnak meg, a folyamatot ezért többször meg kell ismételni.

4. Hasznos rutinok, rövid programok

4.1 Kétszeres nagyságú betűk a képernyőn

Ismerkedjünk meg néhány rutinnal, amelyek a képernyőre való írás méretét befolyásolják! Először próbáljuk meg egy tömbnek, pl. az y$-nak a tartalmát kétszeres nagyságban kiírni. Ezzel fontos üzeneteket tudunk kiemelni a programban. Kezdjük el egyetlen karakterrel. Először hozzuk be a karakter kódját. Ez a

8*CODE y$ + PEEK 23606+256*PEEK 23607=8*CODE y$+15360

utasítással kezdődik, és 8 számból áll. Vegyük először az első négy számot és tegyük be őket kétszer egymás után az USR "a"-ba, a második négy számot ehhez hasonlóan az USR "b"-be. Az általunk meghatározott a és b karaktereket a kívánt helyre, egymás alá íratjuk ki, és már készen is vagyunk.
Tehát:

800 LET CODE x=8*CODE y$+15360
810 FOR z=0 TO 7
820 LET a=PEEK (x+z)
830 LET b=PEEK (x+z+1)
840 POKE USR "a"+2*z,a
850 POKE USR "b"+2*z+1,b
860 NEXT z

és pl.:

900 PRINT AT 9,9;"A"
910 PRINT AT 10,9;"B"

Az utolsó két sorban kiválasztjuk a megfelelő grafikus karaktert. Adjuk még be a

700 INPUT y$

és a

990 GO TO 700

utasításokat is, majd futtassuk a programot! Ha a program lefut, akkor a rutint azzal bővítjük, hogy y$-t egy karakternél hosszabbra választjuk. Ennek létrehozására egy ciklust szervezünk:

750 FOR i= 1 TO LEN y$

Ezután a 800-as, a 900-as és a 910-es sorokat meg kell változtatni:

800 LET x=8*CODE y$(i)+15360
900 PRINT AT 9,i;"A"
910 PRINT AT 10,i;"B"

és hozzá kell tenni a

920 NEXT i

utasítást.
Ha kijelöljük a grafikus a és a grafikus b nyomtatási helyét, az xpoz, ypoz és az xpoz+1, ypoz koordinátákkal, és végül 930 RETURN-nel zárunk, akkor olyan rutinhoz jutunk, amelyet több programban is felhasználhatunk.
Összefüggően a rutin így néz ki:

750 FOR i= 1 TO LEN y$
800 LET x=8*CODE y$(i)+15360
810 FOR z=0 TO 7
820 LET a=PEEK (x+z)
830 LET b=PEEK (x+z+1)
840 POKE USR "a"+2*z,a
850 POKE USR "b"+2*z+1,b
860 NEXT z
900 PRINT AT xpoz,ypoz+i-1;"A"
910 PRINT AT xpoz+1,ypoz+i-1;"B"
920 NEXT i
930 RETURN

A rutin viszonylag lassú, bár ez nem mindig jelent gondot. Ha egy kicsit gyorsítani szeretnénk, akkor a következő változatot célszerű beírni:

800 LET c=USR "a"
810 FOR i=1 TO LEN y$
820 IF y$=" " THEN PRINT AT xpoz+1,ypoz+i-1;" ": GO TO 900
830 LET x=8*CODE y$(i)+15360
840 FOR z= 0 TO 7
850 POKE c+2*z,PEEK (x+z)
860 POKE c+2*z+1,PEEK (x+z+1)
870 NEXT z
880 PRINT AT xpoz,ypoz+i+1;"A"
890 PRINT AT xpoz+1,ypoz+i-1;"B"
900 NEXT i
910 RETURN

A ciklusok itt kevesebb számítási műveletet tartalmaznak, így ez a változat az előzőhöz képest kb. kétszer olyan gyors lesz. Hasonlítsuk össze a két rutint! Gondoljunk arra, hogy az xpoz és az ypoz értékét meg kell határozni!
Ha még nagyobb betűket szeretnénk hasonló módon ábrázolni, akkor a BASIC nyelv korlátai miatt ezek már túl hosszú programok lennének. Ilyenkor célszerűbb gépi kódban programozni. A 9. fejezetben egy olyan gépi kódban írt programot mutatunk be, amellyel tetszőleges nagyságú betűket írhatunk. Megtehetjük természetesen azt is, hogy programjainkat megírjuk BASIC nyelven, majd egy fordítóprogrammal gépi kódra fordítjuk. Erről a fordítóprogramról a 7. fejezetben lesz szó.

4.2. Soronkénti 64 karakteres ábrázolás

Az előző fejezetben megismertük a betűk és a karakterek normálisnál nagyobb méretben való ábrázolását. Most próbáljunk meg a normálisnál kisebb méretű betűket írni a képernyőre. Miért van erre szükség? Sokszor nem elegendő vagy nem kényelmes a soronkénti 32 karakteres ábrázolás, ill. a hosszú számoszlopok vagy sorok nehézkesen kezelhetők. Néhány számítógéphez ezért lehet költséges 80 karakteres kártyát venni.
A TASWORD II. szövegfeldolgozó programmal 64 karaktert tudunk soronként Ábrázolni. Erről a programról a 7. fejezetben írunk majd részletesebben. Itt egy egyszerű rutint szeretnénk bemutatni, amely alkalmas saját programjainkban a soronkénti 64 karakteres ábrázolásra. Kétszer annyi információt tudunk a képernyőre kiírni, és így a ráfordított idő és munka megtérül.
Hogy működik ez a rutin? A Spectrum-ban minden karaktert egy 8x8 pontból álló mátrixban ábrázolunk. Lehetőségünk van azonban arra, hogy egy 4*8 pontból állómátrixon ábrázoljunk úgy, hogy a karakter még mindig jól olvasható legyen. Próbáljuk ki ezt egyszer! Ehhez most az UDG-ket, azaz a használó által meghatározott grafikus karaktereket használjuk.
Próbáljuk ki a rutint az A betűvel! Binárisan az A betűt a következőképpen kell ábrázolni:

BIN 00000000
BIN 00000100
BIN 00001010
BIN 00001010
BIN 00001110
BIN 00001010
BIN 00001010
BIN 00000000

Bizonyára felismerik az A betű formáját. Írassuk ki a képernyőre! Ehhez az alábbi utasításokra van szükség:

 10 DATA BIN 00000000,BIN 00000100,BIN 00001010,BIN 00001010,BIN 00001110,BIN 00001010,BIN 00001010,BIN 00000000
 20 FOR i=0 TO 7
 30 READ x
 40 POKE USR "a"+i,x
 50 NEXT i
100 CLS
110 FOR i=1 TO 300
120 PRINT CHR$ 144;
130 NEXT i
140 STOP

A 120-as sorban természetesen a grafikus A-t kell beadni, azaz a CHR$ 144-et. Ha begépeljük ezt a programot és lenyomjuk a RUN billentyűt, akkor 300 db keskeny A betű jelenik meg a képernyőn. Hogyan lehet ezeket a karaktereket egymáshoz közelíteni, hogy a képernyőn valóban több karakter jelenhessen meg? Egészítsük ki a programot a következő utasításokkal:

 15 DATA BIN 00000000,BIN 00100000,BIN 10100000,BIN 10100000,BIN 11100000,BIN 10100000,BIN 10100000,BIN 00000000
 60 FOR i=0 TO 7
 70 READ x
 80 POKE USR "b"+i,x
 90 NEXT i
125 PRINT CHR$ 145;

A kinyomtatott betű újból grafikus karakter. Ismét adjunk RUN parancsot. Most 600 db kis A-t látunk, amelyek a 8*8-as mátrixnak hol a jobb, hol a bal felét töltik ki. Ezzel még mindig nem értük el a célunkat, de már egy kicsit közelebb kerültünk hozzá.
Meg kell még oldanunk, hogy a karakterek azonos pozícióra kerüljenek anélkül, hogy töröljék egymást. Az OVER 1 utasítással ezt egyszerűen elérhetjük. Ha minden karakter után, amelyik a mátrix bal felén helyezkedik el, kiírunk egy PRINT utasítást (azaz a nyomtatási pozíciót eggyel visszaléptetjük), akkor a problémát megoldottuk. Az előző kurzor pozíciót a PRINT CHR$ 8 utasítás állítja vissza. Példánkban a grafikus B-vel kell kezdeni, mivel ez foglalja el a mátrix bal felét. Változtassuk meg a programot az alábbiak szerint:

120 PRINT CHR$ 145; CHR$ 8;
125 PRINT OVER 1; CHR$ 144;

Adjunk ezután RUN parancsot!
A következőket kell tennünk: meghatározunk két teljes karaktersorozatot. Az egyiknél mindig csak a mátrix bal felét, a másiknál csak a jobb felét használjuk. Ezt a két karaktersorozatot a tárban valahol a RAMTOP fölött tároljuk. Ha ezeket utána 64 karakter/sor formában akarunk kiírni, akkor a mutatót a 23606-os és a 23607-es rendszerváltozókba lehozott karaktersorozatra állítjuk, váltakozva az egyikre, ill. a másikra, mialatt programunk a megfelelő szöveget a képernyőre viszi.
Az ábrázolni kívánt karakterek kódjai 32-től 143-ig terjednek, azaz 112 karakter lehetséges. Ehhez 8*112 számra van szükségünk karaktersorozatonként, ami két sorozatban 2*896 számot jelent. A normál karaktersorozat a 15360-as címnél kezdődik. A 23606-os tárhelyen 0, a 23607-es tárhelyen 60 áll, így 0+256*60 éppen 15360-at ad. A tulajdonképpeni karaktersorozat a 15516-os helyen, a nyomtatható karakterek azonban 256 hellyel később kezdődnek. Az új karaktersorozatokat 256 egész számú többszöröseinél ajánlatos elhelyezni. így az átkapcsolásnál csak egy címet kell beírnunk, a 23607-et.
Pillanatnyilag tételezzük fel azt, hogy a két karaktersorozatot már meghatároztuk és a 63488-64383 és a 64512-65408 helyekre beírtuk. Ezt a következő paranccsal Érhetjük el:

SAVE "64MC" CODE 63488,1921

illetve

SAVE*"m";1;"64MC" CODE 63488,1921

A tárcímeket úgy választottuk meg, hogy a POKE 23607,247 és a POKE 23607,251 utasításokkal működtethessük az új karaktersorozatokat. A POKE 23607,60 utasítással visszatérhetünk a normális karakterekre. Írjunk egy kis rutint, amely egy tetszőleges szöveget 64 karakter/sor elhelyezésben visz ki a képernyőre!

   5 CLEAR 63487: LOAD*"m";1;"64MC" CODE
  10 LET pr64=9700
  20 LET xpoz=10
  30 LET ypoz=0
  50 CLS
  60 INPUT "Kerem a szoveget beadni",z$
  70 GO SUB pr64
  80 PAUSE 0
  90 GOTO 50
9700 PRINT AT xpoz,ypoz;CHR$ 8;
9710 FOR i = 1 TO LEN z$ STEP 2
9720 POKE 23607,251
9730 PRINT z$(i);
9740 IF i = LEN z$ THEN GO TO 9790
9750 PRINT CHR$ 8;
9760 POKE 23607,247
9770 PRINT OVER 1;z$(i+1);
9780 NEXT i
9790 POKE 23607,60
9800 RETURN

Hiányzik még a két karaktersorozat, és aztán indíthatjuk a programot. A karaktersorozat meghatározása elég fárasztó dolog. Akinek van TASWORD II. programja, annak egyszerű dolga van, mert ebben egy sorozatot már meghatároztunk.
A TASWORD II. program betöltése után ez a karaktersorozat a tár 61184-62079 helyein található, és ha visszatérünk a BASIC-be, akkor ezt SAVE paranccsal könnyen felvehetjük:

SAVE "64MC" CODE 61184,896

illetve

SAVE*"m";1;"64MC" CODE 61184,896

A karaktersorozatot a

LOAD "64MC" CODE 63488,896

paranccsal az általunk használt tárhelyekre betölthetjük.

4.3. Mastermind

Most megírjuk első kis játékprogramunkat. A neve MASTERMIND. Játékunknál a gép tetszőleges sorrendben 5 különböző számot (1 és 9 között) választ ki. A játékosnak a számokat és a számok sorrendjét is a legkevesebb próbálkozással kell kitalálni. Minden típus után válaszol a gép. Először megadja, hogy hány számot találtunk el, másodszor, hogy ezek közül hánynak sikerült a helyét is eltalálnunk.
A programozás elkezdése előtt tervezzük meg a program szerkezetét!

1. Inicializálás (tár biztosítása, képernyőtörlés stb.).
2. A számok kiválasztása.
3. A képernyő feliratozása stb.
4. A tipp bevitele.
5. A tipp helyességének ellenőrzése.
6. A számok ellenőrzése.
7. Az eltalált pozíciók ellenőrzése.
8. A találatok száma.
9. Ellenőrizzük, hogy kitaláltuk-e a számot:
   - ha igen, akkor értékelő szöveg és VÉGE utasítás;
   - ha nem, ellenőrizzük, hogy hányszor próbálkoztunk. Ha még van lehetőségünk, akkor újabb tipp bevitele, ha már túl sok volt a próbálkozás, akkor értékelő szöveg és VÉGE utasítás.
10. Értékelés.
11. Vége.

Kezdjük az inicializálással:

4000 REM Mastermind
4010 BORDER 6: PAPER 6: INK 0: CLS

Két 5-5 elemből álló tömbre van szükségünk a tárban. Az elsőt a(5)-nek nevezzük, és ebben tároljuk a Spectrum által kiválasztott számot, a másodikat b(5)-nek, és a tippet tároljuk benne.
Tehát:

4020 DIM a(5): DIM b(5)

Beépítünk egy számlálót, ami 15 próbálkozás után leállítja a játékot.

4030 LET nn=0

Ezzel az első pontot teljesítettük, most a Spectrum által kiválasztott 5 szám programozása következik:

4040 FOR i=1 TO 5
4050 LET a(i)=1+INT (9*RND)

Ellenőriznünk kell, hogy a számunk előfordult-e már. Tehát:

4060 IF i=1 THEN GO TO 4100
4070 FOR k=1 TO i-1
4080 IF a(i)=a(i-k) THEN GO TO 4050
4090 NEXT k
4100 NEXT i

Az a(5) mezőben különböző számok vannak. Írassuk ki a képernyőre!

4200 PRINT "MASTERMIND (5-ot 9-bol)"
4210 PRINT AT nn+3,0;"N   TIPP        HELY jo  SZAM jo"

Adjuk be a tippünket:

4220 INPUT "Tipp (Pl. 12345 bevitele)"; LINE b$

A bevitel ellenőrzése következik:

4230 IF LEN b$<>5 THEN GO TO 4220
4232 LET hiba=0
4234 FOR i=1 TO 5
4236 IF CODE b$(i)<49 OR CODE b$(i)>57 THEN LET hiba=1
4238 NEXT i
4239 IF hiba=1 THEN GO TO 4220

A tippet kiírathatjuk. A b$ füzér tartalmát nem szükséges a tömbbe beírni. A programnál nincs probléma a tár nagyságával, így bátran írhatjuk:

4240 PRINT AT nn+4,0;nn+1
4250 FOR i=1 TO 5
4260 LET b(i)=VAL b$(i)
4270 PRINT AT nn+4,2*i+2;b(i)
4280 NEXT i
4290 LET nn=nn+1

Ellenőrizzük, hogy kitaláltuk-e a számot, ill. hogy hány számot és pozíciót találtunk ki helyesen. Először a két számlálót kinullázzuk:

4300 LET r1=0: LET r2=0

Majd írunk egy ciklust 1-től 5-ig.

4310 FOR i=1 TO 5
4320 IF a(i)=b(i) THEN LET r1=r1+1
4330 FOR k=1 TO 5
4340 IF a(i)=b(k) THEN LET r2=r2+1
4350 NEXT k
4360 NEXT i

A keresett számok az r1 és az r2-ben vannak, és ki lehet azokat írni:

4370 PRINT AT nn+3,18;r1
4380 PRINT AT nn+3,25;r2

Ha mind az 5 szám jó helyen van, akkor a következő üzenetet írjuk be:

4400 IF r1=5 THEN GO TO 4500

15 próbálkozás után álljon le a program:

4410 IF nn>15 THEN GO TO 4600

Kevesebb próbálkozás esetén menjen vissza, hogy az újabb tippet beadhassuk:

4420 GO TO 4220

Vegyük végig az üzeneteket!

4500 PRINT : PRINT nn;" Lepesben nyert"
4510 IF nn<=4 THEN PRINT "Nagyon jo!"
4520 IF nn=5 THEN PRINT "Jo"
4530 IF nn=6 THEN PRINT "Egesz jo"
4540 IF nn=7 THEN PRINT "Majdnem jo, tessek tovabb gyakorolni!"
4550 IF nn>7 AND nn<=10 THEN PRINT "Atlagos"
4560 IF nn>10 THEN PRINT "Jobban is mehetne..."
4570 GO TO 4900
4600 PRINT : PRINT "Ma nincs formaban"

Végül kérdezzük meg, hogy akar-e még játszani:

4900 PRINT FLASH 1;"Jatszik meg egyet? (i/n)"
4910 PAUSE 0
4920 IF INKEY$="i" THEN GO TO 4000
4930 CLS : STOP

Elkészült a programunk. LINE 1 utasítással vegyük fel, és indítsuk RUN-nal! Jó szórakozást!
A programot rövidebben is megírhattuk volna, de így áttekinthetőbb. Megkérjük önöket, hogy javítsák, fejlesszék a könyv többi programját is. Bár működő programokat mutatunk be, nem szeretnénk az Önök kreativitását mellőzni!

A fejezet befejezéseként 3 programlistát mutatunk be magyarázatok nélkül. A programok viszonylag rövidek és könnyen érthetők. Az egyik egy időjelző (óra) program, amely a képernyőn a pontos időt mutatja. Fő vonásaiban megegyezik a SINCLAIR kézikönyv programjával, mi csak kiegészítettük. A programot részprogramként egyéb feladatainkban is felhasználhatjuk.
A második program naptárprogram, amely egy kívánt év kívánt hónapjának a szokásos "kalendáriumát" kirajzolja a képernyőre. (Az évszámnak 1760 és 9999 Közé kell esnie.)
A harmadik a sokak által kedvelt bioritmus, amelynek sok reális alapja talán nincs Is (vagy ki tudja), de jó szórakozást nyújt.

Első program (óra):

   1 BORDER 0: PAPER 0: INK 6: CLS
  10 LET u$="1111"
  50 INPUT "Ido (pl. 0845)"; LINE u$
  55 IF LEN u$<>4 THEN GO TO 50
  60 LET hiba=0
  70 FOR i=1 TO 4
  75 IF CODE u$<48 OR CODE u$(i)>57 THEN LET hiba=1
  80 NEXT i
  85 IF hiba=1 THEN GO TO 50
  90 IF VAL u$>2400 THEN GO TO 50
  93 GO TO 2000
  95 RETURN
2000 CLS : REM ora
2100 LET e=50*(3600*VAL u$(1 TO 2)+60*VAL u$(3 TO 4))
2110 LET ss=65536: LET pp=23672
2120 LET a1=INT (e/ss)
2130 LET a2=INT ((e-a1*ss)/256)
2140 LET a3=e-a1*ss-a2*256
2150 POKE pp+2,a1: POKE pp+1,a2: POKE pp,a3
2200 CLS
2210 FOR n=1 TO 12: PRINT AT 10-10*COS (n/6*PI),16+10*SIN (n/6*PI);n: NEXT n
2220 DEF FN t()=INT ((ss*PEEK (pp+2)+256*PEEK (pp+1)+PEEK pp)/50)
2230 LET t1=FN t(): LET ts=t1
2240 LET tm=INT (t1/60): LET th=tm/60
2250 LET am=tm/30*PI: LET ah=th/6*PI
2260 LET mx=72*SIN am: LET my=72*COS am
2270 LET hx=40*SIN ah: LET hy=40*COS ah
2300 PLOT 132,90: DRAW OVER 1;hx,hy
2310 PLOT 130,90: DRAW OVER 1;mx,my
2320 LET a=t1/30*PI
2330 LET sx=56*SIN a: LET sy=56*COS a
2340 PLOT 131,91: DRAW OVER 1;sx,sy
2350 LET t=FN t()
2360 IF t<=t1 THEN GO TO 2350
2370 PLOT 131,91: DRAW OVER 1;sx,sy
2380 IF INKEY$="u" THEN GO SUB 50: GO TO 2000
2400 IF t/60<>INT (t/60) THEN GO TO 2450
2410 PLOT 130,90: DRAW OVER 1;mx,my
2420 PLOT 132,90: DRAW OVER 1;hx,hy
2430 LET tm=tm+1: LET th=th+1/60
2440 LET ts=t: LET t1=t
2445 GO TO 2250
2450 LET t1=t
2500 GO TO 2320

Második program (naptár):

  1 BORDER 0: PAPER 0: INK 6: CLS
 10 GO TO 100
 20 LET y=0
 22 FOR j=1 TO LEN m$: IF m$(j)="*" THEN LET y=y+1
 23 IF y=m THEN GO TO 25
 24 NEXT j
 25 FOR y=1 TO 10: IF m$(j+y)<>"*" THEN NEXT y
 28 LET t$=m$(j+1 TO j+y-1)
 29 RETURN
 30 INPUT "Nap="; LINE a$: IF a$="" THEN GO TO 30
 32 IF VAL a$<10 THEN LET a$=" "+a$
 35 LET tag=VAL a$
40 RETURN
100 LET m$="*Januar*Februar*Marcius *Aprilis*Majus*Junius*Julius*Augusztus*Szeptember*Oktober*November*December*"
110 LET n$=" 1 2 3 4 5 6 7 8 910111213141516171819202122232425262728293031"
120 LET d$="VasHetKedSzeCsuPenSzo"
130 LET c$="303232332323"
140 LET b=0: LET c=0
200 INPUT "Ev?";a$
202 IF a$="" THEN LET ty=1984: LET a$="1984"
203 IF VAL a$<1760 THEN GO TO 200
204 IF VAL a$>9999 THEN GO TO 200
208 IF VAL a$<>0 THEN LET ty=VAL a$
210 INPUT "Honap? (1=Jan stb.)";a$
215 LET m=VAL a$
216 IF m<1 OR m>12 THEN GO TO 210
220 GO SUB 20
230 GO SUB 30
400 CLS : LET ly=0
402 IF ty/4<>INT (ty/4) THEN GO TO 420
404 LET Ly=1
410 IF ty/100=INT (ty/100) AND ty/400<>INT (ty/400) THEN LET LY=0
420 LET n=CODE c$(m)-20
422 IF m=2 AND ly THEN LET n=n+1
424 LET y=0
426 FOR j=1 TO m: LET y=y+CODE c$(j)-20: NEXT j
430 IF ly AND m>1 THEN LET y=y+1
435 LET y=y+1-n+(ty-1)*365+INT ((ty-1)/4)-INT ((ty-1)/100)+INT ((ty-1)/400)
440 LET y=y-7*INT (y/7)
450 CLS : PRINT INK 3;ty;TAB (31-LEN t$)/2;t$;TAB 28;ty
460 FOR j=1 TO LEN d$ STEP 3: PRINT AT j/3*2+2,0;d$(j TO j+2);TAB 29;d$(j TO j+2): NEXT j
500 LET p$=n$( TO n*2)
502 FOR j=1 TO y: LET p$=" "+p$: NEXT j
520 LET date=0: LET x=5: LET y=1
530 FOR j=1 TO LEN p$ STEP 2: LET y=y+2: IF y<16 THEN GO TO 560
540 LET y=3: LET x=x+4
560 IF p$(j TO j+1)=a$ THEN FLASH 1
565 PRINT AT y,X; INK 4;p$(j TO j+1)
566 FLASH 0
570 NEXT j
580 PRINT AT 19,0;"Kovetkezo honap (K)"
581 PRINT AT 20,0;"Elozo honap     (E)"
583 PRINT AT 21,0;"Datum           (D)"
600 LET f$=INKEY$
610 IF f$="d" THEN GO TO 200
650 IF f$<>"k" THEN GO TO 670
660 LET m=m+1: LET a$="99": IF m=13 THEN LET ty=ty+1: LET m=1
661 IF ty>9999 THEN LET ty=9999
665 GO SUB 20
669 GO TO 400
670 IF f$<>"e" THEN GO TO 680
672 LET m=m-1: IF m=0 THEN LET m=12: LET ty=ty-1: IF TY<1760 THEN LET ty=1760
673 LET a$="99"
674 GO SUB 20
676 GO TO 400
680 GO TO 600

Harmadik program (bioritmus):

  1 BORDER 6: PAPER 6: INK 0: CLS
 10 LET m$="303232332323"
 20 PRINT TAB 7; INVERSE 1;"B I O R I T M U S"
 30 INPUT "Nev= ";n$
 40 PRINT AT 2,0;n$
 50 INPUT "Szuletesi ev: ";j$
 55 IF VAL j$<=1900 THEN GO TO 50
 60 PRINT "Szul.: ";J$;"-";
 70 INPUT "Szuletesi ho (1-12): ";x$
 80 PRINT x$;"-";
 90 INPUT "Szuletesi nap: ";t$
100 PRINT t$
110 LET q=0
120 FOR i=1 TO VAL x$-1
130 LET q=q+CODE m$(i)-20
140 NEXT i
145 LET y=VAL j$
150 IF q>59 AND y/4=INT (y/4) THEN LET q=q+1
160 LET q=q+VAL t$+INT (365.25*(y-1))
200 INPUT "Datum: Ev= ";k$
205 IF k$<j$ THEN GO TO 200
210 PRINT "Datum: ";k$;"-";
220 INPUT "Honap:";l$
230 PRINT l$;"-";
240 INPUT "Nap: ";y$
250 PRINT y$
300 LET r=0
310 FOR i=1 TO VAL L$-1
320 LET r=r+CODE m$(i)-20
330 NEXT i
335 LET y=VAL k$
340 IF r>59 AND y/4=INT (y/4) THEN LET r=r+1
350 LET r=r+VAL y$+INT (365.25*(y-1))
400 LET z=r-q
600 LET amp=1.5
610 PRINT AT 8,0;"--------------------------------"
620 PRINT AT 13,0;"--------------------------------"
630 PRINT AT 18,0;"--------------------------------"
640 GO SUB 1100
650 PRINT AT 7,0;"Fizikai"
660 PRINT AT 12,0;"Erzelmi"
670 PRINT AT 17,0;"Szellemi"
700 LET phy=z-23*INT (z/23)
710 LET emo=z-28*INT (z/28)
720 LET sze=z-33*INT (z/33)
750 LET p=23
760 LET n=phy
770 LET k=104
780 GO SUB 1000
800 LET p=28: LET n=emo: LET k=64: GO SUB 1000
810 LET p=33: LET n=sze: LET k=24: GO SUB 1000
900 INPUT "Nyomtatora? (i/n) "; LINE q$: IF q$="i" THEN COPY
910 INPUT "Megegyszer? (i/n) "; LINE q$: IF q$="i" THEN GO TO 1
920 CLS : STOP
1000 REM Gorberajzolas
1010 FOR j=0 TO 255
1020 PLOT j,amp*SIN ((j/4+(8*n))*PI/p)*10+k
1030 NEXT j
1040 RETURN
1100 FOR i=0 TO 30 STEP 5
1110 LET nap=VAL y$+i
1120 IF nap>CODE m$(VAL l$)-20 THEN LET nap=nap-CODE m$(VAL l$)+20
1130 PRINT AT 9,i;nap
1140 PRINT AT 14,i;nap
1150 PRINT AT 19,i;nap
1160 NEXT i
1170 RETURN

6. Látványos képszerkesztés a Spectrummal
Nappalok és éjszakák a Földön

6.1 A program kidolgozása

Ebben a fejezetben egy olyan programot fogunk kidolgozni, amelynek közvetlen hasznát nem vehetjük, és ráadásul nagyon sok adatot is kell a gépbe bevinnünk, de jól mutatja majd a Spectrum grafikus képességeit. A programmal végül egy világtérképet rajzolhatunk a képernyőre. A program változatossá tételéhez beépítünk egy órát, ami a mindenkori nappal és éjszakai zónákat mutatja a Földön. A zónáknak természetesen az órával szinkronban kell váltakozniuk, az évszakok változását azonban a program nem számolja. A világtérképet természetesen címlappal is ellátjuk.
A tengereket kékre színezzük. A nappali zónákat sárgával, az éjszakaiakat feketével jelöljük. Bár a Spectrum nagy felbontóképességű grafikával rendelkezik, minden nyomtatási pozíciónál tulajdonképpen 2 különböző színt használhatunk: egyet a háttér és egyet az írás színezésére. A mi esetünkben a nappalok és az éjszakák határvonalánál 3 szín találkozik, a kék, a fekete és a sárga. Ha a zónákat csak minden egész órában mutatjuk, akkor a problémákat úgy oldhatjuk meg, hogy egy óra egy nyomtatási pozíció szélességének, vagyis 8 képpontnak feleljen meg.
Ebben az esetben a 3 szín mindig éppen két egymást követő nyomtatási pozíció határán találkozik. A világtérkép adatait DATA utasításokban tároljuk, majd READ utasításokkal olvassuk, és azután értékeljük őket. A megfelelő méretű világtérképet rá kell rajzolni egy 102*192-es négyzethálóra. Oszloponként (észak-déli irány bán haladva) kikeressük azokat a négyzeteket, amelyekben a víz és a szárazföli találkozik, és ezeket egy DATA utasításban tároljuk. Ha egy oszloppal elkészültünk, akkor két nullát írunk a végére, ezzel jelezve, hogy új oszlop következik. Az eljárást folytatva olyan DATA utasításokhoz jutunk, amelyek a rajzolórutin számára érthetők lesznek.
Az adatok bevitele után (jó gépelést kívánunk!) foglalkozhatunk a tulajdonképpeni programmal. Átugrunk a 132-es sorban kezdődő DATA-kon és beírjuk a

10 GO TO 8000

utasítást.
A feliratok fontosabb részeinek kiemelésére a 4. fejezetben ismertetett nagybetűket író rutint fogjuk használni, amit a 20-as sortól kezdődően viszünk be. Írjuk be következő utasításokat:

8000 CLS : INK 1: LET y$="Nappalok es ejszakak a Foldon": LET xpos=0: LET ypos=0: GO SUB 20
8010 INK 0: PRINT AT 9,0;"Lehetosegek: Eloreallitas(e)"
8011 PRINT ,"Megallitas  (m)"
8012 PRINT ,"Normalmenet (n)"
8013 PRINT ,"Beallitas   (b)"
8014 PRINT ,"Vege        (v)"
8020 PRINT : PRINT "A programot a honap elso napjan ujra kell inditani!"
8030 PRINT : PRINT "Ha vege, gepelje be v ENTER!"
8040 PRINT AT 5,0; FLASH 1;"Honap = ? (pl. Januar = 1 stb)"
8050 INPUT LINE m$: IF m$="v" THEN CLS : STOP
8055 FOR i=1 TO 12: IF m$=STR$ i THEN GO TO 8065
8060 NEXT i: GO TO 8050
8065 LET mon=VAL m$
8070 PRINT AT 5,0,,AT 5,5; FLASH 1;"Ido = ? (pl.. 1445)"
8075 INPUT LINE m$: IF m$="v" THEN CLS : STOP
8080 IF LEN m$<>4 AND LEN m$<>3 THEN GO TO 8075
8090 FOR i=1 TO LEN m$
8100 IF m$(i)>"9" OR m$(i)<"0" THEN GO TO 8075
8110 NEXT i
8200 LET uhr=VAL m$: LET st=INT (uhr/100)
8210 IF St<0 OR St>24 THEN GO TO 8075
8220 LET min=uhr-100*st: IF min>59 OR min<0 THEN GO TO 8075
8230 PRINT AT 5,0,,: LET uhr=100*st

Megoldottuk a hónapok és az órák lekérdezését és megteremtettük az időpont átállításának a lehetőségét. Most megrajzolhatjuk a világtérképet, megadhatjuk az időpontokat és az időeltolódásokat, valamint a Nap jelét is. A Napot piros színnél rajzoljuk fel.

7200 FOR i=2 TO 4: PRINT AT i,0,,: NEXT i: REM Nap
7210 LET yy=150
7220 LET XX=224-4*Uhr/50
7230 CIRCLE xx+8,yy,8
7240 INK 2
7250 FOR i=-8 TO 8
7260 FOR k=-8 TO 8
7270 IF i*i+k*k>64 THEN GO TO 7290
7280 PLOT xx+8+k,yy+i
7290 NEXT k
7300 NEXT i

Ha még beírunk egy kis rutint, ami az órajelet kiírja, akkor a világtérkép teljes lesz.

7000 INK 6: PRINT AT 5,0,,: REM Ora
7010 PRINT AT 5,8;"Ido: ";st;" Ora ";min;" Perc"
7020 RETURN

Ezután következik:

8300 BORDER 1: PAPER 1: INK 6: CLS
8310 GO SUB 7000: GO SUB 7200: INK 6
8320 LET y$="Nappalok es ejszakak a Foldon": LET xpos=0: LET ypos=3: INK 7: GO SUB 20: INK 6
8330 PRINT AT 7,3;"-12 -8  -4   0  +4  +8 +12"
8340 GO TO 9600

A 9600-as sortól kezdve kirajzoljuk a világtérképet, beállítjuk az időpont, valamint a nappali és az éjszakai zónák megfelelő értékét.

9600 LET sek=3000: REM Lefutas
9610 GO SUB 9000

A 9000-es sorral kezdődő rutinban rögzítjük minden hónap nappali és éjszakai területeit, kiszámítva közben a hozzá tartozó időket is. Ezután beolvassuk és kirajzoljuk a térképet:

9000 LET anf=32: RESTORE : REM terkeprajzolas
9010 DIM f(12): DIM s(12)
9020 LET f(1)=3: LET f(2)=4: LET f(3)=5: LET f(4)=6: LET f(5)=7: LET f(6)=8
9030 LET f(7)=8: LET f(8)=7: LET f(9)=6: LET f(10)=5: LET f(11)=4: LET f(12)=3
9040 LET s(1)=5: LET s(2)=6: LET s(3)=7: LET s(4)=7: LET S(5)=8: LET s(6)=9
9050 LET s(7)=9: LET S(8)=8: LET s(9)=7: LET s(10)=6: LET S(11)=5: LET s(12)=5
9060 LET a1=xx-8*f(mon): LET a2=xx+8*s(mon)
9100 READ x1,x2
9110 IF x1>8000 THEN GO TO 9280
9120 IF x1=0 THEN LET anf=anf+1: GO TO 9270
9200 INK 6
9210 IF anf<a1 THEN INK 0
9220 IF anf<a2-192 THEN INK 6
9230 IF anf>=a2 THEN INK 0
9240 IF anf>=192+a1 THEN INK 6
9250 PLOT anf,x1
9260 DRAW 0,x2-x1
9270 GO TO 9100
9280 RETURN

A világtérkép megrajzolása után gondoskodnunk kell arról, hogy az órát percenként, az egész képet pedig minden órában újra ki tudjuk rajzolni:

9620 LET min=min+1
9630 LET dif=0
9640 IF min=60 THEN LET dif=1
9650 PAUSE 2325
9660 GO TO 9710
9700 PAUSE sek
9710 IF INKEY$="v" THEN CLS : STOP
9720 IF INKEY$="e" THEN LET sek=50
9730 IF INKEY$="m" THEN PRINT AT 21,22;"Megallitva":PAUSE 0:PRINT AT 21,22;"          "
9740 IF INKEY$="n" THEN LET sek=3000
9750 IF INKEY$="b" THEN GO TO 8070

Az óra előreállítását és az idő normális múlását, a SEK változó értékét szünettel percenként megváltoztatjuk. Arra azonban ügyelnünk kell, hogy a térkép rajzolásihoz is időre van szükségünk, ezért a percek számát eggyel növelni kell, mivel a kép elkészültéig már megkezdődött a következő perc:

9760 LET min=min+1
9770 IF min>=60 THEN LET st=St+1
9780 LET uhr=100*st
9790 IF min>=60 THEN LET min=0
9800 IF St>=24 THEN LET St=0
9810 GO SUB 7000
9820 IF min<>0 THEN GO TO 9700
9830 GO SUB 7200
9840 GO SUB 9000
9850 LET min=min+2+dif
9860 LET dif=0
9870 PAUSE 2325
9880 GO TO 9700

A hiányzó DATA utasítások a programlistában találhatók.
Ha már betápláltuk a számítógépbe a világtérkép adatait, akkor még további bővítési lehetőségeink is vannak, pl. adott földrészeket egyenként kinagyítva kirajzolhatunk.

7. Kiegészítő készülékek és bővítési lehetőségek

7.1 Bevezetés

Minden számítógép-tulajdonosban előbb vagy utóbb felmerül a kérdés: milyen tartozékkal tudná rendszerét bővíteni? A SINCLAIR cég sok kiegészítő készüléket kínál, pl. az Interface 1-et, a kazettás egységet, amelyekkel a számítógép nyújtotta lehetőségeket bővíteni, lehet. Mivel a Spectrum gépek nagyon elterjedtek a világon, más cégek is foglalkoznak a SINCLAIR számítógépek perifériáinak gyártásával. A Spectrum a ~perifériák széles skálájával rendelkezik, így majdhogynem csak a használó pénztárcája szab határt a bővítésnek.
A hosszabb programok kizárólag képernyőn való szerkesztése nagyon fárasztó, ezért elsőként a nyomtató fog hiányozni. Ha a nyomtatót csak listázásra használjuk, akkor az ALPHACOM nyomtató elfogadható, de az igényesebb használóknak a SEIKOSHA GP 505 típusú mátrixnyomtatót ajánljuk. Egy CENTRONICS PARALEL illesztővel nagyobb számítógépek számára készített nyomtatók is használhatók, amelyek soronként 80 vagy még több karaktert is nyomtatnak. A 80 karakteres nyomtatók írásképe szép, és így a Spectrum szövegszerkesztő feladatok megoldására is használható.
Ha sok szöveget kívánunk a Spectrummal íratni, akkor egy idő után elégedetlenek leszünk a gumibillentyűkkel (ez természetesen a Spectrum Plus tulajdonosokra nem vonatkozik). A cégek felismerték a problémát, és meg is oldották. A Spectrum billentyűzet a számítógép külön része. Ha felnyitjuk a Spectrum dobozát, azt látjuk, hogy a billentyűzettől két dugóval csatlakozó lapos kábel vezet a nyomtatott áramköri alaplemezhez. Egy új billentyűzetet általában úgy csatlakoztathatunk, hogy kihúzzuk a két kábelt, és a helyére bedugjuk az új billentyűzet két kábelét.

7.2 Az Interface 1 bővítő egység

A Spectrum kétségkívül legsokoldalúbb kiegészítő készüléke az Interface 1. Az illesztővel gyors háttértárhoz juthatunk; egy beépített RS 232-es csatlakozóhelyen keresztül más számítógépekkel, nyomtatókkal és átvivőkkel kapcsolhatjuk össze gépünket. Mindez nem is nagyon költséges. Az Interface 1 lehetővé teszi továbbá 64 db Spectrum és SINCLAIR QLS összekapcsolását is. A magnetofon és a ZX nyomtatók csatlakoztatási lehetősége is megmarad.
Az Interface 1-ben egy 8 kbyte-os ROM bővítés is van, amely a Spectrum 16 kbyte-os ROM-jához csatlakozik. A ROM-bővítés a Spectrum parancs-, ill. utasításkészletét az alábbi utasításokkal egészíti ki:

CAT
CLOSE
ERASE
FORMAT
MOVE
OPEN

és a következő utasítások lehetőségeit kiterjeszti:

CLS
CLEAR
INPUT
INKEY$
PRINT
LPRINT
LIST
LLIST
SAVE
LOAD
MERGE
VERIFY

Az utasítások jelentése az 1. függelékben található, mi csak néhány érdekesebbet emelünk ki. A CAT paranccsal tartalomjegyzéket kérhetünk a kazettás egységről. A CAT parancs hatására megtudjuk a kazetta és a rajta levő első ötven, nem védett file nevét. A védett file-ok neve CHR$ 0-val kezdődik. Ezek a file-ok CAT paranccsal nem olvashatók. Megjelenik még a rendelkezésünkre álló tárhely mennyisége kbyte-ban. Ha a parancsot a fenti formában írjuk be, akkor a lista a képernyőn jelenik meg.
Ha a listát pl. a nyomtatóra akarjuk kiírni, akkor meg kell nyitni a megfelelő csatornát, és a parancsot az alábbi formában kell beírni:

CAT #n;1

ahol n a csatornaszám.

Ha az RS 232-es csatlakozóhelyen keresztül az adatátvitel sebességének meghatározására a FORMAT utasítást használjuk, akkor az 50,110, 300, 600, 1200, 2400, 4800, 9600 és 19200-as értékeket lehet beadni. Ha nem adunk be külön értéket, akkor az átviteli sebesség 9600 baud (1 baud (Bd) egy elemi karakter/s sebességegység. A FORMAT-ban megadható értékek 50-től 300-ig kicsi, míg 600-tól 9600-ig közepes átviteli sebességeket jelentenek). Ha olyan értéket írunk be, amelyik nem szerepel a listán, akkor az utasítás a legközelebbi és kisebb értéket veszi figyelembe. A minimum természetesen az 50-es.
A CLS# utasítás az Interface 1 jelenlétében is megengedett. Ellentétben az egyszerű CLS utasítással, a CLS# nemcsak a képernyő file-t törli, hanem a következőket is meghatározza:

A CLEAR# utasítás a csatornán kivitt adatokat törli. Minden csatornát lezár; azok az adatok, amelyek valamelyik puffertárban voltak, ellentétben a CLOSE# utasítással, így elvesznek.
Az Interface 1-hez 8 kazettás egység csatlakoztatható, és ezeket egyidejűleg képes vezérelni. A kazettás egységgel speciális végtelenített szalagok írhatók és olvashatók. Minden kazettában egy körülbelül 5 m hosszú szalag van, amelynek a végigjátszásához körülbelül 7s-ra van szükség. A szalag közepén levő adat 3-5s alatt érhető el. A kazettában kb. 90 kbyte adat tárolható. A kazetta tárhelyeinek megszerkesztését célszerű többször is elvégezni, mivel a rendelkezésre álló tárhelyek a próbálkozások során változhatnak.

Az Interface 1 előnye a helyi hálózat kiépítésének lehetősége. A 64 db Spectrurnmal és a SINCLAIR QLS-sel kiépített kapcsolatot egy egyszerű kéterű kábellel létrehozhatjuk. Az adatokat 5 kbyte/s sebességgel vihetjük át az egyik gépből a másikba.
A FORMAT "n",7 utasítással a Spectrumhoz hozzárendeljük a 7-es pozíciószámot. Ennek a pozíciószámnak 1-64 közé kell esnie. A POKE 23749,7 parancsnak is ugyanez a hatása. A LOAD, SAVE, MERGE stb. parancsokkal az adatátvitel egyszerűen megoldható. Az m karakter a kazettás egységet, az n karakter a hálózati csatlakozást jelenti. A variációs lehetőségek sokfélék. Az Interface 1 kézikönyv szerint pl. több Spectrum tulajdonos egy közös drága perifériát is használhat, ilyen lehet pl. egy nyomtató.
Több Spectrum összekapcsolása esetén új játékokra nyílik lehetőség. Olyan programok is készíthetők, ahol a két számítógép egy program különböző részein dolgozik. A számítások eredményei kicserélhetők, és azok két (vagy több számítógép esetén több) képernyőn is megjeleníthetők. Az összekapcsolás mind a hardver, mind a szoftver fejlesztők számára ad érdekes feladatokat.

7.3 Sornyomtató

Az Interface 1 és az RS 232-es csatlakozó tulajdonosai a nyomtatón kívül írógépet is használhatnak. A modellek közül a BROTHER cég EP 44-esét szeretnénk kiemelni, a típus sokoldalúsága miatt. Az írógép vagy szalag nélkül, hőérzékelő papírra ír (ez nem túl olcsó), vagy szalaggal (ami szintén nem olcsó) normál papírra. Az íráskép a 18*24-es pontmátrixnak köszönhetően nagyon jó. A Spectrumhoz ennél alkalmasabb nyomtatót nem is találhatnánk. Bedugjuk az RS 232-es kábelt, és az adatátvitel paramétereinek a következő értékeket adjuk:

BAUD RATE	tetszőleges, de egyeznie kell a Spectrum értékével
BIT LENGTH	8
PARITY	N
NEW LINE	CR + LF
CODE	7 BIT
ER	Y

A megfelelő kapcsolót terminál állásba tesszük és a Spectrumnak a következő utasítást adjuk:

OPEN#3,"t": FORMAT "t";baud rate

ahol a baud rate az EP 44-nek megadott átviteli sebesség. Az LPRINT és a LLIST utasítások már az EP 44-nek szólnak.
Az LPRINT és a LLIST utasítások a PRINT#3 és a LIST#3 utasításoknak felelnek meg, COPY-t sajnos nem írhatunk, mivel az EP 44 rajzolni nem tud.
Az írógép a szövegtárolás és a távadatátvitel területén nagyon sokoldalú. Egy kis szövegszerkesztőt is beépítettek a gépbe. Azoknak a Spectrum tulajdonosoknak, akiknek nincs kiegészítő billentyűzetük, hasznos az a lehetőség, hogy az EP 44-et beviteli perifériaként is alkalmazhatják.
Egy egyszerű rutinra van csupán szükség:

10 OPEN#3,"t":FORMAT "t";300
20 BORDER 0
100 LET m$=INKEY$#3
110 IF CODE m$>31 THEN PRINT m$;
150 GO TO 100

Minden, amit az EP 44-en beadunk, megjelenik a képernyőn. A rutin segít az írógép billentyűzetén bevinni a programokat. Az EP 44 használható nyomtatóként és korlátozott mértékben billentyűzetként is.
Ha Spectrumból azonnal az írógépen akarunk írni, vagy netán a kettő között párbeszédes üzemmódban kívánunk dolgozni, akkor az előbbi rutint a következő két sorral még ki kell egészíteni:

120 LET n$=INKEY$
130 IF CODE n$>31 THEN PRINT#3;n$

7.4 Fényceruza

A Spectrum (és a többi számítógép) jó kiegészítője a fényceruza. A fényceruzával olyan dolgokat vihetünk végbe, ami egy laikus számára varázslatnak tűnhet. Vonalakat, köröket és más figurákat rajzolhatunk a képernyőre. A menüből való látványos kiválasztásra is használhatjuk a ceruzát. Természetesen valódi csodát ne várjunk tőle. Aki pl. az aacheni dómot szeretné a képernyőre rajzolni, szép egyenes vonalakkal, annak sokat kell gyakorolnia.
Hogyan működik egy ilyen fényceruza? Elvileg egy fényérzékelő, amely a fényjeleket a számítógép számára érthető elektromos jelekké alakítja. A televíziós kép pl. minden másodpercben 25-szőr jelenik meg a képernyőn. Az elektronsugár 625 vízszintes vonalat rajzol a képernyőre. Ha a fényceruzát a képernyő elé tartjuk, akkor minden olyan esetben, amikor az elektronsugár a neki megfelelő pozícióra irányul, fényt érzékel. Ilyenkor jelet küld a számítógépbe. A számítógép kiszámítja, mennyi idő telt el a sugár rajzolásának kezdete óta, vagyis azóta, amikor a sugár még a bal felső sarokban volt. Ebből az időkülönbségből egész pontosan meg tudja határozni, hogy melyik pozíción volt a fényceruza.
Szabad kézzel bonyolultabb festményeket nem tudunk készíteni, de egy jó szoftverrel még ezt is megtehetjük. A fényceruza nagyon kellemes beviteli eszköz azok számára akik nem értenek a programozáshoz, egyszerűen csak rá kell mutatni arra a pontra, amit be akarunk vinni. A fényceruzával a választás is egyszerű a menüből. Vigyáznunk kell arra, hogy a fényceruza ne kapjon fényt a képernyőhöz való közelítés közben, vagy akkor, amikor a képernyőn továbbvisszük. A hibát kiküszöbölhetjük, ha kis szünetet tartva, kétszer egymás után ugyanazt a sort lekérdezzük. Ha mindkétszer ugyanazt az eredményt kapjuk, akkor biztosak lehetünk abban, hogy a ceruzát egy helyen tartottuk.
A programba a következő sorokat írjuk be:

100 LET sor1=USR 63109: REM vagy az a szám, amelyen az előállító rutint elhelyezte
110 PAUSE 10
120 LET sor2=USR 63109
130 IF sor1=sor2 THEN GO TO ...
140 GO TO 100

A 110-es sorba írt szünet tetszőlegesen változtatható, és így optimális eredményt kaphatunk.

7.6 Fordító

A BASIC programok hátrányos tulajdonsága, hogy ha sok a számolási művelet, akkor viszonylag lassan futnak. Meggyorsíthatjuk a futást, ha a számítógépet megkíméljük a BASIC nyelvről a gépi kódra való fordítástól. Ez elég fáradságos és nem is egyszerű feladat. A számítógép ebben is tud segíteni, ha erre alkalmas programmal rendelkezik. Az ilyen programot fordítónak hívják és éppen azt teszi, amit megkívánunk tőle; BASIC nyelvről gépi kódra fordít. A fordítóprogram maga is gépi kódú. Töltsük be a fordítót a Spectrumba. Ezután kezdjünk el BASIC nyelven programozni, vagy töltsünk be egy már kész programot és fordítsuk le.
A fordítótól függően a gépi kódú program 5-50-szer gyorsabban fut, mint BASIC nyelven. A fordítóprogramok alapvetően abban különböznek egymástól, hogy egész számokat vagy lebegőpontos számokat tudnak-e kezelni. Felmerül a kérdés, hogy mi a jelentősége ennek, ha lehetőségünk van mindkét számtípus kezelésére. Erre a sebességek közötti eltérés adja meg a választ. Éppen a lebegőpontos aritmetika az, ami nagyon időigényes. Ha pl. olyan játékokat szeretnénk lefordítani, amelyeknél a reakcióidő és a rajzolás a legfontosabb, akkor egy egyszerű fordító is megfelel. A nyert pontokat mindig kifejezhetjük egész számokkal. A könyvelési programok esetében az általános fordító a jobb, hiszen az üzletemberek egy fillérről sem szeretnének lemondani.
A fordítók általában nem értik mindazokat az utasításokat, amik a Spectrumban rendelkezésünkre állnak. Pl. legtöbbször a tömbök megengedett dimenziószáma egy. Ez természetesen nem jelentős probléma, mivel minden többdimenziós tömb ábrázolható egy dimenziósként is, amelyben az értékeket egymás után tároljuk. A Spectrumon belül a tárolás mindig így valósul meg. A fordító általában nem érti a VAL utasítást, és a számított ugrást nem hajtja végre. De ez a probléma is megkerülhető pl. CODE CHR$ utasítással.
A fordítók előnye még, hogy a részprogramok egymás után fordíthatók és különböző tárcímekben kezdhetők. A rutinokat aztán tetszőleges programból hívhatjuk a RAND USR... utasítással.

8. Táblázatok grafikus rajzolása

8.1. Bevezetés

A Spectrum kiváló grafikai képességeit a legtöbb játékprogramnál jól ki lehet használni. Ebben a fejezetben nem a képek rajzolásával, hanem a táblázatok grafikus ábrázolásával foglalkozunk.
A táblázatok grafikus ábrázolása kedvelt felhasználási területe a személyi számítógépeknek, a Spectrum is alkalmas rá. Az értéktáblázatokat oszlop- és kördiagramokkal legjobb ábrázolni.
Állítsunk össze egy programot, amely mindkét diagrammal képernyőre viszi az adatokat!
A programot úgy készítjük, hogy a léptéket tetszőlegesen lehessen megválasztani. Több diagram adatának tárolására és módosítására is lehetőséget kell biztosítani.

8.2. A BUSYGRAPH program kidolgozása

A program felépítése elvileg nagyon egyszerű.

1. A diagramok inicializálása, azaz tárhely foglalás.
2. A menü, ami egyben a különböző diagramok tartalomjegyzéke is.
3. A képernyős ábrázolás vezérlése.
4. Az oszlopdiagramok szerkesztése.
5. A kördiagramok szerkesztése.
6. A bevitel és a változtatások kivitelezése.
7. A program és az adatok tárolása.

Kezdjük a helyfoglalással. Korlátozzuk 15 db-ra azoknak a diagramoknak a számát, amelyeket a programból hívni lehet. Ez bőven elegendő. Aki több diagramot akar tárolni, annak a programot is többször kell tárolnia. Tehát:

20 DIM t$(15,20)

azaz minden felirat 20 karakter hosszúságú lehet. A címek elhelyezése a következő:

30 FOR i=1 TO 15: LET t$(i)="Szabad": NEXT i

A diagramba beépíthető értékek (oszlopdiagram esetén az oszlopok, kördiagram esetén a szektorok) száma maximum 24 lehet. A változót dimax-mak nevezzük. Meg kell határoznunk még a dm változót is, amelyben később a diagramban szereplő értékek valódi számát adjuk meg. Az értékeket x(dm,15)-ös tömbben tároljuk. Szükségünk van még egy segédvektorra, amiben az adatok használható léptékben szerepelnek.

40 LET dimax=24: LET dm=dimax: DIM x(dm,15)
50 DIM y(dm): DIM a(dm)

Vigyázzunk, a programrészt csak egyszer futtathatjuk, különben minden adatot törlünk!
Adjuk be a

10 BORDER 0: PAPER 0: INK 6: LET m=9000: GO TO m

utasítást, hogy leállás esetén a program GOTO 1-gyel, az adatok elvesztése nélkül újraindítható legyen.
Most nézzük a 9000-es sorban kezdődő menüt!

9000 CLS : PRINT TAB 2; INK 3;"B U S Y G R A P H"''
9010 FOR i=1 TO 15: PRINT " ";i;TAB 5;t$(i): NEXT i
9020 PRINT AT 20,2; INK 6;"V ... Vege"
9100 INPUT INK 4;"Adjon be egy szamot! "; LINE m$

Ellenőrizni kell, hogy szabályos volt-e a bevitel:

9110 IF m$="v" THEN GO TO 9990
9120 FOR i=1 TO 15: IF m$=STR$ i THEN GO TO 5000
9130 NEXT i

Ha ciklus lefut, akkor a bevitel hibás volt, és visszaugrunk a 9100-as utasításra:

9140 GO TO 9100

A 9900-as sorban megjelenik a kérdés: Megőrizzük az adatokat? Ha igen, akkor lehet magnetofonon vagy kazettás egységen, ahogy azt a 4. fejezetben már csináltuk.
Az 5000-es sornál eldöntjük, hogy oszlop- vagy kördiagramot akarunk-e használni A döntéshez az egyszerűség kedvéért egy X0 értéket használunk, ami a diagram kezdő koordinátája lesz. Az oszlopdiagramnál X0=40, a kördiagramnál x0=90.

5000 LET dm=a(VAL m$)
5010 IF x0<=50 THEN GO TO 1000
5020 IF x0>50 THEN GO TO 3000
5100 PAUSE 0: LET n$=INKEY$
5200 IF n$="m" THEN GO TO m
5300 GO TO 5100

A biztonság kedvéért írjuk még be a

60 LET x0=40: LET y0=20

utasítást, hogy a változók meghatározása már az első inicializálás előtt megvalósuljon.
Az 1000-es sortól állítjuk elő az oszlopdiagramot, a 3000-es sortól a kördiagramot, Mindkét esetben ki kell írnunk egy üzenetet, hogy emlékezzünk rá, melyik ábrázolási mód következik. Erre a sorra kétszer van szükségünk, ezért egy rutint írunk a 100-as sorba.

100 PRINT INK 4;"Menu Oszlop Kor Rakovetkezo     Utolso Valtoztatas     tabla:";VAL m$
110 RETURN

A "rákövetkező", ill. az "utolsó" üzenet arra a lehetőségre utal, hogy megtekinthetjük a következő, ill. az utolsó diagramot anélkül, hogy visszamennénk a menühöz. A D a VAL m$-ral együtt az aktuális diagram számát adja meg.
A vezérlősort a következő utasítás határozza meg:

1000 CLS : GO SUB 100

Ki is kell nyomtatni:

1010 PRINT AT 2,3; INK 3;t$(VAL m$)

A diagram rajzolását a kerettel kezdjük:

1100 LET x0=40: LET y0=20
1110 FOR i=0 TO 1
1120 PLOT x0+i,y0+i
1130 DRAW 200,0: DRAW 0,120
1140 DRAW -200,0: DRAW 0,-120
1150 NEXT i

Az x tengelyre elkészítjük a léptéket:

1160 FOR i=INT (1+dm/6) TO dm STEP INT (1+dm/6)
1170 PRINT AT 20,(x0-8)/8+i/8*(192/dm);i: NEXT i

Az adatok az x(dimax, VAL m$)-os tömbben az első helyekre tárolódnak. A lefoglalt értékek számát a VAL m$-ban tároljuk, és az 5010-es sorban adjuk át a dm változónak. Az alkalmas lépték megválasztásához meg kell keresni az értékek közül a legnagyobbat:

1180 LET max=0
1190 FOR i=1 TO dm: IF x(i,VAL m$)>max THEN LET max=x(i,VAL m$)
1200 NEXT i
1210 LET top=max

Ha max = 0, akkor még nem adtunk be adatot a diagramhoz, és azonnal a bevivő vagy az adatmódosító rutinra kell ugrani. Ezt a 4000-es sorban kezdjük.

1220 IF max=0 THEN PRINT AT 20,0,,: GO TO 4000

Az adatokat normalizálni kell:

1230 LET max=100/max
1240 FOR i=1 TO dm: LET y(i)=max*x(i,VAL m$): NEXT i

Fel kell használnunk az y segédvektort is. Az y tengely beosztásához egy kis trükkre van szükségünk:

1250 LET sc=1: IF top<30 THEN LET sc=10
1260 FOR i=0 TO 4
1270 PRINT AT 9+i*3-y0/8,0; OVER 1;INT (sc*(top-i/4*top))/sc
1280 NEXT i

Befejezésként elhelyezzük az oszlopokat:

1300 LET xa=x0+50/dm
1310 FOR i=1 TO dm
1320 FOR j=0 TO 125/dm STEP 2
1330 PLOT xa+j,y0
1340 DRAW 0,y(i)
1350 NEXT j
1360 PLOT xa,y(i)+y0
1370 DRAW 125/dm,0
1380 DRAW 0,-y(i)
1390 LET xa=xa+200/dm
1400 NEXT i
1900 GO TO 5100

A kördiagram készítése előtt már csak egy kis feladat van hátra: egy új vezérlősort kell írni.

4000 PRINT AT 0,0; INK 5;"Be:";
4010 PRINT INK 4;" Menu Cim Ertek Torles Ok                      "
4020 PAUSE 0: LET n$=INKEY$: IF n$="o" THEN GO TO 5000
4030 IF n$="c" THEN GO TO 4200
4040 IF n$="e" THEN GO TO 4300
4050 IF n$="m" THEN GO TO m
4060 IF n$="t" THEN GO TO 4100
4070 GO TO 4000

Az adatok törlésénél nagyon óvatosnak kell lennünk, így a 4100-as sorban egy biztonsági kérdést teszünk fel:

4100 INPUT "Torles? (i/n) "; LINE n$
4110 IF n$<>"i" THEN GO TO 4000
4120 FOR i=1 TO dimax: LET x(i,VAL m$)=0: NEXT i
4130 LET a(VAL m$)=1
4140 LET t$(VAL m$)="Szabad"
4150 GO TO 5000

A bevitellel, ill. a módosítással, valamint az adatok számával és magával az adatokkal is foglalkoznunk kell.

4200 INPUT "Bevitel: "; LINE n$: IF n$<>"" THEN LET t$(VAL m$)=n$
4210 PRINT AT 2,3,,;AT 2,3; INK 3;t$(VAL m$)
4220 GO TO 4000

Az adatok száma:

4300 INPUT "Adatok szama (ENTER=";(a(VAL m$));")"; LINE n$: IF n$="" THEN GO TO 4340
4310 FOR i=1 TO dimax: IF n$=STR$ i THEN GO TO 4330
4315 NEXT i
4320 GO TO 4000
4330 LET a(VAL m$)=VAL n$
4340 LET dm=a(VAL m$)
4350 INPUT "Adatot akar valtoztatni?" (i/n)"; LINE n$: IF n$<>"i" THEN GO TO 4000
4360 FOR i=1 TO a(VAL m$)
4370 INPUT "Ertek ";(i);" (ENTER-";(x(i,VAL m$));" V-Vege) "; LINE n$: IF n$="" THEN GO TO 4400
4380 IF n$="v" THEN PAPER 0: INK 6: GO TO 5000
4390 LET x(i,VAL m$)=VAL n$
4400 NEXT i

A használóra bízzuk, hogy készít-e adatbevitelt ellenőrző programot.
Az oszlopdiagram elkészítése után rátérhetünk a kördiagram megszerkesztésére. A rajzolás előtt vigyük be az adatokat:

3000 CLS : GO SUB 100: REM kordiagram
3005 LET sum=0
3010 FOR i=1 TO dm
3020 LET sum=sum+x(i,VAL m$)
3030 NEXT i
3040 IF sum=0 THEN GO TO 1000
3050 CLS : GO SUB 100
3060 PRINT AT 2,3; INK 3;t$(VAL m$)

Rajzoljunk most egy kört:

3100 LET x0=90: LET y0=72
3110 CIRCLE x0,y0,y0

Normalizáljuk az értékeket, és helyezzük el az y(dim) vektorba:

3120 FOR i=1 TO dm: LET y(i)=x(i,VAL m$)/sum: NEXT i

A körcikkek rajzolásához trigonometriai ismereteinket használjuk fel:

3200 LET win=0
3210 LET xp=22-y0/8: LET yp=x0/8
3220 LET u=2*PI*y0

A körcikkek helyes pozicionálásához vezessük be a scal változót:

3230 LET scal=0.9

A kör középpontjának meghatározásához és a sugarak megfelelő szögben való rajzolásához ciklust szervezünk:

3400 FOR i=1 TO dm
3410 PLOT x0,y0
3420 LET win=win+y(i)
3430 LET x1=y0*COS (2*PI*win)
3440 LET x2=scal*y0*COS (2*PI*(win-y(i)/2))
3450 LET y1=y0*SIN (2*PI*win)
3460 LET y2=scal*y0*SIN (2*PI*(win-y(i)/2))
3470 DRAW x1,y1
3480 PRINT AT 21-y0/8-y2/8,x0/8-1+x2/8; INVERSE 1;i
3490 NEXT i

A kördiagram mellett a képernyő bal felén még van helyünk, nyomtassuk ki az adatok százalékos arányát és középértékét:

3500 PRINT AT 3,21; INK 5;"Ertek (%)"
3510 FOR i=1 TO dm STEP 2: PRINT AT (i+6)/2,21; INK 5;i;
3520 PRINT TAB 23;INT (1000*y(i))/10;
3530 IF (i+1)<=dm THEN PRINT TAB 28;INT (1000*y(i+1))/10
3540 NEXT i
3550 PRINT AT 17,20;"Osszeg";AT 18,19;INT (100*sum)/100
3560 PRINT AT 20,20;"Kozepertek";AT 21,19;INT (100*(sum/dm))/100
3900 GO TO 5100

A diagram megrajzolása után a program az 5100-as sorba tér vissza. A menübe való visszatérésről már gondoskodtunk, de meg kell oldanunk még néhány egyéb választási lehetőséget is:

5210 IF n$="o" THEN GO TO 1000
5220 IF n$="k" THEN GO TO 3000
5230 IF n$="r" AND VAL m$<15 THEN LET m$=STR$ (VAL m$+1)
5240 IF n$="u" AND VAL m$>1 THEN LET m$=STR$ (VAL m$-1)
5250 IF n$="r" OR n$="u" THEN GO TO 5000
5260 IF n$="v" THEN GO TO 4000
5300 GO TO 5100

8.3. A program használata

Fejlesszük a programot tovább! Tárolás után indítsuk el a programot! A képernyőn megjelenik a menü. Adjunk be egy számot! Gépeljük be az 1 ENTER parancsot. Megjelenik a vezérlősor és a diagram kerete is. A változók minden értéke 0, így nem lehet diagramot rajzolni. Ebből a program tudja, hogy új diagram készítéséről van szó. Megjelenik a megfelelő vezérlősor

Be: Menü Cím Érték Törlés Ok

Ha nem akarunk adatot bevinni, akkor M-mel visszatérhetünk a menühöz. Ha a T billentyűt nyomjuk le, akkor beadhatunk egy feliratot, pl.: teszt. Ez azonnal a szabad felirat helyébe kerül. A E bevitele után egy kérdés jelenik meg az értékek számáról. Ha nem akarjuk az értékeket megváltoztatni, akkor ENTER-t kell adni, egyébként egy 1-24 közötti számot, pl. 10-et.
Most megadhatjuk azt, hogy az értékeken kívánunk-e változtatni, ha igen i. Adjuk be pl. az .1,2,3...10 számsorozatot, és nézzük meg, hogy mi történik! Az utolsó szám után a gép azonnal elkezdi rajzolni a diagramot, és megjelenik az első vezérlősor.

Menü Oszlop Kor Rákövetkező Utolsó Változtatás

A K billentyű benyomásával az értékeket kördiagram formájában láthatjuk. Az egyes értékek százalékos aránya, az összeg és a középérték is megjelenik.
Ha valamelyik értéket meg akarjuk változtatni vagy még pótlólagosan adatot szeretnénk bevinni, akkor az A billentyűt kell lenyomni. Hagyjuk az értékek számát változatlanul, de az első számnak adjunk 20-at. Végül gépeljünk be egy v betűt, és ezzel az új diagram kész.
Zavaró a programban, hogy az adatokat nem láthatjuk, és a hibásan beadott értéket csak akkor tudjuk megváltoztatni, ha v-vel lezártuk a bevitelt, vagy az utolsó értéket is elértük. Ezt a hibát egyszerűen kiküszöbölhetjük.
Szakítsuk meg BREAK-kel a programot, és adjuk be ezeket az utasításokat:

200 FOR i=5 TO 17: PRINT AT i,6;"               ": NEXT i: RETURN

Ezzel egy 13 soros 15 oszlopos tömböt hoztunk létre. Írjuk át a 4350-es sort a következőképpen:

4350 INK 0: PAPER 7: GO SUB 200: PRINT AT 5,6;"Ertektablazat"

és azután;

4352 FOR i=1 TO dm: IF i<13 THEN PRINT AT i+5,6;i;TAB 9;x(i,VAL m$)
4353 IF i>12 THEN PRINT AT i-7,18;i;TAB 22;x(i,VAL m$)
4355 NEXT i
4356 INK 6
4380 IF n$="v" OR n$="V" THEN PAPER 0: INK 6: GO TO 5000
4382 IF n$="l" OR n$="L" AND i>1 THEN LET i=i-1: GO TO 4370
4384 IF CODE n$>57 THEN GO TO 4370
4390 LET x(i,VAL m$)=VAL n$
4392 IF i<13 THEN PRINT AT i+5,9; PAPER 7;"      ";AT i+5,9; INK 0;x(i,VAL m$)
4393 IF i>12 THEN PRINT AT i-7,22; PAPER 7;"      ";AT i-7,22; INK 0;x(i,VAL m$)
4396 PAPER 0

Tároljuk ezt a változatot! Ha értéket viszünk be vagy változtatunk meg, akkor mindig megjelenik az értéktáblázat, és ezzel az egész áttekinthetővé válik.
A bevitelnél az 'L' billentyű lenyomásával visszaugorhatunk az utolsó értékre A diagramok megjelenésekor az 'r', ill. az 'u' billentyű lenyomásával az előző vagy a következő diagramhoz jutunk anélkül, hogy vissza kellene térnünk a menühöz.
A program tág teret hagy a változtatásnak. További ábrázolási lehetőségek vonaldiagram, a negatív számok megjelenítése, két diagram egyidejű ábrázolása diagramok összeadása és az összeg új diagramként való tárolása.

1. Függelék: A Spectrum utasításkészlete

Az INPUT, a DEF és a DATA utasításokon kívül minden utasítás közvetlen parancsként is adható. Egy sorban több utasítás is állhat, ezeket kettősponttal kell egymástól elválasztani. A REM utasítás utáni rész viszont nem kerül végrehajtásra. Az IF utasítást ugyanazon sorban az egymást követő utasítások csak abban az esetben mennek végbe, ha a feltétel rész logikai értéke igaz.
Ezekután ismertetjük a Spectrum utasításait.

BEEP x,y
x másodpercig megszólal egy hang a beépített hangszóróból, amelynek magassága y félhanggal a normál c fölött van. Ha y negatív, akkor a hang c-nél mélyebb. A hang megjelenik a EAR kimeneten van és erősíthető.

BORDER m
Az m a képernyőkeret és a képernyő alsó részének háttérszínét adja meg. Az m értéke 0 és 7 közé esik.

BRIGHT n
A kontrasztot határozza meg, ha n 0, akkor normál, ha 1, akkor éles, ha 8, akkor "átlátszó".

CAT
A kazettás egységre vonatkozik (lásd később).

CIRCLE x,y,z
Az x,y pontba z sugárral kört rajzol.

CLEAR
Törli a változókat. Ezenkívül a RESTORE és a CLS utasítás is végbemegy, a PLOT helyzete a bal alsó sarokban (0,0) lesz és a GO SUB a tárat törli.

CLEAR n
Ugyanaz, mint a CLEAR utasítás és amennyiben ez lehetséges, a RAMTOP n-re állítódik.

CLOSE#
Csak kazettás egység használatakor érvényes (lásd később).

CLS
Törli a képernyőtárat és ezzel együtt a képernyőt is.

CONT(inue)
Folytatja a programot attól a ponttól, ahonnan az egy 0-tól eltérő üzenettel megszakadt.

COPY
A képernyő felső 22 sorát a nyomtatóra másolja.

DATA a,b,c;;;
A programban szereplő adatlista, amelyet READ utasítással lehet beolvasni.

DEF FN f(a,b,...)=e
Egy függvényt definiál, amelyet a programban FN-nel hívhatunk.

DELETE f
A kazettás egység használatakor érvényes (lásd később).

DIM a(m,n,...,S)
Törli a tömböt, és tárhelyet foglal egy s dimenziójú numerikus a tömbnek.

DIM aS(m,n,...,S)
Ugyanaz, mint a DIM a(m,n,...,s) parancs, csak a tömb szöveg típusú. Kezdetben minden helyet üres karakterrel tölt fel.

DRAW x,y
Az a,b pozícióból az a+x és a b+y pozícióig egyenest rajzol. (a,b az aktuális rajzolási pozíció)

ERASE
Csak kazettás egység használatakor érvényes (lásd később).

FLASH n
Ha a=1, akkor a karakter villogni kezd, a=0 esetében megszűnik a villogás, ha n =8, akkor marad a korábbi állapot.

FOR a=x TO y
Az a változó értékét törli és kijelöli ciklusváltozónak. Ezután az a értéke felveszi INT x értékét, végbemegy a ciklus, amelynek végét a NEXT a jelzi, majd a értékét 1-gyel megnövelve újból á következő ciklus hajtódik végre. Ez addig ismétlődik, amíg y értéke kisebb, mint a.

FOR a=x TO y STEP z
Ugyanaz, mint a FOR a=x TO y parancs, de itt a ciklusváltozó minden lépésnél az a+z értéket veszi fel, z negatív szám is lehet (ha x>y).

FORMAT f
Csak kazettás egység használatakor érvényes (lásd később).

GO SUB n
Ezzel az utasítással a program az n. sorban kezdődő részprogramra (szubrutinra) ugrik. A részprogramot a RETURN utasítással kelt befejezni.

GOTO n
Az n. sorra való ugrást eredményezi. Ha nincs ilyen sorszám, akkor a következőre ugrik.

IF x THEN y
Ha x (ami kifejezés is lehet) igaz, vagyis nem 0, akkor végrehajtódik az y utasítás.

INK n
A karakterek színét állítja be, az n 0 és 7 közé eshet, vagy az n=8 a fényerőt, az n=9 a kontrasztot jelenti.

INPUT...
Megszakítja a programot és bevitelre vár. A bevitelt ENTER utasítással kell befejezni.

INVERSE n
n = 1 esetén az írás és a háttér színét megcseréli. n=0 esetében az alapállapotot állítja be. n értéke csak 0 vagy 1 lehet.

LET v=e
v változó felveszi e változónak, vagy kifejezésnek az értékét.

LIST
Kiírja a programot a képernyőre.

LIST n
1-tól n-ig kiírja a programsorokat a képernyőre.

LLIST
A programot a nyomtatóra írja.

LLIST n
1-től n-ig írja a programot a nyomtatóra.

LOAD f
Betölti a programot és a változókat.

LOAD f DATA ()
Betölt egy numerikus tömböt.

LOAD f DATA S$()
Betölt egy szövegfüzért.

LOAD f CODE m,n
n byte-ot tölt be a tár m-ből m + n-ig terjedő helyére.

LOAD f CODE m
Byte-okat tölt be a tároló m címétől kezdődően.

LOAD f CODE
A tárnak azokra a címeire tölt be byte-okat, amelyekről a felvételnél kivittünk.

LOAD f SCREEN$
Azonos a LOAD f CODE 16384, 6912 utasítással, 6912 byte-ot tölt be a képernyőtárba.

LPRINT e
Az e változó vagy kifejezés értékét kiírja a nyomtatóra.

MERGE f
Ugyanaz, mint a LOAD f utasítás, de a Spectrumban levő programsorok nem törlődnek.

MOVE a,b
Csak kazettás egység használatakor érvényes (lásd később).

NEW
Törli a BASIC-nyelvű programot és a változókat, Az UDG-ket és a CLEAR n által foglalt n-nél nagyobb címen levő tároló helyeket nem befolyásolja.

NEXT x
Egy FOR utasítással elkezdett ciklus lezárása.

OPEN #
Csak kazettás egység használatakor érvényes (lásd később).

OUT m,n
Az n byte-ot az m portra küldi.

OVER n
n=1 esetén egy karaktert ír a képernyőre anélkül, hogy az előzőt törölné, ha n=0, akkor visszaáll az alaphelyzet.

PAPER n
Mint az INK utasítás, csak ez a háttér színét szabályozza.

PAUSE n
Megállítja a program futását és n egységnyi szünetet tart. Az egység 1/50 s. Ha közben megnyomunk egy billentyűt, akkor a szünet megszakad. n=0 esetén addig tart a szünet, amíg egy billentyűt le nem nyomunk.

PLOT m,n
Az m,n koordinátájú helyre egy pontot ír 0<=m<=255,és 0<=n<175.

POKE m,n
n értékét az m című tárba írja be.

PRINT e
Az e változót vagy kifejezést a képernyő soron következő nyomtatási pozíciójára írja.

PRINT AT x,y;e
Az e értéket kiírja az x, sor y. oszlopába (0 <= x <= 21 és 0 <= y <= 31).

PRINT TAB x;e
Az e értékét kiírja a következő sor x. oszlopába.

RAND(omize) n
Ha n<>0, akkor a véletlenszám-generátor kezdő értéket n-re állítja be. n=0 esetében vagy ha n-t elhagyjuk, akkor a véletlenszámot képernyőn a bekapcsolás óta eddig megjelent képek számát tároló rendszerváltozó értéke alapján veszi fel.

READ a,b,c,...
Adatokat olvas a DATA utasításból és ezeket a,b, stb. változókhoz rendeli.

REM
A REMARK (megjegyzés) szó rövidítése. A REM utasítás utáni rész a programsorban nem kerül értelmezésre.

RESTORE n
A READ utasítás mutatóját az n. sorra állítja. Ha n-t elhagyjuk, akkor a RESTORE 0-t jelent.

RETURN
A szubrutinok utolsó utasítása. Az utasítás hatására a program a hívó GO SUB utasítás utáni sorral folytatódik.

RUN n
Törli az összes változót és az n. sortól indítja a programot. Ha n-t elhagyjuk, akkor a program az első sortól kezdődik.

SAVE f
A programot és a változókat tárolja.

SAVE f LINE n
Utasítás is tárolja a programot és a változókat, de az így felvett program betöltésekor az automatikusan az n. sorral kezdődik.

SAVE f DATA ()
Egy numerikus tömböt vesz fel.

SAVE f DATA S$()
Egy szöveges tömböt vesz fel.

SAVE f CODE m,n
n byte-ot tárol az m. címtől kezdődően.

SAVE f SCREEN$
Elmenti a képernyőtár tartalmát. Az utasítás azonos a SAVE f CODE 16384,6912-vel.

STOP
A program futását megszakítja és a 9. üzenet jelenik meg. Ha CONT parancsot adunk, akkor a program a STOP utáni utasítással folytatódik.

VERIFY
Azonos a LOAD utasítással, de az adatokat nem tölti be a tárba, csak összehasonlítja annak tartalmával.

Az utasítások mellett a Spectrumban az alábbi függvények használhatók:

ABS x
x abszolút értéke

ACS x
arkusz-koszinusz (radiánban). Az x értéke: -1 <= x <= 1.

AND
A logikai és.

ASN x
arkusz-szinusz (radiánban). Az x értéke: -1 <= x <= 1.

ATN x
arkusz-tangens (radiánban)

ATTR (x,y)
Egy bináris szám, amely a képernyő x. sorsában és y. oszlopában lévő képernyőpont jellemzőit adja meg. A 7. bit a legjellemzőbb. Értéke akkor 1, ha a FLASH 1, és 0 akkor, ha a FLASH 0. Ha a 6. bit értéke egyenlő 1-gyel, akkor a képernyő világos, ha 0, akkor normál. Az 5. és a 3. bit a háttér, a 2. és a 0. bit az előtér színét határozza meg.

BIN
Ha egy számot nem decimális, hanem bináris formában akarunk megadni, akkor azt a BIN után 0,1 számsorozattal tehetjük.

CHR$ x
Azt a karaktert eredményezi, amelynek az INT x a kódja.

CODE x$
Az x$ szöveg első karakterének kódját adja meg, Szóköz esetén üres karakter az eredmény.

COS x
Koszinusz x

EXP x
e^x exponenciális függvény.

FN e (x)
Ezzel lehet a DEF FN utasításban meghatározott függvényt hívni. Az x-et mindig zárójelbe kell tenni! Ha nincs x, akkor is ki kell tenni a zárójelet!

IN x
Az x portról beolvasott byte.

INKEY$
A billentyűzetet olvassa le. Az eredmény az a karakter, amelyet az utasítás végrehajtásának pillanatában lenyomva tartunk, egyébként üres string.

INT x
x egész része, x-INT x a tizedesvessző utáni részt jelenti.

LEN x$
x$ füzér hosszát adja meg.

LN x
Természetes alapú logaritmus függvény.

NOT x
Logikai függvény. Ha x <> 0, akkor a kifejezés értéke 0, ha viszont x=0, akkor a kifejezés értéke 1.

OR
Logikai vagy: x OR y azt jelenti, hogy vagy az x, vagy az y igaz.

PEEK x
Az INT(x) tárhelyen levő byte értékét adja meg.

PI
3,14159265, konstans.

POINT (x,y)
Ha az (x,y) pont színe a tintaszín, akkor az értéke 1, 0 akkor, ha az (x,y) pont színe a háttérszín 0 <=x <= 255 és 0 <= y <=175.

RND
0 és 1 közötti pszeudó-véletlenszámot állít elő. a és b közötti véletlenszámot az a+(b-a)*RND utasítással állíthatunk elő.

SCEEN$ (x,y)
Az x. sor y. oszlopában lévő karaktert eredményezi.

SGN x
Az x változó előjele. Ha x<0, akkor -1, ha x=0, akkor 0, ha x > 0, akkor +1 az értéke.

SIN x
szinusz x

SQR x
Az x változó négyzetgyöke.

STR$ x
Az x változót füzérré alakítja.

TAN x
tangens x, x radiánban van megadva.

USR x
Az x. címen kezdődő gépi kódú rutint hívja.

USR x$
Egy általunk definiált grafikus karakter címét adja meg.

VAL x$
x$ füzér numerikus értékét adja.

VAL$ x$
Az idézőjelek nélküli x$ stringkifejezésként való kiértékelése.

-x
Az x változó előjelét váltja.

A Spectrum a következő aritmetikai és összehasonlító műveleteket végzi el:

Ha Interface 1 is van, akkor a Spectrum parancskészlete kibővül. Ekkor 15 logikai csatorna van, amelyeket 1-től 15-ig sorszámozunk. Létezik még ezenkívül kétféle csatorna: k a billentyűzeté, s a képernyőé, p a nyomtatóé, t az RS 232-es csatlakozóhelyhez tartozó szövegillesztőé, b az RS 232-es csatlakozóhelyhez tartozó bináris illesztőé, n a hálózaté, m a kazettás egységé. Így további utasítások használhatóak:

CAT x
Megadja az x. kazettás egységbe helyezett kazetta tartalomjegyzékét. A lista ABC sorrendben jelenik meg. Megtudhatjuk még a kazetta nevét és a szabad tárhelyet kbyte-ban.

CAT#z;x
Az x. kazettás egységbe helyezett kazetta tartalomjegyzékét kiírja a z. logikai csatornára.

CLOSE#x
Az x. logikai csatorna összes átvitelét lezárja. Ha még van adat a puffertárban, akkor azokat kiírja.

ERASE "m";x;f
Törli az x. kazettás egységen levő f nevű file-t.

FORMAT "m";x;f
Az x. kazettás egység kazettáját formázza. A kazettát elnevezi (f-nek), és ez a név a tartalomjegyzékben megjelenik. Ha már volt valami a kazettán, akkor az felülíródik.

FORMAT "n";x
Kiépített helyi hálózat esetén az x sorszámot adja a Spectrumnak.

FORMAT "t";x
Az RS 232-es csatlakozón keresztüli adatátvitel sebességét határozza meg. x értékei a következők lehetnek: 50, 110, 300, 600, 1200, 2400, 4800, 9600 és 19200.

FORMAT "b";x
Azonos a FORMAT "t";x utasítással, az átviteli sebesség a t és b csatornán mindig azonos.

INKEY#x
Az x csatornából jövő karaktert adja vissza. Ha ez nincs, akkor üres karakter jelenik meg.

INPUT#x;y
Az y csatornán az x érték kerül bevitelre. Sorválasztás itt is lehetséges.

LOAD#...
A jelzett csatornán beviszi a programot, az adatokat vagy a byte-okat. A bevitelre csak a b, az n és az m csatornák használhatók. A normál LOAD utasításban megengedett választások itt is használhatók.

MERGE#...
Ugyanaz, mint a szokásos MERGE utasítás, csak itt egy adott csatornán dolgozunk.

MOVE a TO b
Az a forrásból a b-be viszi át az adatokat. Az utasítás előtt nem kell a csatornát megnyitni és lezárni.

OPEN#x,y
Az y csatornát az x logikai csatornához rendeli. Ezzel megnyílik a csatorna a BASIC nyelvű be- és kivitel számára. A megengedett csatornák: k, s, p.

PRINT#x...
Adatátvitelt hajt végre a megjelölt logikai csatornához. Ezt előzőleg az adatkivitel számára meg kell nyitni.

SAVE#...
A jelzett csatornán programot, adatokat vagy byte-okai vesz fel. Csak b, n és m csatornákat lehet használni. A normál SAVE utasításban megengedett választások itt is használhatók.

VERIFY#
Ugyanaz, mint a normál VERIFY utasítás, de az adatok megjelölt csatornáról jönnek.

2. Függelék: Hibajelzések

A Spectrum minden parancs és program végrehajtásakor a képernyő alsó részében üzenetet küld. Ez az üzenet egy kódból és egy rövid magyarázatból áll, amely megkönnyíti a hibakeresést. Ha az üzenet 0, OK, sorszám, utasítás, akkor ez azt jelenti, hogy a művelet szabályosan lezajlott, formális hiba nincsen. Sajnos, gyakran más üzenetek jelennek meg a képernyőn.

0 OK.
A program sikeresen lefutott.

1 NEXT without FOR
A ciklus elejéről hiányzik a FOR utasítás.

2 Variable not found
Olyan változót használunk, amelyet a LET, a READ vagy az INPUT utasítással nem határoztunk meg. Tömb esetében ez azt jelenti, hogy kihagytuk a DIM utasítást.

3 Subscript wrong
A tömbelemek száma meghaladja a LET vagy a DIM utasításban rögzített értéket.

4 Out of memory
A Spectrum tárja nem elég a feladatra.

5 Out of screen
Egy INPUT utasításban több mint 23 sort akarunk a képernyő alsó részére bevinni, vagy a PRINT utasítás hosszabb, mint 21 sor.

6 Number too big
Túlcsordulás, 10^38-nál nagyobb szám áll elő. Ez legtöbbször akkor fordul elő, ha olyan változóval osztunk, amelynek az értéke 0.

7 RETURN without GO SUB
A program olyan RETURN utasításra futott, amelyet nem előzött meg GO SUB utasítás.

8 End of file
A file végéhez érkeztünk. Csak azok számára érdekes, akiknek van kazettás egységük.

9 STOP statement
A programot STOP utasítás szakította meg. Ha CONTINUE parancsot adunk, akkor a STOP utáni utasítás végbemegy.

A Invalid argument
A függvény argumentumában szereplő mennyiség nem megengedett.

B Integer out of range
Túlcsordulás, egy egész szám túl nagy.

C Nonsense In BASIC
A VAL utasítással kiszámított kifejezés nem megengedett.

D BREAK-CONT repeats
A programot a BREAK billentyűvel megszakítottuk. Ha ezután CONT parancsot adunk, akkor a megszakított utasítás megismétlődik, ellentétben az L típusú hibával.

E Out of DATA
Több változót szeretnénk a READ utasítással beolvasni, mint amennyit a DATA-ban meghatároztunk. Ez általában akkor fordul elő, ha a RESTORE utasítást elfelejtettük.

F Invalid file name
Egy file-t név nélkül vagy tíz karakternél hosszabb névvel akartunk megőrizni.

G No room for line
A következő utasítás részére már nem elég a tárhely.

H STOP in INPUT
Egy INPUT utasítást STOP paranccsal megállítottunk. A CONTINUE parancs hatására megismétlődik az INPUT utasítás.

I FOR without NEXT
A ciklus végéről lefelejtettük a NEXT utasítást.

J Invalid I/O device
Hibás INPUT-OUTPUT utasítás a kazettás egységen.

K Invalid colour
Nem megengedett számot adtunk be a szín kijelölésénél.

L BREAK into program
BREAK billentyűvel két programsor között szakítottuk meg a futást.

M RAMTOP no good
A RAMTOP részére megadott szám vagy túl kicsi, vagy túl nagy.

N Statement lost
Nemlétező utasításra szeretnénk ugrani.

O Invalid stream
A kazettás egység, ill. az Interface 1 használatánál nem megengedett logikai csatornának szóló utasítást adtunk ki.

P FN without DEF
Olyan függvényt használtunk, amit előtte DEF FN utasítással nem határoztunk meg.

Q Parameter error
Egy a DEF FN-nel meghatározott függvényt hibás számú vagy hibás típusú paraméterrel hívtunk.

R Tape loading error
Betöltésnél vagy ellenőrzésnél olvasási hibát találtunk.

Ha Interface 1 is csatlakozik a Spectrum-hoz, akkor még további 21 hibaüzenet létezik.

Code error
A LOAD utasítással több kódot szerettünk volna betölteni, mint amennyi hely van.

Drive "write" protected
Egy védett kazettára akartunk írni, és ez nem sikerült.

File not found
A kazettán nincs olyan file, amelyet LOAD utasítással be szeretnénk tölteni, vagy ha nem lehet tökéletesen elolvasni. Ez akkor fordul elő, ha a kazetta megsérült, vagy a file-t nem szabályosan zártuk le.

Invalid device expression
Más betűkkel jelöltünk egy egységet, mint amivel lehetséges. A lehetséges betűk s,p,k,m,n,t vagy b. A hiba akkor is előfordulhat, ha az s,p vagy k csatorna kijelölésekor pontosvesszőt használtunk vessző helyett.

Invalid name
Egy file-nak vagy nincs neve, vagy az 10 karakternél hosszabb.

Invalid station number
Helyi hálózat esetén valamely egységhez 0-nál kisebb vagy 64-nél nagyobb számot rendeltünk, ill. a FORMAT utasításban 1-nél kisebb vagy 64-nél nagyobb számot használtunk.

Invalid stream number
Egy logikai csatornához 0-nál kisebb vagy 15-nél nagyobb számot rendeltünk.

Merge error
Adatokat vagy kódokat próbáltunk bevinni MERGE utasítással. A MERGE utasítás csak programoknál megengedett, és ott is csak akkor, ha azokat LINE utasítás nélkül vettük fel.

Microdrive full
Nincs már hely a kazettán a SAVE utasítás végrehajtására. Egy file-t törölni kell a kazettáról.

Microdrive not present
Vagy nem kapcsoltuk be a kazettás egységet, vagy nincs benne kazetta, ill. a benne levő kazetta nincs megformálva.

Missing band rate
Elfelejtettük az átviteli sebességet a FORMAT utasítással meghatározni.

Missing drive number
Olyan kazettás egységet akarunk elérni, amit elfelejtettünk megszámozni.

Missing name
Nem adtunk meg egy file nevet.

Missing station number
Egy csatlakozóhely számát nem adtuk meg.

Program finished
Olyan utasítást akartunk végrehajtani, amelyiknek a sorszáma nagyobb a programban előforduló legnagyobbnál. Ez az üzenet akkor is megjelenik, ha olyankor adunk RUN parancsot, amikor nincs program a tárban.

Reading a "write" file
Egy nemlétező, ill. írásra megnyitott file-ből szeretnénk adatot olvasni.

Stream already open
Olyan logikai csatornát szeretnénk megnyitni, amit már egy új csatornához hozzárendeltünk (m,n,t vagy b). Ebben az esetben az áramot le kell zárni.

Verification has failed
Az azonosításnál különbséget találtunk a felvett és a tárban lévő, annak megfelelő file között.

Writing to a "read" file
Olyan file-t szeretnénk kivinni, ami már létezik és a régit még nem töröltük le.

Wrong file type
A file típusa nem felel meg a kívánt műveletnek. Ez pl. akkor fordul elő, ha a kódot programként szeretnénk betölteni vagy a programot szeretnénk adatként átvinni.

A könyv programjai

Vissza