Niezalogowany (Zaloguj się)

Jeśli chcesz wziąć udział w dyskusjach na forum - zaloguj się. Jeżeli nie masz loginu - poproś o członkostwo.

Vanilla 1.1.4 jest produktem Lussumo. Więcej informacji: Dokumentacja, Forum.

Scramble in Action!

Od 1 do 50 z 189

- 1: CommentAuthorzbyti
- CommentTime7 May 2020 11:05 zmieniony
W ramach poznawania Atari 8-bit od strony programistycznej postanowiłem na fali warsztatów TDC napisać coś własnego na kanwie znanego klasyka.

Projekt ma dla mnie charakter szkoleniowy i mam nadzieję, że będzie pomocny innym stawiającym swoje pierwsze kroki w programowaniu na małe Atari.

Językiem programowania wybranym na potrzeby pisania Scramble jest Action! ze względu na swoją elastyczność i łatwość w czytaniu kodu, zwłaszcza po użyciu pluginu Michała Kołodziejskiego ->link<-

Projekt jest publiczny, można go dowolnie modyfikować jeżeli tylko kogokolwiek najdzie ochota na eksperymenty czy też wpadnie na pomysł poprawki/usprawnienia (te chętnie przyjmę jako PR).

GitHub: ->link<-

---------------------------------------------------------------------------

Pierwsza koncepcja w Atari FontMaker:

Pierwsza implementacja:
- 2: CommentAuthorzbyti
- CommentTime7 May 2020 11:05 zmieniony
Nowe fonty od @Kaza z moimi małymi poprawkami związanym ze zmianą radaru na działo laserowe ;) płomieniami dysz i ogonem meteoru.

Dziś powalczę ze scrollem.

Dalej chciałbym zanimować chociaż jedną rakietę do końca tygodnia...
- Screenshot_2020-05-07_11-20-18.png
- 3:
  
  CommentAuthorKaz
- CommentTime7 May 2020 13:05
I pacyfizm się skończył - był sobie radar, a teraz wypuszcza promienie śmierci... :D

Wygląda to coraz lepiej, kibicuję.
- 4:
  
  CommentAuthorDracon
- CommentTime7 May 2020 13:05 zmieniony
O qrde, naprawdę wygląda to całkiem obiecująco! Trochę kojarzy się z hiresem ZX-a (czy Zbyti ma tamtejsze korzenie? ;)) a gdyby jeszcze tu i ówdzie podkolorować sprytnie duszkami, to byłaby "miód-malina" ! :)
- 5: CommentAuthormuffy
- CommentTime7 May 2020 13:05
Ładne to :)
- 6: CommentAuthorzbyti
- CommentTime8 May 2020 18:05 zmieniony
Wdrożenie "wiedzy" w życie ;)

Zamiast jak do tej pory po podbiciu wartości HSCROL czekać ramkę wrzuciłem rysowanie i rzeczy z tym związane do procedury uruchamianej przez VBLANK.

Zmiany na GitHub.
- Screenshot_2020-05-08_18-34-37.png
- 7: CommentAuthorMADRAFi
- CommentTime8 May 2020 18:05 zmieniony
Ok ujawnie sie ze pracuje rownolegle z zbyti nad gra w MAD-Pascal.
W zamierzeniu to ma byc ta sama gra napisana natywnie w Pascalu. To bedzie wyjscie do materialu porownawczego programowania tego samego "zadania" w wielu jezykach programowania.

Prace mozna sledzic na githubie ->link<-

Poniewaz gra pisana jest w roznych jezyka mozliwe ze pojawia sie rozbieznosci:)
- 8: CommentAuthorzbyti
- CommentTime8 May 2020 19:05
@MADRAFi fajnie, to motywujące! :]
- 9:
  
  CommentAuthorKaz
- CommentTime8 May 2020 19:05
Madrafi - brawo! A to "wyjście do materiału porównawczego programowania tego samego zadania w wielu językach" to jakiś szerszy plan, więcej osób i więcej języków czy tylko Ty i Mad Pascal?
- 10:
  
  CommentAuthorbocianu
- CommentTime8 May 2020 20:05
Jak już kodu będzie więcej i się zmotywuje, to zrobię trzecią wersję w cc65 ;)
- 11: CommentAuthorzbyti
- CommentTime8 May 2020 20:05
DLI wrzucone zgodnie z pomysłem @Kaza
- atari000101.png
- 12:
  
  CommentAuthorKaz
- CommentTime8 May 2020 20:05
Nie do końca tak, ale coraz bliżej :D
- 13: CommentAuthorzbyti
- CommentTime8 May 2020 20:05
Jeszcze pamiętam o dolnym cieniowaniu, zaraz zrobię, ale górne jest od $8C do $80, więc nie wiem co zrobiłem inaczej niż mi w @ napisałeś ;P
- 14: CommentAuthorgorgh
- CommentTime8 May 2020 20:05
pięknie zbyti, czekam na filmik
- 15: CommentAuthorilmenit
- CommentTime8 May 2020 20:05
a ja na xex'a ;)
- 16: CommentAuthorgorgh
- CommentTime8 May 2020 20:05
no tak, ale zanim powstanie gra to fajnie by ją było rozreklamować, ja odnośnie mojej stronki mechanism.fr
- 17: CommentAuthorzbyti
- CommentTime8 May 2020 21:05 zmieniony
@gorgh filmiki w załączniku ;) W przyszłym tygodniu zacznę animować rakiety ;) Na ten moment ogarniałem VBLANK i DLI.

Niestety 30 klatek w filmie to trochę chrupie ten scroll, na emu jest płynnie i ponoć na Real Atari też dobrze.

@ilmenit robienie XEX jest chwilowo problematyczne, taka uroda Action!

Action 3.7P na karcie, pliki z repo wrzucić do H1 i można odpalić u siebie.
- a8-scramble.mkv
- 18: CommentAuthorzbyti
- CommentTime8 May 2020 21:05
Kaz uprzejmie wrzucił filmik do playlisty Action!

Następnym razem przestawię emu w NTSC i nagram w 60fps by tak scrolla nie szarpało.
- 19: CommentAuthorantrykot
- CommentTime8 May 2020 22:05
To ja napiszę wersję w haskellu.
- 20: CommentAuthorzbyti
- CommentTime8 May 2020 22:05
@antrykot za Haskella na Atari robi FORTH ;)

21: CommentAuthorzbyti
CommentTime9 May 2020 00:05 zmieniony

Skróciłem poniższe DLI:

DLI00=[PHA LDAI $8C STA $0A $D4 STA $18 $D0 LDAI $3C STA 0 2 LDAI $20 STA 1 2 PLA RTI],
DLI01=[PHA LDAI $8A STA $0A $D4 STA $18 $D0 LDAI $53 STA 0 2 LDAI $20 STA 1 2 PLA RTI],
DLI02=[PHA LDAI $88 STA $0A $D4 STA $18 $D0 LDAI $6A STA 0 2 LDAI $20 STA 1 2 PLA RTI],
DLI03=[PHA LDAI $86 STA $0A $D4 STA $18 $D0 LDAI $81 STA 0 2 LDAI $20 STA 1 2 PLA RTI],
DLI04=[PHA LDAI $84 STA $0A $D4 STA $18 $D0 LDAI $98 STA 0 2 LDAI $20 STA 1 2 PLA RTI],
DLI05=[PHA LDAI $82 STA $0A $D4 STA $18 $D0 LDAI $AF STA 0 2 LDAI $20 STA 1 2 PLA RTI],
DLI06=[PHA LDAI $80 STA $0A $D4 STA $18 $D0 LDAI $C6 STA 0 2 LDAI $20 STA 1 2 PLA RTI],
DLI07=[PHA LDAI 0 STA $0A $D4 STA $18 $D0 PLA RTI]

zmieniając na:

DLI=[
    PHA
    LDAI $8C STA $0A $D4 STA $18 $D0
    DEC $27 $20 DEC $27 $20
    CMPI $80 BNE $A LDAI 0 STA $18 $D0 LDAI $8C STA $27 $20
    PLA
    RTI
]

- 22: CommentAuthorzbyti
- CommentTime9 May 2020 11:05 zmieniony
TUTORIAL 1.0: Action! to XEX

Podaję chałupniczą metodę wykonania XEX za pomocą Action 3.7P bo plikowy RUNTIME jaki używałem do tej pory nie chwyta poprawnie mojego kodu.

---------------------------------------------------------------------------

Mój kod zaczyna się od $2000
Fonty od $1000

1. Monitor Action!: C "H6:MAIN.ACT"

2. [F8] wejście do monitora emulatora atari800

3. Doczytanie zasobów:

read /home/zbyti/Atari8HDD/SCRAMBLE.FNT 1000 400

4. Zgranie do XEX obszaru pamięci wraz cartem:

write XEX 1000 bfff 2a04

$2A04 to akurat początek startu mojego programu.

---------------------------------------------------------------------------

Całość można spakować jak ktoś chce za pomocą Exomizera.

Niestety w roli RUNTIME występuje tutaj zrzut banków pamięci zajętych przez cart Action 3.7P.

Trochę mnie to dziwi (że potrzebuję ten RUNTIME) bo podczas kompilacji w kodzie były wykomentowane wszystkie procedury biblioteczne jakie używam.

EDIT: w załączniku DUMP.XEX spakowany Exomizerem.
```
exomizer sfx sys -n -t 168 -o SCREXO.XEX SCRAMBLE.XEX
```
- SCRAMBLE5.XEX
- SCREXO.XEX
- 23: CommentAuthorgorgh
- CommentTime9 May 2020 14:05
piękne dzięki za filmik, już udostępniony, gra cudo
- 24: CommentAuthorzbyti
- CommentTime9 May 2020 14:05
@gorgh You are too kind Mister! :D
- 25: CommentAuthorzbyti
- CommentTime11 May 2020 17:05 zmieniony
W ramach dumania nad wykonaniem softwarowych spritów dokonałem drobnych zmian w kodzie pozwalających ustawać za pomocą stałych gdzie ma znajdować się kod a gdzie zaczynać ekran tak by nie było potrzeby dokonywania innych zmian w kodzie.
```
;---------------------------------------------------------------
; CODEBASE START
;---------------------------------------------------------------

SET $E=$1000
SET $491=$1000

;---------------------------------------------------------------
; DEFINED CONSTANTS
;---------------------------------------------------------------

; MSB OF SET CODEBASE
DEFINE CBMSB="$10"
```
Mój kod działa zarówno z wersją cartridge-ową Action! 3.6 jak i 3.7P. By zapanować nad pamięcią Atari nie należy używać edytora Action! tylko sam monitor.

Wykonać należy tak jak na screenshot-cie C a potem uruchomić za pomocą R.
- atari000105.png
- 26:
  
  CommentAuthorjhusak
- CommentTime12 May 2020 01:05
Nie trzeba całej a000-bfff dołączać, wystarczy jakieś 3kb spod a000.
- 27: CommentAuthorzbyti
- CommentTime12 May 2020 02:05
@jhusak dzięki za TIP, sprawdzę.
- 28:
  
  CommentAuthorjhusak
- CommentTime12 May 2020 08:05 zmieniony
Można tez tak pisać, ze w ogóle niepotrzebny runtime jest :) nie używać funkcji systemowych ani mnożenia, oraz nie przekazywać do procedur więcej, niż 3 bajty w sumie.
- 29: CommentAuthorxxl
- CommentTime12 May 2020 08:05
w Action mozna tez chyba podmieniac funkcje systemowe definiujac pod tymi samymi nazwami wlasne.
- 30: CommentAuthorzbyti
- CommentTime12 May 2020 11:05 zmieniony
@jhusak napisałem, że tak zrobiłem. By nie potrzebować runtime wyrzuciłem wszytki wywołania procedur/funkcji systemowych a mimo wszystko OBJ nie chciał działać.

Co do ilości parametrów to trzymam się tej zasady. Funkcja LOAD jaka znajduje się w kodzie, jest pomocnicza i wyleci/wylatuje podczas robienia XEX.

3x razy sprawdzałem czy coś przeoczyłem, sprawdzę jeszcze raz.

@xxl można tak zrobić.
- 31: CommentAuthorzbyti
- CommentTime12 May 2020 13:05 zmieniony
No to mam zagadkę. Wykonałem XEX, nie ma w nim wywołań procedur lub funkcji bibliotecznych - przynajmniej w swoim kodzie ich nie widzę. Te nieliczne podczas procesu kompilacja zakomentowałem.

Zamieszczony XEX działa gdy jest wpięty cart z Action! ale bez wiesza emulator.

Dokonałem disassemblacji, zobaczę czy jest jakiś skok do obszaru $8000-$BFFF bo używam Action 3.7P.

EDIT1: no i jest wywołanie :> tylko po co?
```
;-----------------------------------------------------------------
; LAUNCH PROCEDURE
;-----------------------------------------------------------------

PROC MAIN()
  SDMCTL=0 INIT() SDMCTL=$22
  SETVBLK(7,(VBLANKD RSH 8),VBLANKD)

  WHILE CH#$1C DO OD ; press ESC

  SETVBLK(7,(OLDVBL RSH 8),OLDVBL)
  ; GRAPHICS(0)
RETURN
```
EDIT2: ale ze mnie cymbał... RSH to część biblioteki a nie języka! :D muszę ją sobie wrzucić do TOOLS i po sprawie ;)
- scramble.xex
- Screenshot_2020-05-12_13-34-25.png

32: CommentAuthorzbyti
CommentTime12 May 2020 14:05

Tak dla ciekawskich wrzucam implementację:

; oryginalny runtime plikowy
SET $4E6=RShift
PROC RShift=*()
[$84A4$AF0$8586$8546$6A$88$FAD0$85A6$60]

; Runtime von Jeff Reister (używana przeze mnie, działający)
PROC _RSHOP=*()
SET $4E6 = _RSHOP
[$A4$84$F0$0A$86$86$46$86$6A$88$D0$FA
$A6$86$60]

; Action! 3.7P
9E1A: A4 84     LDY $84     ;VNTD
9E1C: F0 0A     BEQ $9E28
9E1E: 86 85     STX $85     ;VNTD+1
9E20: 46 85     LSR $85     ;VNTD+1
9E22: 6A        ROR
9E23: 88        DEY
9E24: D0 FA     BNE $9E20
9E26: A6 85     LDX $85     ;VNTD+1
9E28: 60        RTS

Wygląda, że oryginalnie wypuszczony RUNTIME plikowy do zabawy bez cartridge ma w RSH babola już na samym początku :]

- 33: CommentAuthorxxl
- CommentTime12 May 2020 14:05
tyle zachodu zeby pobrac do rejestru starszy bajt ?
- 34: CommentAuthorzbyti
- CommentTime12 May 2020 15:05 zmieniony
@xxl metodę podpatrzyłem u @jhusak ale chyba faktycznie można to zrobić lepiej. Zaraz to zmienię na coś nie wymagającego RSH.
- 35: CommentAuthorzbyti
- CommentTime12 May 2020 15:05 zmieniony
TUTORIAL 2.0: Action! to XEX

UWAGA: dołączony przez nas plikowy RUNTIME.ACT musi być ZA dyrektywami ustawiającymi CODEBASE, inaczej wyląduje poza zgrywanym przez nas adresem.

---------------------------------------------------------------------------

Monitor Action!

1. C "H6:MAIN.ACT"

2. W "H1:MAIN.XEX"

wxHexEditor

Wczytujemy MAIN.XEX:

2 i 3 bajt to początek naszego programu
4 i 5 bajt to koniec naszego programu

ostatnie dwa bajty to adres procedury startującej nasz kod.

Atari800

1. Wejście do monitora F8

2. Wczytanie do pamięci komputera MAIN.XEX

read /home/zbyti/Atari8HDD/MAIN.XEX ffa 1fff

gdzie 1fff może być z naddatkiem lub dokładnym adresem podejrzanym w wxHexEditor a ffa to adres 2 i 3 bajtu minus nagłówek u mnie $1000 - $6.

można skasować dla estetyki końcówkę wczytanych danych po RTS za pocą: f 1a15 1a1b 0

3. Wczytanie zasobów w przewidziane przez nas miejsce

read /home/zbyti/Atari8HDD/SCRAMBLE.FNT 2800 400

4. Zgranie pamięci do XEX

write XEX 1000 2bff 19b9

gdzie 19b9 to podejrzany wcześniej adres startowy.

5. Zmieniamy nazwę memdump.dat na np. gra.xex :]

---------------------------------------------------------------------------

Całość można spakować za pomocą Exomizera.
```
exomizer sfx sys -n -t 168 -o graexo.xex gra.xex
```
- SCRAMBLE6.XEX
- SCREXO2.XEX

36: CommentAuthorzbyti
CommentTime12 May 2020 17:05 zmieniony

OK. No to rezygnujemy z RSH na rzecz poniższego kawałka kodu który wydumałem ;)

Dla wartości:

BYTE ARRAY MATRIX=0
CARD TMP=[$2050]

PROC MAIN()
  PRINTF("%H%E",MATRIX(@TMP))
  PRINTF("%H%E",MATRIX(@TMP+1))
RETURN

Dla procedur:

BYTE ARRAY MATRIX=0

PROC FOO()
RETURN

PROC MAIN()
  CARD TMP
  TMP=FOO

  PRINTF("%H%E",FOO);
  PRINTF("%H%E",MATRIX(@TMP));
  PRINTF("%H%E",MATRIX(@TMP+1));
RETURN

Szybciej pewnie dużo nie będzie ale zaleta taka, że nie potrzeba mieć RSH w swoim RUNTIME.

- 37: CommentAuthorzbyti
- CommentTime13 May 2020 17:05 zmieniony
@Kaz o to Ci chodziło?
- atari00223.png
- scramble2.xex
- 38:
  
  CommentAuthorjhusak
- CommentTime14 May 2020 11:05 zmieniony
Od razu mówię, że moje niegdysiejsze wypociny nie stanowią wzorca, jak należy w Action programować, podobnie dzisiejsze. Nie robię tego na tyle często, żeby to zmasterować.
Przydatna technika w Action to zdefiniowanie na początku kodu tablicy:
byte array m=0
Wówczas mamy dostęp do całej pamięci bezpośrednio, np:

while m[53279]=7 do od

Nie wiem, jak to się kompiluje, czy sensowniej jest użyć zmiennej o adresie 53279, czy tego, ale po zdefiniowaniu to "m" już zawsze i w całym programie jest i będzie.
- 39: CommentAuthorzbyti
- CommentTime14 May 2020 11:05 zmieniony
@jhusak dzięki, stosuję już od 1-wszych warsztatów z @tdc by nie produkować wielu zmiennych.

Dzięki temu trickowi nie muszę używać procedur bibliotecznych PEEK/POKE.

Mam to tutaj ->link<- jako MATRIX.

Mógłbyś rzucić okiem na mojego gita to może więcej tip-ów by Ci się przypomniało i byś je podał?

---------------------------------------------------------------------------

Sprawdziłem także swego czasu jak to się kompiluje:
```
DEFINE COLOR2="$2C6"

SET $E=$2000
SET $491=$2000

BYTE ARRAY MATRIX=0

PROC MAIN()
  MATRIX(COLOR2)=2
RETURN

; 2000: 00        BRK
; 2001: 00        BRK
; 2002: 4C 05 20  JMP $2005
; 2005: 18        CLC
; 2006: AD 00 20  LDA $2000
; 2009: 69 C6     ADC #$C6
; 200B: 85 AE     STA $AE     ;LELNUM+1
; 200D: AD 01 20  LDA $2001
; 2010: 69 02     ADC #$02
; 2012: 85 AF     STA $AF     ;STENUM
; 2014: A9 02     LDA #$02
; 2016: A0 00     LDY #$00
; 2018: 91 AE     STA ($AE),Y ;LELNUM+1
; 201A: 60        RTS
; 201B: 60        RTS
```
```
PROC Poke=*(CARD a BYTE v)
[$85$A0$86$A1$98$A0$00$91$A0$60]

PROC PokeC=*(CARD a, v)
[$20 Poke $C8$A5$A3$91$A0$60]

BYTE FUNC Peek=*(CARD a)
CARD FUNC PeekC=*(CARD a)
[$85$A2$86$A3$A0$00$B1$A2$85$A0$C8$B1
$A2$85$A1$60]
```
Skłoniłeś mnie do myślenia czy nie napisać tego jakoś inaczej... :]

Chyba przeniosę PEEK/POKE do swojego TOOLS.ACT będzie krótszy kod kosztem JSR, a i te procedurki nie są źle napisane w ML by z nich nie korzystać.

40: CommentAuthorzbyti
CommentTime14 May 2020 12:05 zmieniony

DEFINE COLOR2="$2C6"

SET $E=$2000
SET $491=$2000

PROC POKE=*(CARD a BYTE v)
[$85$A0$86$A1$98$A0$00$91$A0$60]

PROC MAIN()
  POKE(COLOR2,2)
RETURN

; 2000: 85 A0     STA $A0     ;TSLNUM
; 2002: 86 A1     STX $A1     ;TSLNUM+1
; 2004: 98        TYA
; 2005: A0 00     LDY #$00
; 2007: 91 A0     STA ($A0),Y ;TSLNUM
; 2009: 60        RTS
; 200A: 4C 0D 20  JMP $200D
; 200D: A0 02     LDY #$02
; 200F: A2 02     LDX #$02
; 2011: A9 C6     LDA #$C6
; 2013: 20 00 20  JSR $2000
; 2016: 60        RTS
; 2017: 60        RTS

Rezygnuję z MATRIX dla POKE w tego typu sytuacjach, zostawiam go do sytuacji specjalnych, POKE robi dobrą robotę ;)

MATRIX(x) jest wygodniejsze od PEEK(x) bo można umieścić jako wartość parametru a PEEK jest funkcją więc już się nie da.

Widać wyższość kompilatora TeBe-go, który POKE od razu przerabia na LDA/STA.

41: CommentAuthorzbyti
CommentTime14 May 2020 12:05 zmieniony

To jeszcze dla potomnych taki wariant:

SET $E=$2000
SET $491=$2000

CARD SAVMSC=88
CARD POINTER SCREEN

PROC MAIN()
  SCREEN=SAVMSC
  SCREEN==+240
  SCREEN^=33
RETURN

; 2000: 00        BRK
; 2001: 00        BRK
; 2002: 4C 05 20  JMP $2005
; 2005: A5 59     LDA $59     ;SAVMSC+1
; 2007: 8D 01 20  STA $2001
; 200A: A5 58     LDA $58     ;SAVMSC
; 200C: 8D 00 20  STA $2000
; 200F: 18        CLC
; 2010: AD 00 20  LDA $2000
; 2013: 69 F0     ADC #$F0
; 2015: 8D 00 20  STA $2000
; 2018: AD 01 20  LDA $2001
; 201B: 69 00     ADC #$00
; 201D: 8D 01 20  STA $2001
; 2020: AD 00 20  LDA $2000
; 2023: 85 AE     STA $AE     ;LELNUM+1
; 2025: AD 01 20  LDA $2001
; 2028: 85 AF     STA $AF     ;STENUM
; 202A: A9 00     LDA #$00
; 202C: A0 01     LDY #$01
; 202E: 91 AE     STA ($AE),Y ;LELNUM+1
; 2030: A9 21     LDA #$21
; 2032: 88        DEY
; 2033: 91 AE     STA ($AE),Y ;LELNUM+1
; 2035: 60        RTS
; 2036: 60        RTS

SET $E=$2000
SET $491=$2000

BYTE ARRAY SCREEN
CARD SAVMSC=88

PROC MAIN()
  SCREEN=SAVMSC
  SCREEN(240)=33
RETURN

; 2000: 00        BRK
; 2001: 00        BRK
; 2002: 4C 05 20  JMP $2005
; 2005: A5 59     LDA $59     ;SAVMSC+1
; 2007: 8D 01 20  STA $2001
; 200A: A5 58     LDA $58     ;SAVMSC
; 200C: 8D 00 20  STA $2000
; 200F: 18        CLC
; 2010: AD 00 20  LDA $2000
; 2013: 69 F0     ADC #$F0
; 2015: 85 AE     STA $AE     ;LELNUM+1
; 2017: AD 01 20  LDA $2001
; 201A: 69 00     ADC #$00
; 201C: 85 AF     STA $AF     ;STENUM
; 201E: A9 21     LDA #$21
; 2020: A0 00     LDY #$00
; 2022: 91 AE     STA ($AE),Y ;LELNUM+1
; 2024: 60        RTS
; 2025: 60        RTS

Jak widać między posługiwaniem się tablicą i wskaźnikiem w kodzie wynikowym nie ma różnicy, tylko, że w przypadku tablicy mniej problematyczne było strzelić literką w odpowiedni punkt.

- 42: CommentAuthormono
- CommentTime14 May 2020 12:05
A co jeśli indeks tablicy jest typu BYTE?
- 43: CommentAuthorzbyti
- CommentTime14 May 2020 13:05 zmieniony
@mono Action! nie przewiduje takiej opcji, zawsze zrobi CARD nawet jak mu dasz BYTE, z resztą w przykładzie masz indeks = 240.

To samo jest z pętlami gdzie iterator jest typu BYTE dlatego Mad Pascal w pętlach gdzie iterator ma wartości od 0-255 generuje lepszą/szybszą pętlę od Action!

44: CommentAuthorzbyti
CommentTime14 May 2020 13:05

No to ostatni mogący interesować nas przykład w dyskusji czy stosować trick z tablicą założoną na całą pamięć w przypadku pojedynczych odczytów czy zapisów.

DEFINE COLOR2="$2C6"

SET $E=$2000
SET $491=$2000

BYTE FUNC PEEK=*(CARD a)
[$85$A2$86$A3$A0$00$B1$A2$85$A0$C8$B1$A2$85$A1$60]

PROC MAIN()
  BYTE COLOR
  COLOR=PEEK(COLOR2)
RETURN

; 2000: 85 A2     STA $A2     ;MVLNG
; 2002: 86 A3     STX $A3     ;MVLNG+1
; 2004: A0 00     LDY #$00
; 2006: B1 A2     LDA ($A2),Y ;MVLNG
; 2008: 85 A0     STA $A0     ;TSLNUM
; 200A: C8        INY
; 200B: B1 A2     LDA ($A2),Y ;MVLNG
; 200D: 85 A1     STA $A1     ;TSLNUM+1
; 200F: 60        RTS
; 2010: 00        BRK
; 2011: 4C 14 20  JMP $2014
; 2014: A2 02     LDX #$02
; 2016: A9 C6     LDA #$C6
; 2018: 20 00 20  JSR $2000
; 201B: A5 A0     LDA $A0     ;TSLNUM
; 201D: 8D 10 20  STA $2010
; 2020: 60        RTS

DEFINE COLOR2="$2C6"

SET $E=$2000
SET $491=$2000

BYTE ARRAY MATRIX=0

PROC MAIN()
  BYTE COLOR
  COLOR=MATRIX(COLOR2)
RETURN

; 2000: 00        BRK
; 2001: 00        BRK
; 2002: 00        BRK
; 2003: 4C 06 20  JMP $2006
; 2006: 18        CLC
; 2007: AD 00 20  LDA $2000
; 200A: 69 C6     ADC #$C6
; 200C: 85 AE     STA $AE     ;LELNUM+1
; 200E: AD 01 20  LDA $2001
; 2011: 69 02     ADC #$02
; 2013: 85 AF     STA $AF     ;STENUM
; 2015: A0 00     LDY #$00
; 2017: B1 AE     LDA ($AE),Y ;LELNUM+1
; 2019: 8D 02 20  STA $2002
; 201C: 60        RTS

- 45: CommentAuthormono
- CommentTime14 May 2020 14:05
No ale czekaj. W przykładzie masz zwiększenie wskaźnika o 240, a mnie chodzi o indeksowanie tablicy matrix za pomocą indeksu typu BYTE - czyli np. MATRIX(I)=13.
- 46: CommentAuthorzbyti
- CommentTime14 May 2020 14:05 zmieniony
@mono a jak zrozumiałeś poniższe?
```
SCREEN(240)=33
```
przecież SCREEN w tym przypadku to generalnie ten sam mechanizm co MATRIX.

Post #41, drugi blok kodu.
- 47: CommentAuthormono
- CommentTime14 May 2020 15:05
Masz rację, przepraszam za zawracanie głowy.

48: CommentAuthorzbyti
CommentTime14 May 2020 16:05 zmieniony

@mono Twoje pytanie ma sens bo w przypadku tablicy o zadeklarowanej wielkości (zapewne nie przekraczającej BYTE) masz już ładny kod:

SET $E=$2000
SET $491=$2000

BYTE ARRAY AR(10)

PROC MAIN()
  AR(0)=1
RETURN

; 2000: 00        BRK
; 2001: 00        BRK
; 2002: 0A        ASL
; 2003: 00        BRK
; 2004: 00        BRK
; 2005: 00        BRK
; 2006: 00        BRK
; 2007: 00        BRK
; 2008: 00        BRK
; 2009: 00        BRK
; 200A: 4C 0D 20  JMP $200D
; 200D: A9 01     LDA #$01
; 200F: 8D 00 20  STA $2000
; 2012: 60        RTS
; 2013: 60        RTS

więc fajnie, że zapytałeś bo inaczej bym nie sprawdził tego wariantu :]

49: CommentAuthorzbyti
CommentTime14 May 2020 19:05 zmieniony

Chmmm... To chyba ostatni praktyczny przykład warty uwagi na ten moment by wiedzieć: co, kiedy i jak użyć :]

W pętlach PEEK i POKE już nie będzie dobrym pomysłem tak jak przy pojedynczych strzałach.

SET $E=$2000
SET $491=$2000

CARD SAVMSC=88
BYTE ARRAY SCREEN

PROC MAIN()
  BYTE I=[0]

  SCREEN=SAVMSC+240

  FOR I=0 TO 9 DO
    SCREEN(I)=33+I
  OD
RETURN

; 2000: 00        BRK
; 2001: 00        BRK
; 2002: 00        BRK
; 2003: 4C 06 20  JMP $2006
; 2006: 18        CLC
; 2007: A5 58     LDA $58     ;SAVMSC
; 2009: 69 F0     ADC #$F0
; 200B: 8D 00 20  STA $2000
; 200E: A5 59     LDA $59     ;SAVMSC+1
; 2010: 69 00     ADC #$00
; 2012: 8D 01 20  STA $2001
; 2015: A0 00     LDY #$00
; 2017: 8C 02 20  STY $2002
; 201A: A9 09     LDA #$09
; 201C: CD 02 20  CMP $2002
; 201F: B0 03     BCS $2024
; 2021: 4C 44 20  JMP $2044
; 2024: 18        CLC
; 2025: AD 00 20  LDA $2000
; 2028: 6D 02 20  ADC $2002
; 202B: 85 AE     STA $AE     ;LELNUM+1
; 202D: AD 01 20  LDA $2001
; 2030: 69 00     ADC #$00
; 2032: 85 AF     STA $AF     ;STENUM
; 2034: 18        CLC
; 2035: A9 21     LDA #$21
; 2037: 6D 02 20  ADC $2002
; 203A: A0 00     LDY #$00
; 203C: 91 AE     STA ($AE),Y ;LELNUM+1
; 203E: EE 02 20  INC $2002
; 2041: 4C 1A 20  JMP $201A
; 2044: 60        RTS
; 2045: 60        RTS

- 50: CommentAuthorzbyti
- CommentTime14 May 2020 19:05 zmieniony
->link<-

Od 1 do 50 z 189