Movimiento de sprites dentro de un scroll de chars

[SingletonJohn]

Otra cosa importante, para cuando tengas que "definir" o "dibujar" el charset base de los tiles.
Hay dos rangos de memoria en el que no podrías meterlo, ya que el "cableado" del charset estándar te lo taparía, aunque el charset esté oculto (que es como está normalmente). Estos rangos son:
-$1000 a $1FFF (es decir el cableado del charset en el banco 0 del VIC)
-$9000 a $9FFF (es decir, el cableado del charset en el banco 2 del VIC)

Si te fijas, ambos cableados están en la posición relativa +$1000 y tienen $1000 bytes de tamaño, esto es 4096 bytes->4k->2k del charset "modo dibujo" y 2k del charset "máquina de escribir". Por lo tanto las posiciones 2 y 3 de las 8 posibles en el banco 0 y el banco 2, están PROHIBIDAS para la definición base del tileset. Tendrías que coger la 0,1,4,5,6 o 7 ....o usar otro banco

Observa que digo "prohibidas para un charset", ya que el cableado sólo afecta al charset que el VIC ve, en esas posiciones puedes poner código o definiciones de sprites o lo que sea, que puedes acceder a ello sin problemas

Esto aparece comentado el la Guía Oficial del Programador del C64 en 3.PROGRAMMING GRAPHICS - Graphic Locations - Character Memory (página 104)

[Laddh]

No hay problema, ya hace tiempo me acostumbre a que el VIC apunte siempre al banco 1, así pongo los chars editados que necesite donde quiera dentro de ese banco

[SingletonJohn]

Apunta siempre al banco 0->0000 a 16384. Recuerda que el charset estándar está cableado entre 4096 a 8191 (posiciones 2 y 3  del VIC, de las 8 posibles)

[SingletonJohn]

a esto me refiero...

Y recuerda que en el banco 0, no debes poner el charset en la posición cero (ya que está la página cero, la pila y la pantalla en posición estándar). Y en la posición 1 tampoco (o con mucho cuidado y dejando sin definir los primeros chars), ya que en $800 (2048) se inicia el basic, por lo que si usas un cargador, ojo con no pisarle hasta que se haya ejecutado

[SingletonJohn]

jajaja....estoy constantemente corrigiendo....hablo de memoria y al mirar los papeles veo que he metido el cuezo!

Perdona por el caos

[SingletonJohn]

Cómo lo llevas @Laddh ?

Qué tal va la cosa, has avanzado algo?

[Laddh]

Hola, pues de lo que pregunté y los tiles aún no he llegado, primero tengo que acabar de pulir el scroll de un bigmap de 4 pantallas en horizontal que ya he conseguido que los chars los muestre bien pixel a pixel pero no se porque el color me falla y produce unos destellos, y eso que hago doble buffer y no apunto a la pantalla hasta que esta hecho, te pongo el .prg para que lo veas, es más fácil de ver que explicar.

[javierglez]

No sigo muy bien el tema pero la memoria de color no tiene doble bufer. Para cambios en la memoria de color, si tienes alguna interrupción raster, quizá cambiando el orden de ejecucion de los distintos bloques de código.

[SingletonJohn]

Hola, pues de lo que pregunté y los tiles aún no he llegado, primero tengo que acabar de pulir el scroll de un bigmap de 4 pantallas en horizontal que ya he conseguido que los chars los muestre bien pixel a pixel pero no se porque el color me falla y produce unos destellos, y eso que hago doble buffer y no apunto a la pantalla hasta que esta hecho, te pongo el .prg para que lo veas, es más fácil de ver que explicar.

Efectivamente @javierglez tiene razón: sólo hay una Color Ram en 55296 ($D800, ahí está toda la info del color, a no ser que estés en modo multicolor o enhanced background color o Bitmap(o cualquier modo "no oficial"). La manera correcta de proceder es ir pintando el siguiente fotograma en el dobble buffer (mientras usas el scroll hardware te suele dar tiempo), y, en el momento en que toque, hacer el scroll de la Color RAM (que los colores acompañen a los tiles) y redireccionar el VIC al nuevo frame. Hay que hacer un movimiento de 1000 bytes en la Color Ram, por lo que le da tiempo de sobra al 6510. La clave es CUANDO

Los 1000 bytes del color da tiempo de sobra a moverlos desde que el raster entra en la primera línea del borde inferior hasta que vuelve a entrar por la primera línea superior de la pantalla (la primera tras el borde superior). EL cambio de VIC al buffer es casi inmediato, eso si, como es casi inmediato hay que hacerlo cuando el raster esta saliendo por el borde inferior de la pantalla. Yo he hecho las dos cosas sin problema. Eso si, conviene al inicio del juego, coordinar las interrupciones por tiempo (las que tengas para música, sonido, lectura del teclado, etc) con las del raster, y darles la misma frecuencia.

Esta coordinación se puede hacer al arrancar el juego, y sería tan "sencillo" como programar una interrupción de raster en la primera línea del borde inferior, y justo en esa interrupción, cambiar la frecuencia de la interrupción por tiempo a la del Raster y poner el "cronómetro" a cero y eliminar la interrupción por raster (esto NO ES DEL TODO EXACTO, pero si ves que cada cierto tiempo hay flickering, puedes ir corrigiéndolo, en las muertes, en los cambios de fase, etc...) De esta manera, en cada interrupción puedes hacer lo que sea necesario, tanto de gráficos como de cualquier otra cosa (sonido, animaciones, movimiento de sprites, etc)

@Laddh , si puedes pásanos mejor el código fuente o un archivo .d64 con los binarios (aunque esto último es más incómodo, ya que habría que descompilar, etc... si optas por archivo binario, no estaría de más un archivo de etiquetas o un mapa de memoria del juego etc...para que se puede entender bien el desensamblado

[SingletonJohn]

Veo que la rutina del movimiento de bytes está en $8c0 y que usas el modo de direccionamiento indirecto indexado. Veo además que intentas pintar el buffer y mover el color A LA VEZ, y por eso el raster te pillla enseguida. La mejor estrategia es pintar los tiles en el buffer en momentos en los que el procesador "está libre" mientras usas el scroll hardware (tienes más de un frame para hacerlo). Y en el momento que el Raster toca el borde inferior, hacer el scroll SOLO del color y cambiar de pantalla a buffer y vuelta a empezar.

También veo que debes tener dos espacios de 1000 bytes para mover el color: uno un buffer de lectura (puntero en $f7) y el otro de escritura en el D800 (puntero $f9)....a ver creo que sólo necesitas leer el buffer de color para la línea de tiles que entra. El resto de bytes YA ESTAN EN LA PANTALLA, con lo que los puedes mover de una forma mucho más rápida que con el indirect indexed....la Color RAM SIEMPRE está en $D800, no te hace falta una Indirect Indexed, ya que tienes que coger un tile en la color ram, pongamos que en $D805 y ponerlo en $D804 (o viceversa, según el scroll se mueva a derecha o izquierda) y repetirlo 1000 veces.

Si no quieres cambiar la rutina de mover el color, lo que si puedes hacer es empezar a mover el color Justo cuando el ráster entre en la primera fila de pixels de la segunda línea de tiles ($D828) e ir POR DETRÁS DE ÉL...con lo que tendrás MUUUUCHO mas tiempo que esperando a que esté en el borde inferior. Sólo deberías esperar a este momento justo para cambiar pantalla por buffer, ya que tarda unos 5 ciclos de reloj (el tiempo que tardas en cambiar el valor  del screen pointer)

[Laddh]

Je, te me has adelantado, te estaba escribiendo esto:

Te he aislado el programa solo con la parte que concierne al scroll para clarificar mejor.
Las rutinas importantes son las Bigmap, que escriben la pantalla entera en $4400 o $6400 (trabajo con el banco 1) después del scroll por hardware y a la de color.
Con el JOY 2 te mueves izq y der.
En $a000 esta en mapa de 4 pantallas de chars creado con el charpad y en $b000 el mapa de color, en $7000 los chars.

Código: [Seleccionar]

; 10 SYS (2064)

*=$0801

        BYTE    $0E, $08, $0A, $00, $9E, $20, $28,  $32, $30, $36, $34, $29, $00, $00, $00

*=$0810

zp=$f9
zs=$fb
screen=$4400
screen2=$6400
maptab=$a000

zpc=$f7
zc=$fd
colortab=$b000
color=$d800

screen_control_register1 = $d011
screen_control_register2 = $d016


        lda 1   ;quita el basic
        and #%11111110
        sta 1

        jsr PANCHAR
        jsr pantalla
        jsr int

init    jsr bigmap1
        jsr bigmap2
        LDA $D018
        AND #15
        ORA #144  ;POSICIÓN PANTALLA DENTRO DEL BANCO1 $6400
        STA $D018

        LDA screen_control_register2
        AND #$F7    ;38 columnas
        STA screen_control_register2

lg      jsr raster_wait ;Loop game
        jsr PlayerControl
        jmp lg

PlayerControl
                  lda #4      ;Read LEFT on joystick port 2
                  bit $dc00
                  bne NotDENLeft
        jsr right ;muevecajai

NotDENLeft                 
                  lda #8      ;Read RIGHT on joystick port 2
                  bit $dc00
                  bne NotDENRight
        jsr left ;muevecajad
NotDENRight   
      rts

bigmap1
        lda #<maptab
        sta zp 
        lda #>maptab
        sta zp+1

        lda #<colortab
        sta zpc 
        lda #>colortab
        sta zpc+1

fixcol  lda cornrx
        clc
        adc zp
        sta zp
        lda #0
        adc zp+1
        sta zp+1
       
        lda cornrx
        clc
        adc zpc
        sta zpc
        lda #0
        adc zpc+1
        sta zpc+1

        lda #<screen
        sta zs
        lda #>screen
        sta zs+1

        lda #<color
        sta zc
        lda #>color
        sta zc+1

        lda lines
        sta countr
storlp  ldy cols
inloop  lda (zp),y
        sta (zs),y

        lda (zpc),y
        sta (zc),y

        dey
        bpl inloop
           
        clc
        lda zp
        adc width
        sta zp
        lda #0
        adc zp+1
        sta zp+1
        clc
        lda zs
        adc #40
        sta zs
       
        clc
        lda zpc
        adc width
        sta zpc
        lda #0
        adc zpc+1
        sta zpc+1
        clc
        lda zc
        adc #40
        sta zc

        bcc fdg
        inc zs+1
        inc zc+1

fdg     dec countr
        bpl storlp

        rts

bigmap2
        lda #<maptab
        sta zp 
        lda #>maptab
        sta zp+1

        lda #<colortab
        sta zpc 
        lda #>colortab
        sta zpc+1

fixcol2  lda cornrx
        clc
        adc zp
        sta zp
        lda #0
        adc zp+1
        sta zp+1
       
        lda cornrx
        clc
        adc zpc
        sta zpc
        lda #0
        adc zpc+1
        sta zpc+1

        lda #<screen2
        sta zs
        lda #>screen2
        sta zs+1

        lda #<color
        sta zc
        lda #>color
        sta zc+1

        lda lines
        sta countr
storlp2  ldy cols
inloop2  lda (zp),y
        sta (zs),y

        lda (zpc),y
        sta (zc),y

        dey
        bpl inloop2
           
        clc
        lda zp
        adc width
        sta zp
        lda #0
        adc zp+1
        sta zp+1
        clc
        lda zs
        adc #40
        sta zs
       
        clc
        lda zpc
        adc width
        sta zpc
        lda #0
        adc zpc+1
        sta zpc+1
        clc
        lda zc
        adc #40
        sta zc

        bcc fdg2
        inc zs+1
        inc zc+1

fdg2     dec countr
        bpl storlp2

sale2   rts

left   
        ldx cornrx
        cpx maxx
        beq sale2
    LDX screen_offset
    DEX
    STX screen_offset
    CPX #$FF
    BEQ continue
    JMP end
continue
    LDX #$07
    STX screen_offset
        jsr move_rows_left
end     
    LDA screen_control_register2
    AND #$F8
    ORA screen_offset
    STA screen_control_register2
    rts

move_rows_left
        inc cornrx
        jsr swap_bigmap
        jsr swap_video
sale3   rts
screen_offset byte $07

right
        ldx cornrx
        beq sale3
    LDX screen_offset_r
    inx
    STX screen_offset_r
    CPX #8
    Beq continuer
    JMP endr
continuer
    LDX #$00
    STX screen_offset_r
        jsr move_rows_right
endr 
    LDA screen_control_register2
    AND #$F8
    ORA screen_offset_r
    STA screen_control_register2
@sal        rts

move_rows_right
        dec cornrx
        jsr swap_bigmap
        jsr swap_video
        rts
screen_offset_r byte $00

swap_video
        lda cp
        beq pantalla1
        bne pantalla2
        rts
pantalla1
        LDA $D018
        AND #15
        ORA #16  ;POSICIÓN PANTALLA DENTRO DEL BANCO1 $4400
        STA $D018
        lda #1
        sta cp
        rts
pantalla2
        LDA $D018
        AND #15
        ORA #144  ;POSICIÓN PANTALLA DENTRO DEL BANCO1 $6400
        STA $D018
        lda #0
        sta cp
        rts
cp      byte 0

swap_bigmap
        lda bm
        beq bm1
        bne bm2
        rts
bm1
        jsr bigmap1
        lda #1
        sta bm
        rts
bm2
        jsr bigmap2
        lda #0
        sta bm
        rts
bm      byte 0

raster_wait               ;espera línea raster
l         LDA  #$ff
          CMP  $D012
          BNE  l
          BIT  $d011
          BMI  l
          rts

PANCHAR   LDA  56578
          ORA  #3        ;PREPARAMOS PARA SELECCIONAR EL @@@
          STA  56578
          LDA  56576
          AND  #252
          ORA  #2        ; @@@ BANCO DE VIDEO 1 (16384)
          STA  56576
; COMO MEMORIA PANTALLA SE QUEDA EN SU POSICIÓN POR DEFECTO, NO LA CAMBIAMOS
;        LDA $D018
;        AND #15
;        ORA #16  ;POSICIÓN PANTALLA DENTRO DEL BANCO
;        STA $D018
; SI QUISIERAMOS EL CURSOR
;        LDA #68 ;CURSOR PANTALLA EN BANCO 1
;        STA 648

          LDA  $D018
          AND  #240      ;ESTABLECEMOS EL MODO CARACTER
          ORA  #12       ;BUSCA CARACTERES A PARTIR DE 12288 + DIR BANCO 1
          STA  $D018
;        LDA $D016
;        ORA #16  ;MODO CARACTER MULTICOLOR
;        STA $D016
         RTS

pantalla
        lda #11
        sta $d020
        sta $d021
        lda #8
        sta $d022
        lda #10
        sta $d023
        rts

INT     sei
         lda #<n1
        sta $0314
        lda #>n1
        sta $0315
;        lda #$00
;        jsr $1000 ;Initialize music
         lda #$7f
         sta $dc0d
         sta $dd0d
 
         lda #$01  ;IRQ speeder
         sta $d01a
        cli
        RTS

N1      asl $d019 ; IRQ speeder again
        lda $dc0d
        sta $dd0d ; Stabilize CIA

;        jsr $1003;Play the music
        jmp $ea31 ;7e

width   byte 160
height  byte 22 ;25 normal total lineas pantalla vertical
lines   byte 21;22-1
cols    byte 39 ;40-1

cornrx  byte 0
cornry  byte 0
maxx    byte 120 ;160-40 total mapa x menos pantalla (40 carac)
maxy    byte 0   ;25-25 total mapa y menos pantalla (25 carac)
countr  byte 0
countr2  byte 0


*=$7000  ;28672 ;CARACTERES EN BANCO 1 (12288 + 16384)
incbin    "chars2.bin"

*=$a000
incbin"map.bin"
*=$b000
incbin"colormap.bin"


[SingletonJohn]

Varias ideas que te pueden ayudar:

-Pon música e interrupciones raster en la misma rutina de interrupción y coordínalas. Eso es mejor que esperar al raster, que tienes al procesador ocioso esperando el momento (raster_wait). De esta forma, coordinando ambas cosas, no pierdes tiempo. Si al entrar en la rutina de interrupción ves que hay que hacer el scroll de color y cambiar pantalla por buffer, pues lo haces. Si no, pues no....usando las variables que tienes mismamente lo podrías hacer

-Para hacer el scroll de color VE POR DETRÁS del raster...es decir, cuando el ráster esté pintando la segunda fila de tiles, empieza a mover el color de la primera fila....ganarás un tiempo enorme. Y justo al final del scroll de color, cambia el pointer de la pantalla. Lo más seguro es que se haga con el raster fuera de pantalla y no se note. Esto es ya es cuestión de AJUSTE FINO (o de renunciar a un fps de 60. Hasta 21 fps la percepción del scroll es suave).Por lo tanto, me desdigo del rollo anterior y sincroniza las interrupciones con el ráster entrando en la segunda fila de chars.

-Ve pintando el buffer con el frame siguiente mientras usas el scroll hardware. Por ejemplo, si pintas 1/3 de pantalla cada vez, lo tienes listo en 3 frames y luego el procesador está libre para otras cosas

-Investiga o intenta crear una rutina de movimiento de color/tiles más eficiente que una indirecta indexada...si vas ganando 1 ciclo en cada pixel, cada 4 pixels te sale uno de gratis. Por ejemplo, en vez de usar indirect indexed, puedes probar una absoluta que se vaya automodificando (y ganas 1 ciclo por cada operación de lectura o de escritura)....como vas a mover 1000 bytes, necesitas hacer 1000 operaciones de lectura y 1000 de escritura.....la diferencia es NOTABLE. Además es una rutina CRUCIAL. En un rato te pongo un ejemplo

 

[SingletonJohn]

Mira esta rutina, que es una rutina de esas que son bucles "desenrollados". Tómalo como un ejemplo, fijo que hay rutinas mucho mejores

La primera columa es la dirección de memoria en la que se aloja. La segunda columna los bytes que ocupa. La tercera columna es el tiempo que tarda (en ciclos de procesador). La cuarta no influye...es el número de línea

Cada par de LDA/STA es una línea, luego este bloque se repetirá 25 veces y ocupa 6 bytes. Entonces tienes una rutina de 25*6 + 2 + 6 = 158 bytes...es asumible en términos de espacio.

cada bloque de LDA/STA tarda unos 10 ciclos. por lo tanto 25 líneas tardarán 250 ciclos. Como la rutina se repite 38 veces (ldy #39 estaría mal), tarda en moverte los 1000 bytes de color = 38 * 250 = 9500 ciclos

[SingletonJohn]

Analicemos ahora la tuya, teniendo en cuenta sólo que movemos color:

En términos de espacio ocupa $947- $91D = $2A = 42 bytes....ahorro importante de espacio

Analicemos el tiempo:

el bloque $920-925 se repite 39 veces por línea. Una ejecución tarda 18 ciclos, luego una línea tarda 18*39 = 702. Como son 25 líneas de color, ese bloque tarda 25*702 = 17550 ciclos.

el otro bloque se repite 24 veces (1 por línea). Como el bloque tarda unos 44 ciclos aprox -> 44 *24 = 1056 ciclos.

Por lo tanto, en mover 1000 bytes tardas 1056 + 17550 = 18606

es decir, tardamos 18606 ciclos frente a 9500....es algo menos del doble de tiempo....creo que puede compensar si no andas PILLADÍSIMO de espacio

[SingletonJohn]

Ahora vamos a hacer un cálculo "poco fino".
El raster tarda en cada frame 1/60 segundos                                          = 0,0167   segundos
Tu rutina inicial tarda en ejecutarse 18606 ciclos/1000000 ciclos/segundo = 0,0186   segundos (te pilla)
Con la rutina "Desenrollada" tardas 9500 ciclos/1000000                         = 0,0095 segundos (te libras y tienes tiempo de sobra de meter la nueva columna de color por la derecha o por la izquierda)

Luego compensa sacrificar 158*2 = 316 bytes (158 en scroll left y 158 en scroll right)
O puede que no.....que andes pillado de memoria y prefieras sacrificar framerate...