Zx spectrum için bir geliştirme ortamı hazırlamak (windows)

[Ref]

Biliyorum ki hepiniz Zx Spectrum'un muhteşem mimarisi ile donakalıp elinizde her ne varsa bırakıp hemen z80 kodlamaya girişmek istiyordunuz. Ama malesef ne zaman başlamak isteseniz sorular kafanıza toplanıyordu, bir türlü işin içinden çıkamıyordunuz. Buyrun hizmet ayağınıza geliyor.


Önce bulmamız gerekenler:
1.Bir cross-assembler (pasmo/sjasmplus)
2.Bir emülatör (specemu)
3.Bir text editörü (context/notepad++)
Opsiyonel: Bir Grafik editörü

Hemen download’a başlayın:
Pasmo:
http://pasmo.speccy.org/bin/pasmo-0.5.4.beta2.zip (son versionu kontrol edin)
Context Editör:
http://cdn.contextstatic.org/downloads/ConTEXTv0_986.exe (son versionu kontrol edin)
http://cdn.contextstatic.org/downloads/highlighters/z80.chl (context z80 işaretleyici)

Specemu:
http://homepage.ntlworld.com/e.tinney/SpecEmu-2.9.b040510.zip (başka bir emülatör de olur, ama bu tutorialde bunu anlatıcam, genel olarak en iyisi de budur)
SevenUp:
ftp://ftp.worldofspectrum.org/pub/sinclair/tools/pc/SevenuP-v1.20-win.zip (İleride lazım olur, grafik editörü)

Download'lar tamamlandıysa başlayalım:

1. Önce context'i kurun.
2. Pasmo'yu User access control'un bulaşmayacağı bir yere unzip edin. (mesela user klasörünüze ya da ikincil harddiskinize olabilir. Eğer bunu yapamayacaksanız context'i admin olarak çalıştırmanız gerekecek.)
3. Specemu'yu da biryere unzip edin. Specemu'yu hemen çalıştırın. "Options > Options" menüsüne girin, Hardware sekmesinie giderek Model'i "48k" ya getirin. Sonra "Tape" sekmesine giderek tüm "Tape Playback Options" seçeneklerini işaretleyin:  Auto play/stop, flash load, edge detect ve auto load. Specemu'yu kapatın.


4. Context'i çalıştırın.
5. "Options > Environment options" menüsünü seçin. Bir pencere açılacak.
6. Bu pencerede "Execute Keys" menüsüne girin.
7. "ADD" butonuna basın. Açılan Kutuya "asm" yazın. (başka birşey yazmayın)
8. Yukarıda .ASM başlıklı bir liste çıkacak, altında F9, F10.. alt menüler oalcak.
9. F9 başlığına tıklayın, yan tarafta seçenekler aktif hale gelecek, şöyle doldurun:
    Execute: Pasmo.exe
    Start in: Pasmo.exe'nin bulunduğu klasörü yazın, örnek: d:\dev\pasmoasm\ <-bu kutucuğa yazdığınızı ileride kullanacağız.
    Parameters: -v --tapbas %n out.tap
işaretleyin:
    Window: Normal
    Save: "Current before execution"
    "Use short DOS names"
    "Capture Console Output"
    "Scroll console to last line"
diğer seçenekler boş kalsın.
10. APPLY butonuna basın.


11.F10 başlığını tıklayın, bu sefer emülatörü ayarlayacağız:

   Execute: Specemu.exe
   Start in: Bulunduğu klasörü yazın, örnek: d:\dev\emu\
   Parameters: Pasmonun çıktı dosyası "out.tap" pasmo klasöründe duruyor, buraya o dosyayı yazacağız, örnek: d:\dev\pasmoasm\out.tap
   Window: Normal
   Save: Nothing
   Use Short DOS names

12.APPLY butonuna basın. Hatta OK ile bu pencereyi kapatın. Artık hazırız.


13. Aşağıdakileri context penceresine yapıştırın:

Kod: [Seç]

    org 08000h  ;compile adresi seç

     ld hl,text    ; Text verisinin yerini göster
     call doprint ; yazdırma rutinini çağır
     ret        ; Program bitti basic'e dön
   
    doprint    ;yazma rutini
     ld a,(hl) ; sıradaki harfi al
     cp 255 ;metin bitti mi?
     ret z ;bittiyse rutinden çık
     rst 16 ; bitmediyse karakteri yazdır (ROM çağrısı)
     inc hl ; sonraki karakteri seç
     jr doprint ; başa dön
   
    text
     defm "Merhaba dunya!"  ;yazdırılacak metin
     defb 255  ;metnin bittiğini gösteren işaret

    end 08000h

14. Şimdi bu dosyayı kaydetmelisiniz. "File>Save" seçerek dosya türünün *.asm olmasına dikkat edin. Örnek. "Test.asm"
15. Evet, artık context bizim dosyamızın bir z80 dosyası olduğunu biliyor. F9'a basın ve pasmo dosyanızı derleyecek.
16. Aşağıdkai konsol bölümünde "Execution Finished" yazıyor ve hiç hata oluşmadıysa artık deneyebiliriz.


17. F10'a basın, specemu çalışacak ve ekranda "merhaba dünya" yazısını göreceksiniz.
18. Kolay gelsin!


Specemu'yu "View > Zoom > 200% " şekline getirmenizi tavsiye ederim.

Size yardımı olabilecek sayfalar:
http://www.zophar.net/documents/z80.html
http://z80.info/#BASICS_INST
http://www.commodore.gen.tr/forum/index.php?topic=2936.0   Zamanında cgtr'de açılmış birkaç başlık...
http://www.commodore.gen.tr/forum/index.php?topic=2937.17 aynı zaman aralığında yazılmış hades'in örnekleri...

[Ref]

Ayrıca kısa bir bilgi de vereyim spectrum hakkında:

Zx Spectrum'un hafızası 0-65535 arasında adreslenebilir.
Bu adreslerin ilk 16383 slotu ROM tarafından kullanılıyor ve bu kısımı asla kullanamıyorsunuz. Burada bulunan kodları çağırabilir, buradaki dataları kullanabilirsiniz fakat bu bölüme yazma yapamıyorsunuz.

Rom'un hemen peşinde 16384 numaralı adresten itibaren ekran tamponu geliyor. Ekran için ayrılmış bu alan, kendi içinde iki bölüme ayrılıyor denebilir, önce 6144 byte boyunca bitmap resmi, sonra 768 byte uzunluğunda renk bilgisi var, renk bilgisinin ilk byte'ı 22528 numaralı adresten başlıyor. Bunun peşine sistem değişkenleri yerleştirilmiş, ardından da Basic programınız geliyor. 16384'den buraya kadar olan tüm alan "lower ram" olarak anılıyor. 32768 numaralı adresten itibaren biz spectrumcuların "Upper Ram" dedikleri alan başlıyor. Upper RAM "hızlı" alan olarak kabul ediliyor. Çünkü alt ram (lower ram) görüntü çipi ULA tarafından da erişildiği için ekranla ilgili bir işlem yaparsanız, %35 kadar daha yavaş çalışıyor.

Yani özetle:

[--ROM: 0-16383 --][--BITMAP: 16384-22527--][--ATTRIBUTES:22528-23295--][--BOŞ ALAN (Basic)--][--UPPER RAM:32768-65536--]

128k makinelerde son ram alanı, yani 49152-65535 aralığı, farklı ram setleri ile değiştirilebiliyor.

1. Programınızı 32768've üzerinde kalan bölgeye yazın. (org 32768 ya da org 8000h) 
2. 32767'nin altında çalışan kodda ya da o bölgeyi adresleyen tüm opkodlarda, "gecikmeli erişim" (contention) problemi yaşamanız olası (eğer ula ile çakışırsanız, öncelik ula'da).

Örnek: şu komut asla gecikme yaşamaz:
LD HL,40000
LD (HL),1

Şu komut, eğer komutun uygulandığı anda ula alt ram'den bilgi okumaya çalışıyorsa, 1-6 tstate arasında gecikme yaşayabilir.
LD HL,16384
LD (HL),1

Zx Spectrum'un gecikme tablosunu aşağıdaki link'ten görebilirsiniz:
http://scratchpad.wikia.com/wiki/Contended_memory

[Ref]

48K spectrum üzerinde başlamanızı tavsiye ettiğim için (daha basit bir tasarım) sanırım birkaç keyword'den bahsetmem gerekiyor.

Makine Kodunu başlatmak için genellikle girilen komut:
RANDOMIZE USR XXX dir. XXX'in yerine gerekli adresi girmek gerekiyor. Eğer pasmo otomatik olarak başlatmaya ayarlı değilse bunu manuel olarak girmek gerekeiblir:

"Randomize" = T
"USR" = (CTRL+SHIFT) (E moduna geçer) -> L

Pasmo otomatik olarak bu komutları eklese de, normalde manuel olarak bir kod yüklemeniz gerekirse (mesela gerçek makineye) o zaman unutulmaması gereken başka bir komut var.
Makine kodunuz için güveli bir hafıza bölgesi ayırmak gerekiyor. Bunu CLEAR ile yapıyoruz. Genellikle CLEAR komutunun yanına makine kodumuzun başladığı adresin bir altını veriyoruz:
CLEAR 32767

Yani güzel bir yükleyici ve çalıştırıcı basic kod yazmamız gerekirse:

CLEAR 32767: LOAD ""CODE 32768: RANDOMIZE USR 32768

Önce hafızada yer açıp, gerekli kodu teypten yükleyip, sonunda çalıştırıyor.


Eğer bir sebepten basic kodu yazmanız gerekirse 128k editörü kullanmanızı tavsiye ediyorum. Keyword'leri baştan öğrenmek biraz zordur.

Yine de 48K klavyesini buraya yapıştırayım:

Yeşil ile yazılmış kelimeler E modunda (CTRL+Shift) -> Tuş
Tuşların altında Kırmızı olanlar E-Shift Modunda (CTRL+Shift) -> (Shift+Tuş)
Tuşların içindeki kırmızı komutlar Shift ile (Shift + Tuş)
Beyaz olanları satırın ilk komutu olarak ya da ":" 'dan sonra tuşa basarak, (Tuş)
Harfleri ise sadece tırnakların içinde ya da komutlardan sonra değişken adı yazmak için kullanabilirsiniz.

Örneğin 10 PRINT "Arda" yazdırmak için:
1,0,p,(shift+p),(Ctrl+a),r,d,a,(shift+p),Enter
tuşlarına basmanız gerek.

(Specemu'da:
CTRL->Caps Shift
Shift -> Symbol Shift Tuşu yerine geçiyor. Evet Zx Spectrumda iki çeşit Shift tuşu var.)

[Ref]

Bütün programcıların ilk kabusu zx spectrum'un ekran haritasının garipliğinden kaynaklanır. Bir üst başlıkta hafıza'nın yapısını şöyle özetlemiştim:

[--ROM: 0-16383 --][--BITMAP: 16384-22527--][--ATTRIBUTES:22528-23295--][--BOŞ ALAN (Basic)--][--UPPER RAM:32768-65536--]

Bu başlıkta BITMAP + ATTRIBUTES bloklarını kapsayan "Ekran Tamponu"nu anlatmaya çalışacağım.

* Zx Spectrum'da sadece 1 ekran modu vardır.
* Zx Spectrum'da ekran çözünürlüğü 256x192 pikseldir.
* Zx Spectrum Paleti 8 renk barındırır. Fakat bu palet Amiga'daki EHB modu gibidir. 8 renk vardır, ve her rengin bir ton açığı da mevcuttur.
* Ekranın pikselleri oluşturan kısmı ile renklerin tutulduğu kısımı ayrıdır. Bu bölümlere Bitmap ve Attrib bölümleri diyelim. Bitmap 16384'de başlar, attrib 22528'de.
* Bitmap bölümü 6144 byte büyüklüğündedir, doğrusal değildir ve kendi içinde 2048byte'lık 3 eşit parçaya bölünmüştür.
* Attrib bölümü 768 byte uzunluğundadır ve doğrusal bir dizilimi vardır.
* Her 8 pixel 1 byte ile ifade edilir. Ekranın genişliği 256 pixel olduğuna göre, her satır 32 byte alan kaplar.

Zx Spectrumda, örneğin sol üst (x,y) 0,0 pixel koordinatını boyamak istersek 16384 numaralı adresi kullanmamız gerek. Eğer 1 karakter sağa gitmek istersek, o zaman 1 byte ilerleriz= 16385. 32 byte ilerlersek (32 karakter eder) satır sonuna varmış oluruz. 
Eğer 0,0 pozisyonundan bir satır aşağı, 0,1 pixeline gitmek istersek, mantık olarak 32 byte ilerlememiz gerekir. Fakat Hayır. Zx Spectrumda 32 pixel ilerlediğinizde 8 pixel aşağı ulaşmış olursunuz(bir alttaki karakter). Bir pixel inmek için, adrese 256 byte eklemek gerekiyor.

Aslında makine dilini düşünürsek bunun açıklaması çok mantıklı. Zx Spectrum'un ekran hafızasını 16 bitlik bir rakamla adresliyoruz. Bunun için genelde 16bitlik bir register kullanılır. Örneğin, HL. HL aslında iki adet 8 bitlik register'ın eşlenmiş hali. HL=16384 olduğunda, H=64, L=0 değerindedir. Eğer "INC L" operatörüyle, L'yi 1 arttırırsak, yukarıdaki örnekteki gibi, bir sonraki karaktere ulaşırız. L'yi arttırmaya devam edersek ve satır sonuna gelirsek, L'yi tekrar arttırdığımızda otomatik olarak satır başına gelmiş oluruz. Yani L registeri karakter pozisyonunu ayarlıyor. H ise büyük çarpan olduğu için H'yi bir arttırdığımızda adrese 256 değerini ekliyor oluyoruz. Dolayısıyla "INC H" komutu, L'nin gösterdiği Karakterin içinde dikey olarak gezmemizi sağlıyor. Diyelim ki ekrana bir harf basacaksınız, o zaman L'li ayarlayarak karakterimizi seçiyoruz. Sonra H'yi 7 kere arttırarak karakterin oluştuğu 8 pixel satırını da boyuyoruz.

Eğer ekran hafızası lineer olarak dizilmiş olsaydı, bir pixel aşağı gitmek için adrese 32 eklememiz gerekecekti. 32 ekleyebilmek için büyük olasılıkla başka bir 16bit registerde 32 değerini tutmamız gerekecekti. Yani basit bir INC H yapmak yerine, PUSH DE; LD DE,32; ADD HL,DE ; POP DE; Burada yaklaşık 40tstate var. Halbuki aynı iş bu ekran diziliminde sadece 4 tstate tutuyor.

Evet, dikkat ederseniz, sadece L'yi arttırarak, ekranda bulunan tüm karakterleri sırayla gezebiliyoruz. Attrib alanı da bu düzeneğe uyuyor. Her bir karakterlik alan için 1 byte'lık renk alanı ayrılmış durumda. Yani pixelleyeceğiniz karakter'in ilk pixelinin adresini bulduğunuzda, aynı zamanda (sadece H'yi arttırarak) onun renk bilgisinin yerini de bulmuş oluyorsunuz.

Görüldüğü gibi zx spectrum'un ekran dizilimi tamamen karakter (metin) işlemlerini hızlıca yapmak üzere tasarlanmıştır. Clive Sinclair'in acorn BBC'ye kaptırdığı "eğitim bilgisayarı" olma hedefi yüzünden böyle bir düzeneğe sahip olduğu söyleniyor.

Malesef bu düzenek piksel tabanlı hesaplamalar yapanlar için pek de kolay değil. X'de sorun yok ama Y hareketinde 2048'byte'lık bloklar problem oluyor. (Eğer Sprite'ınız iki blok'un kesiştiği alanda ise sorun var). Piksel koordinatlarının adres karşılığını çabukça hesaplamanın en hızlı yöntemi bir tablo kullanmak.


Eğer değerli tstate'leri harcayıp adresi kendim hesaplattırayım diyorsanız Arjun'un yazdığı kodu veriyorum. Kodu bir fonksiyon olarak kullanmak için baştaki "hesapla" ve en sonraki "ret"i ben ekledim:

Kod: [Seç]

hesapla
;Girdiler: B reg = X koord,  C reg = Y koordinat
;Çıktılar: HL = ekran adresi, A = pixel pozisyonu

; Adresin üst byte'ını hesapla ve H yazmaçına yükle
ld a,c
and %00000111
ld h,a
ld a,c
rra
rra
rra
and %00011000
or h
or %01000000
ld h,a

; Adresin alt byte'ını hesapla ve L yazmaçına yükle

ld a,b
rra
rra
rra
and %00011111
ld l,a
ld a,c
rla
rla
and %11100000
or l
ld l,a

; Pixel pozisyonunu bul ve Akümülatöre yükle

ld a,b
and %00000111

ret


Örneğin yukarıdaki kodu, 65,83 koordinatını pixellemek için kullanalım:

Kod: [Seç]

       org 32768  ; programın başlangıç adresi

       ld b,65   ; X kkordinatını B'ye yüklüyoruz
       ld c,83  ; Y koordinatını C'ye
       call hesapla  ; Arjun'un hesaplama kodunu çağırıyoruz, bize HL ve A değerlerini veriyor

       LD (HL),A ; Direkt olarak pixel'i boyayalım (pixelin altındaki bilgi silinir).

       ret ; Basic'e dönelim

Yukarıdaki kodu Context ile F9, F10 yaptıktan sonra, specemu'da RANDOMIZE USR 32768 komutuyla çalıştırmanız lazım.


Yine bilgileri tamamlamak amacıyla tabloya bakalım.
Eğer tablo kullanmak isterseniz şu tabloya ihtiyacınız olacak, tabloyu hazırlayan ASM'dir. Bu tablodan daha basit(ve akıllı) tablolar da kullanmak mümkün, bu mesaj acemi kullanıcılara göre hazırlanmış olduğu için ufak adımlarla başlıyoruz.

Kod: [Seç]

; --------------------------------------------------------------------------


; Satır konum tablosu.


lpt defw 16384+(32*0)+(256*0)
defw 16384+(32*0)+(256*1)
defw 16384+(32*0)+(256*2)
defw 16384+(32*0)+(256*3)
defw 16384+(32*0)+(256*4)
defw 16384+(32*0)+(256*5)
defw 16384+(32*0)+(256*6)
defw 16384+(32*0)+(256*7)
defw 16384+(32*1)+(256*0)
defw 16384+(32*1)+(256*1)
defw 16384+(32*1)+(256*2)
defw 16384+(32*1)+(256*3)
defw 16384+(32*1)+(256*4)
defw 16384+(32*1)+(256*5)
defw 16384+(32*1)+(256*6)
defw 16384+(32*1)+(256*7)
defw 16384+(32*2)+(256*0)
defw 16384+(32*2)+(256*1)
defw 16384+(32*2)+(256*2)
defw 16384+(32*2)+(256*3)
defw 16384+(32*2)+(256*4)
defw 16384+(32*2)+(256*5)
defw 16384+(32*2)+(256*6)
defw 16384+(32*2)+(256*7)
defw 16384+(32*3)+(256*0)
defw 16384+(32*3)+(256*1)
defw 16384+(32*3)+(256*2)
defw 16384+(32*3)+(256*3)
defw 16384+(32*3)+(256*4)
defw 16384+(32*3)+(256*5)
defw 16384+(32*3)+(256*6)
defw 16384+(32*3)+(256*7)
defw 16384+(32*4)+(256*0)
defw 16384+(32*4)+(256*1)
defw 16384+(32*4)+(256*2)
defw 16384+(32*4)+(256*3)
defw 16384+(32*4)+(256*4)
defw 16384+(32*4)+(256*5)
defw 16384+(32*4)+(256*6)
defw 16384+(32*4)+(256*7)
defw 16384+(32*5)+(256*0)
defw 16384+(32*5)+(256*1)
defw 16384+(32*5)+(256*2)
defw 16384+(32*5)+(256*3)
defw 16384+(32*5)+(256*4)
defw 16384+(32*5)+(256*5)
defw 16384+(32*5)+(256*6)
defw 16384+(32*5)+(256*7)
defw 16384+(32*6)+(256*0)
defw 16384+(32*6)+(256*1)
defw 16384+(32*6)+(256*2)
defw 16384+(32*6)+(256*3)
defw 16384+(32*6)+(256*4)
defw 16384+(32*6)+(256*5)
defw 16384+(32*6)+(256*6)
defw 16384+(32*6)+(256*7)
defw 16384+(32*7)+(256*0)
defw 16384+(32*7)+(256*1)
defw 16384+(32*7)+(256*2)
defw 16384+(32*7)+(256*3)
defw 16384+(32*7)+(256*4)
defw 16384+(32*7)+(256*5)
defw 16384+(32*7)+(256*6)
defw 16384+(32*7)+(256*7)
defw 18432+(32*0)+(256*0)
defw 18432+(32*0)+(256*1)
defw 18432+(32*0)+(256*2)
defw 18432+(32*0)+(256*3)
defw 18432+(32*0)+(256*4)
defw 18432+(32*0)+(256*5)
defw 18432+(32*0)+(256*6)
defw 18432+(32*0)+(256*7)
defw 18432+(32*1)+(256*0)
defw 18432+(32*1)+(256*1)
defw 18432+(32*1)+(256*2)
defw 18432+(32*1)+(256*3)
defw 18432+(32*1)+(256*4)
defw 18432+(32*1)+(256*5)
defw 18432+(32*1)+(256*6)
defw 18432+(32*1)+(256*7)
defw 18432+(32*2)+(256*0)
defw 18432+(32*2)+(256*1)
defw 18432+(32*2)+(256*2)
defw 18432+(32*2)+(256*3)
defw 18432+(32*2)+(256*4)
defw 18432+(32*2)+(256*5)
defw 18432+(32*2)+(256*6)
defw 18432+(32*2)+(256*7)
defw 18432+(32*3)+(256*0)
defw 18432+(32*3)+(256*1)
defw 18432+(32*3)+(256*2)
defw 18432+(32*3)+(256*3)
defw 18432+(32*3)+(256*4)
defw 18432+(32*3)+(256*5)
defw 18432+(32*3)+(256*6)
defw 18432+(32*3)+(256*7)
defw 18432+(32*4)+(256*0)
defw 18432+(32*4)+(256*1)
defw 18432+(32*4)+(256*2)
defw 18432+(32*4)+(256*3)
defw 18432+(32*4)+(256*4)
defw 18432+(32*4)+(256*5)
defw 18432+(32*4)+(256*6)
defw 18432+(32*4)+(256*7)
defw 18432+(32*5)+(256*0)
defw 18432+(32*5)+(256*1)
defw 18432+(32*5)+(256*2)
defw 18432+(32*5)+(256*3)
defw 18432+(32*5)+(256*4)
defw 18432+(32*5)+(256*5)
defw 18432+(32*5)+(256*6)
defw 18432+(32*5)+(256*7)
defw 18432+(32*6)+(256*0)
defw 18432+(32*6)+(256*1)
defw 18432+(32*6)+(256*2)
defw 18432+(32*6)+(256*3)
defw 18432+(32*6)+(256*4)
defw 18432+(32*6)+(256*5)
defw 18432+(32*6)+(256*6)
defw 18432+(32*6)+(256*7)
defw 18432+(32*7)+(256*0)
defw 18432+(32*7)+(256*1)
defw 18432+(32*7)+(256*2)
defw 18432+(32*7)+(256*3)
defw 18432+(32*7)+(256*4)
defw 18432+(32*7)+(256*5)
defw 18432+(32*7)+(256*6)
defw 18432+(32*7)+(256*7)
defw 20480+(32*0)+(256*0)
defw 20480+(32*0)+(256*1)
defw 20480+(32*0)+(256*2)
defw 20480+(32*0)+(256*3)
defw 20480+(32*0)+(256*4)
defw 20480+(32*0)+(256*5)
defw 20480+(32*0)+(256*6)
defw 20480+(32*0)+(256*7)
defw 20480+(32*1)+(256*0)
defw 20480+(32*1)+(256*1)
defw 20480+(32*1)+(256*2)
defw 20480+(32*1)+(256*3)
defw 20480+(32*1)+(256*4)
defw 20480+(32*1)+(256*5)
defw 20480+(32*1)+(256*6)
defw 20480+(32*1)+(256*7)
defw 20480+(32*2)+(256*0)
defw 20480+(32*2)+(256*1)
defw 20480+(32*2)+(256*2)
defw 20480+(32*2)+(256*3)
defw 20480+(32*2)+(256*4)
defw 20480+(32*2)+(256*5)
defw 20480+(32*2)+(256*6)
defw 20480+(32*2)+(256*7)
defw 20480+(32*3)+(256*0)
defw 20480+(32*3)+(256*1)
defw 20480+(32*3)+(256*2)
defw 20480+(32*3)+(256*3)
defw 20480+(32*3)+(256*4)
defw 20480+(32*3)+(256*5)
defw 20480+(32*3)+(256*6)
defw 20480+(32*3)+(256*7)
defw 20480+(32*4)+(256*0)
defw 20480+(32*4)+(256*1)
defw 20480+(32*4)+(256*2)
defw 20480+(32*4)+(256*3)
defw 20480+(32*4)+(256*4)
defw 20480+(32*4)+(256*5)
defw 20480+(32*4)+(256*6)
defw 20480+(32*4)+(256*7)
defw 20480+(32*5)+(256*0)
defw 20480+(32*5)+(256*1)
defw 20480+(32*5)+(256*2)
defw 20480+(32*5)+(256*3)
defw 20480+(32*5)+(256*4)
defw 20480+(32*5)+(256*5)
defw 20480+(32*5)+(256*6)
defw 20480+(32*5)+(256*7)
defw 20480+(32*6)+(256*0)
defw 20480+(32*6)+(256*1)
defw 20480+(32*6)+(256*2)
defw 20480+(32*6)+(256*3)
defw 20480+(32*6)+(256*4)
defw 20480+(32*6)+(256*5)
defw 20480+(32*6)+(256*6)
defw 20480+(32*6)+(256*7)
defw 20480+(32*7)+(256*0)
defw 20480+(32*7)+(256*1)
defw 20480+(32*7)+(256*2)
defw 20480+(32*7)+(256*3)
defw 20480+(32*7)+(256*4)
defw 20480+(32*7)+(256*5)
defw 20480+(32*7)+(256*6)
defw 20480+(32*7)+(256*7)


; --------------------------------------------------------------------------



Çöplük
Bunları belki sonra düzenlerim diye burada bırakıyorum, yukarıdaki metnin içindeydiler, çıkarmak için aşağı aldım, ama belki lazım olabilir.

Zx Spectrum'un "garip" 3 bölümlü buffer diziliminin basit bir sebebi var. Detaya inmek gerekirse, Ekran adreslemesini 16bit ile yapıyoruz. Bunun sonucu olarak ister istemez üç parçalı yapıyla karşılaşyoruz: Örneğin, 16-BIT ekran adresini şöyle bölümleyelim:

010BBİİİ SSSÜÜÜÜÜ

Burada harflere denk düşen bitler ekranın şu bölümlerine ulaşmayı sağlıyor:

BB = 0-2 Ekran Bloğu (2048byte'lık Bloklar)
SSS = 0-7 Her blok içindeki dikey karakter satırları (karakter Satırı)
ÜÜÜÜÜ = 0-31 Yatay eksende her bir karakter (karakter sÜtunu)
İİİ = 0-7 Her bir karakter içindeki dikey Satırlar (iç satırar)



* Attrib bölümündeki renklerin temsili şöyledir:
--Attrib bölümündeki her 1 byte'lık bilgi, Bitmap alanındaki 8x8 piksellik bir alanı boyamak için kullanılır.
--Attrib bölümündeki 1 byte'lık bilginin içeriği şöyledir: 3bit Ön plan rengi, 3bit arka plan rengi , 1 bit Parlaklık, 1 bit yanıp sönme bilgisi.