atarionline.pl Scramble in Action! - Forum Atarum

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.

    • 1: CommentAuthorzbyti
    • CommentTime7 May 2020 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 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...

    • 3:
       
      CommentAuthorKaz
    • CommentTime7 May 2020
     
    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 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
     
    Ładne to :)
    • 6: CommentAuthorzbyti
    • CommentTime8 May 2020 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.

    • 7: CommentAuthorMADRAFi
    • CommentTime8 May 2020 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
     
    @MADRAFi fajnie, to motywujące! :]
    • 9:
       
      CommentAuthorKaz
    • CommentTime8 May 2020
     
    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
     
    Jak już kodu będzie więcej i się zmotywuje, to zrobię trzecią wersję w cc65 ;)
    • 11: CommentAuthorzbyti
    • CommentTime8 May 2020
     
    DLI wrzucone zgodnie z pomysłem @Kaza
    • 12:
       
      CommentAuthorKaz
    • CommentTime8 May 2020
     
    Nie do końca tak, ale coraz bliżej :D
    • 13: CommentAuthorzbyti
    • CommentTime8 May 2020
     
    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
     
    pięknie zbyti, czekam na filmik
    • 15: CommentAuthorilmenit
    • CommentTime8 May 2020
     
    a ja na xex'a ;)
    • 16: CommentAuthorgorgh
    • CommentTime8 May 2020
     
    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 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.
    • 18: CommentAuthorzbyti
    • CommentTime8 May 2020
     
    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
     
    To ja napiszę wersję w haskellu.
    • 20: CommentAuthorzbyti
    • CommentTime8 May 2020
     
    @antrykot za Haskella na Atari robi FORTH ;)
    • 21: CommentAuthorzbyti
    • CommentTime9 May 2020 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 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
    • 23: CommentAuthorgorgh
    • CommentTime9 May 2020
     
    piękne dzięki za filmik, już udostępniony, gra cudo
    • 24: CommentAuthorzbyti
    • CommentTime9 May 2020
     
    @gorgh You are too kind Mister! :D
    • 25: CommentAuthorzbyti
    • CommentTime11 May 2020 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.
    • 26:
       
      CommentAuthorjhusak
    • CommentTime12 May 2020
     
    Nie trzeba całej a000-bfff dołączać, wystarczy jakieś 3kb spod a000.
    • 27: CommentAuthorzbyti
    • CommentTime12 May 2020
     
    @jhusak dzięki za TIP, sprawdzę.
    • 28:
       
      CommentAuthorjhusak
    • CommentTime12 May 2020 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
     
    w Action mozna tez chyba podmieniac funkcje systemowe definiujac pod tymi samymi nazwami wlasne.
    • 30: CommentAuthorzbyti
    • CommentTime12 May 2020 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 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 ;)
    • 32: CommentAuthorzbyti
    • CommentTime12 May 2020
     
    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
     
    tyle zachodu zeby pobrac do rejestru starszy bajt ?
    • 34: CommentAuthorzbyti
    • CommentTime12 May 2020 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 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
    • 36: CommentAuthorzbyti
    • CommentTime12 May 2020 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 zmieniony
     
    @Kaz o to Ci chodziło?
    • 38:
       
      CommentAuthorjhusak
    • CommentTime14 May 2020 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 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 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 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
     
    A co jeśli indeks tablicy jest typu BYTE?
    • 43: CommentAuthorzbyti
    • CommentTime14 May 2020 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
     
    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
     
    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 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
     
    Masz rację, przepraszam za zawracanie głowy.
    • 48: CommentAuthorzbyti
    • CommentTime14 May 2020 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 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 zmieniony