Skopiowanie większej ilości danych do RAM

[siudym]

No właśnie a gdybym chciał mieć w dowolnym miejscu BitMask?

[trojacek]

To wtedy będzie trochę więcej kodu.
Pierwsze, co mi przychodzi do głowy:

Kod: [Zaznacz]

    LD HL, BitMask
    LD D, 0
    LD E, Counter
    ADD HL, DE
    LD A, Flags
    AND (HL)
    JR NZ, skip
    JR innafunkcja
skip

[siudym]

Do weryfikacji - tym razem inny przyklad, ale takze zastepowanie indexowania z uzyciem X z 6502:

- przenosi przy kazdym przebiegu petli cztery kolejne zmienne pod adres ram, po czym zwieksza o cztery aby znowu zapisac je w kolejnych 4 bajtach ram itd itd

; 6502:

loop:

   LDX counter      ; startuje od 00, zwiekszany co cztery przy kazdym przebiegu petli 00,04,08,0C itd

   LDA temp0
   STA $200,x

   LDA temp1
   STA $201,x

   LDA temp2
   STA $202,x

   LDA temp3
   STA $203,x

;------

   TXA
   CLC
   ADC #4
   STA counter

   jmp loop

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

; z80:



   LD D,$00

loop:

   LD A,(counter)
   LD E,A

   LD HL,$200
   ADD HL,DE

   LD A,(temp0)
   LD (HL),A

   INC HL         ; LD HL,$201
   ADD HL,DE

   LD A,(temp1)
   LD (HL),A

   INC HL         ; LD HL,$202
   ADD HL,DE

   LD A,(temp2)
   LD (HL),A

   INC HL         ; LD HL,$203
   ADD HL,DE

   LD A,(temp3)
   LD (HL),A

;------

   LD A,E
   ADD $04
   LD (counter),A

   jp loop

[steev]

Jeśli dobrze zrozumiałem co chcesz zrobić to powiedziałbym, że albo:

Kod: [Zaznacz]

  LD HL, $200
loop:
  LD A,(temp0)
  LD (HL),A
  INC HL
  LD A,(temp1)
  LD (HL),A
  INC HL
  LD A,(temp2)
  LD (HL),A
  INC HL
  LD A,(temp3)
  LD (HL),A
  INC HL
  <test na wyjście z pętli>
  JR loop

albo np.

Kod: [Zaznacz]

  LD DE,$200
loop:
  LD HL,temp0
  LDI
  LD HL,temp1
  LDI
  LD HL,temp2
  LDI
  LD HL,temp3
  LDI
  <test na wyjście z pętli>
  JR loop
(dużo wolniej, ale jest taka opcja )

'Dosłowne' przeniesienie wyglądałoby pewnie jakoś tak...

Kod: [Zaznacz]

  LD IY,$200
  LD DE,$04
loop:
  LD A,(temp0)
  LD (IY+0),A
  LD A,(temp1)
  LD (IY+1),A
  LD A,(temp2)
  LD (IY+2),A
  LD A,(temp3)
  LD (IY+3),A
  ADD IY,DE
  <test na wyjscie z pętli>
  JR loop
(nie idź tą drogą)

[siudym]

Dzięki. To jest tylko przykładowa funkcja, nie ma wyjścia z pętli - chodzi tylko o zastąpienie tego przykładowego kodu. Użycie IY nie wpadłem na to, zapomniałem, że też podobnie jak HL można wysyłać pod wskazany przez niego adres.

[siudym]

Kolejna zagwostka..

Bawię się różnymi funkcjami związanymi ze zmianami w ram,
funkcja niżej powinna zapisać $E8 co czwarty bajt w obszarze pamięci 128-bajtow - niestety robi to losowo:

   LD A,$E8
   LD HL,$C300
   LD DE,$0000

   LD B,32

loop:

   LD (HL),A

   INC DE
   INC DE
   INC DE
   INC DE

   ADD HL,DE

   DEC B
   jp nz,loop

- B uzylem jako licznik czyli 32x4=128

- tak wygląda pamięć po wykonaniu tej funkcji:

Powinny byc E8 co czwarty bajt, a nie sa.

[steev]

Zwiększasz dodawaną wartość przed dodaniem, ergo zwiększasz przesunięcie

albo

Kod: [Zaznacz]

ld a, $e8
 ld hl, $c300
 ld b, $20
loop:
 ld (hl),a
 inc hl
 inc hl
 inc hl
 inc hl
 djnz loop
 end

albo

Kod: [Zaznacz]

ld a, $e8
 ld b, $20
 ld hl, $c300
 ld de, $04
loop:
 ld (hl),a
 add hl,de
 djnz loop
 end


[siudym]

Ale jak zwiększam po dodaniu, mam to samo :/

EDIT. Przeanalizowałem i faktycznie 

   LD A,$E8
   LD HL,$C300
   LD DE,$0004

   LD B,32

loop:

   LD (HL),A
   ADD HL,DE
   DEC B
   jp nz,loop

   RET

[trojacek]

Przeanalizowałem i faktycznie 

Przeanalizowałeś i zepsułeś to, co napisał steev
Tego się trzymaj:

Kod: [Zaznacz]

ld a, $e8
 ld b, $20
 ld hl, $c300
 ld de, $04
loop:
 ld (hl),a
 add hl,de
 djnz loop
 end


Hint: DJNZ = DEC B + JR NZ.

[siudym]

Przeanalizowałeś i zepsułeś to, co napisał steev

Ja tylko wstawiłem działający kod bez błędu popełnionego wcześniej (niepotrzebne 4x INC DE, powodujące, że mialem E8 wstawiane co 4,8,12,16,20,24 itd itd ). To, że użycie DJNZ znacznie lepsze to już wiem.

[siudym]

Wracam do pytania związanego z zamiennikiem indexowania 6502 w Z80:

Mam przykładowy kod - jest to bardzo uproszczona, przykładowa pętla ruchu sprites na ekranie.
Pętla jest jedną, wspólną funkcją dla wszystkich sprites, jedynie zmieniane są wartości indexow i wykonywanu skok do tej funkcji.
Dla kodu 6502 używam indexu Y dla zmiennych, które w pamięci RAM są co jeden bajt, natomiast index X dla zmiennych sprite's, które są co 4 bajty.

Interesuje mnie jak lepiej to zrobić w przypadku kodu Z80 (bo domyślam się, można to zrobić lepiej... )

; RAM:

ENEMY0_FLAGS         ; te zmienne są jedna po drugiej w pamięci RAM
ENEMY1_FLAGS
ENEMY2_FLAGS
ENEMY3_FLAGS
(...)

ENEMY0_Y         ; tu jest nieco inaczej bo każda zmienna np. Y jest co 4 bajty dla kolejnego Sprite'a
ENEMY0_X
ENEMY0_T
ENEMY0_P
ENEMY1_Y
ENEMY1_X
ENEMY1_T
ENEMY1_P
ENEMY2_Y
ENEMY2_X
ENEMY2_T
ENEMY2_P
ENEMY3_Y
ENEMY3_X
ENEMY3_T
ENEMY3_P
(...)

; ################################################
; 6502:

   LDY $00         ; ENEMY0 FLAGS
   LDX $00         ; ENEMY0 Y/X
   JSR FUNKCJA_WSPOLNA

   LDY $01         ; ENEMY1 FLAGS
   LDX $04         ; ENEMY1 Y/X
   JSR FUNKCJA_WSPOLNA

   LDY $02         ; ENEMY2 FLAGS
   LDX $08         ; ENEMY2 Y/X
   JSR FUNKCJA_WSPOLNA

   LDY $03         ; ENEMY3 FLAGS
   LDX $0C         ; ENEMY3 Y/X
   JSR FUNKCJA_WSPOLNA

(...)

FUNKCJA_WSPOLNA:

   LDA ENEMY0_FLAGS,Y
   AND %00000001
   BEQ FUNKCJA_WSPOLNA_NO

   INC ENEMY0_Y,X
   INC ENEMY0_X,X

FUNKCJA_WSPOLNA_NO:
   RTS

; ################################################
; Z80:

   LD HL,$0000
   LD (TEMP1),HL      ; ENEMY0 FLAGS
   LD (TEMP2),HL      ; ENEMY0 Y/X
   CALL FUNKCJA_WSPOLNA

   LD HL,$0001
   LD (TEMP1),HL      ; ENEMY1 FLAGS
   LD HL,$0004
   LD (TEMP2),HL      ; ENEMY1 Y/X
   CALL FUNKCJA_WSPOLNA

   LD HL,$0002
   LD (TEMP1),HL      ; ENEMY2 FLAGS
   LD HL,$0008
   LD (TEMP2),HL      ; ENEMY2 Y/X
   CALL FUNKCJA_WSPOLNA

   LD HL,$0003
   LD (TEMP1),HL      ; ENEMY3 FLAGS
   LD HL,$000C
   LD (TEMP2),HL      ; ENEMY3 Y/X
   CALL FUNKCJA_WSPOLNA

(...)

FUNKCJA_WSPOLNA:

   LD HL,(TEMP1)
   LD DE,HL
   LD HL,(ENEMY0_FLAGS)
   ADD HL,DE
   LD A,(HL)
   AND %00000001
   JR Z,FUNKCJA_WSPOLNA_NO

   LD HL,(TEMP2)
   LD DE,HL

   LD HL,(ENEMY0_Y)
   ADD HL,DE
   LD A,(HL)
   INC A
   LD (HL),A

   LD HL,(ENEMY0_X)
   ADD HL,DE
   LD A,(HL)
   INC A
   LD (HL),A

FUNKCJA_WSPOLNA_NO:
   RET

[steev]

Wracam do pytania związanego z zamiennikiem indexowania 6502 w Z80:

Nie da się.

Mam przykładowy kod - jest to bardzo uproszczona, przykładowa pętla ruchu sprites na ekranie.
Pętla jest jedną, wspólną funkcją dla wszystkich sprites, jedynie zmieniane są wartości indexow i wykonywanu skok do tej funkcji.
Dla kodu 6502 używam indexu Y dla zmiennych, które w pamięci RAM są co jeden bajt, natomiast index X dla zmiennych sprite's, które są co 4 bajty.

Interesuje mnie jak lepiej to zrobić w przypadku kodu Z80 (bo domyślam się, można to zrobić lepiej... )

Nie lepiej.
Inaczej

Kod: [Zaznacz]

;; robimy_wode_z_mozgu.asm

    org $8000

sprites equ     3

start:
    ld b,       sprites
    exx
    ld hl,      pos
    ld de,      4
    exx
    ld hl,      flags
loop:
    bit 0,(hl)
    jr z,       go_away
    exx
    inc (hl)
    inc hl
    inc (hl)
    dec hl
    exx
go_away:
    inc hl
    exx
    add hl,de
    exx
    djnz loop
    ret

flags:
    db  0       ;       ENEMY0_FLAGS
    db  0       ;       ENEMY1_FLAGS
    db  0       ;       ENEMY2_FLAGS

pos:
    db  0       ;       ENEMY0_Y
    db  0       ;       ENEMY0_X
    db  0       ;       ENEMY0_T
    db  0       ;       ENEMY0_P
    db  0       ;       ENEMY1_Y
    db  0       ;       ENEMY1_X
    db  0       ;       ENEMY1_T
    db  0       ;       ENEMY1_P
    db  0       ;       ENEMY2_Y
    db  0       ;       ENEMY2_X
    db  0       ;       ENEMY2_T
    db  0       ;       ENEMY2_P
Nie testowałem, ale chyba powinno robić to co powinno...

[siudym]

    ld b,       sprites
    exx                                             ; ? wymien bc,de,hl na ich rejesty "cienie"
    ld hl,      pos
    ld de,      4
    exx                                             ; ? teraz znowu wymien bc,de,hl na "cienie" - czy teraz zapis HL/DE wyzej nie bedzie zniszczony?
    ld hl,      flags

- tu nie rozumiem zastosowania EXX, jaki ma cel?
- czy nie bedzie tak, ze ponowny EXX po wykonaniu LD HL / LD DE zniszczy nam ich stan bo przecież drugie EXX wykona przeniesienie pustych "cieni rejestrow" znowu do DE i HL ?

[matofesi]

EXX nic nie przenosi. Procesor ma dwa bloki rejestrów i EXX przełącza ten, który jest aktualnie używany. Po wykonaniu twojego kodu w "drugim" bloku (tym normalnie niedostępnym) będziesz miał pos w HL i 4 w DE, a w "głównym" sprites w B i flags w HL. Kolejne EXX "zamieni" znowu bloki rejestrów. Jedyna niedogodność do której dostosowuje się algorytmy to to, że nie da się używać obu bloków równocześnie.

[siudym]

Racja, źle zrozumiałem zasadę działania EXX. Wszystko jasne.