Autor Tema: Rutinas en CM mas o menos útiles  (Leído 26422 veces)

Maniako

  • Desarrolladores
  • Commodore Master
  • ******
  • Mensajes: 1008
  • SYS 8*4096
    • Ver Perfil
Re:Rutinas en CM mas o menos útiles
« Respuesta #15 en: Mayo 29, 2016, 15:38:41 »
Hace tiempo que no colgaba nada por aquí y ya tocaba XD.

Gracias a Riq y a sus ejemplos de código he llegado entender como usar las interrupciones (o eso creo XD).

Aquí dejo el código fuente esperando que alguíen me muestre los fallos y como mejorar la rutina.
Es lo más básico necesario para hacerlas funcionar. Solo hace algo raro cuando provocas un ?syntax error, se "clava" un poco y vuelve a la normalidad. Después, por muchos ?Syntax error que hagas, ni se inmuta.

Hacer un NEW antes de introducir lineas basic, si no, se reseteará. ;)

Código: [Seleccionar]
;CBM prg studio.

; 10 SYS32768

*=$0801

        BYTE    $0B, $08, $0A, $00, $9E, $33, $32, $37, $36, $38, $00, $00, $00

*=$8000         ;Coloco el programa aquí para que no se desplace al
                ;entrar lineas de basic.
vector=vect;$0400
        ldx#0
        sta vector

       ; jsr$ff81        ;Limpiar pantalla
        sei                                   
        lda #%00011011  ;27 original. 26 no flickea.Hibyte del raster pero                             
        sta $D011       ;si no es 27 aparecen "pelos" en los bordes pantalla.
        lda #<irq1                         
        sta $0314                           
        lda #>irq1                         
        sta $0315                           
        lda #%00000001  ;#127 en el ejemplo. Basta con activar el timer A #1     
        sta $DC0D       ;Registro control de la cia                   
        lda #1                             
        sta $D01A       ;Registro mascara IRQ activada. IRQ ON.
        cli 
        rts             ;Salida al basic para pruebas.

main    ;El programa empezaria aquí.
        jmp main

irq1
        lda $D019       ;Reset bandera de registro reescribiendo encima su
        sta $D019       ;propio valor de nuevo.Si no, se queda activado y falla.
        ldx vector
        ldy linea,x
        sty $d012
        ldy color,x
        sty $d020
        lda linea+1,x    ;Siguente nuevo valor
        cmp #255
        beq salt0
        inc vector
        jmp $FEBC        ;Saltar a restaurar a partir de la rutina NMI.

salt0
        lda #0
        sta vector
       
        jmp $EA31       ;Rutina interrupcion normal Leer teclado y demás.     

linea   byte $32,$3A,$42,$4A,$52,$5A,$62,$6A,$72,$7A,$82,$8A,$92,$9A,$A2,$AA,$C8,$ff
color   byte $00,$01,$02,$03,$04,$05,$06,$07,$08,$09,$0a,$0b,$0c,$0d,$0e,$0f,$00
vect
« última modificación: Mayo 29, 2016, 15:43:38 por Maniako »
LDA #$50
STA $0400
RTS
Lloré cuando conseguí hacer esto con el monitor del FC1.

josepzin

  • Administrador
  • Commodore Master
  • *****
  • Mensajes: 13628
  • Commodoreador web
    • Ver Perfil
    • Mi blog
Re:Rutinas en CM mas o menos útiles
« Respuesta #16 en: Mayo 29, 2016, 15:47:00 »
Ese Maniako interruptor :-)
www.retroinvaders.com | www.commodoreplus.org  | josepzin.blogspot.com

riq

  • Desarrolladores
  • Commodore Master
  • ******
  • Mensajes: 567
    • Ver Perfil
    • From the C64 until today, a developer's perspective
Re:Rutinas en CM mas o menos útiles
« Respuesta #17 en: Mayo 29, 2016, 16:40:06 »
Esa!

No recuerdo haber visto mucho el "JMP $FEBC", pero esta bien lo que haces. Es lo mismo que hacer "JMP $EA81"... nada más que el EA81 es más popular que el FEBC.

El "LDA $D019; STA $D019" lo podes reemplazar por "LDA $D019"... creo que no hace falta el "STA $D019"... solo lo tenes que leer para hacer el "ack" de la interrupción.

« última modificación: Mayo 29, 2016, 16:44:20 por riq »

Maniako

  • Desarrolladores
  • Commodore Master
  • ******
  • Mensajes: 1008
  • SYS 8*4096
    • Ver Perfil
Re:Rutinas en CM mas o menos útiles
« Respuesta #18 en: Mayo 29, 2016, 18:13:35 »
Entonces están bien así?. No sabes la ilusión que me hace poder utilizarlas por fin jejeje.
Hay que escribir en D019 para limpiar la bandera de la interrupción. Si no, no funciona.
Pasa lo mismo que con los sprites creo recordar.

He probado con $EA81 y funciona igual. Usaré EA81 ya que es más fácil de recordar.
$EA31 y $EA81.
NMI no dar de comer al 3.
IRQ dar de comer al 3.
 ;D

Ahora a hacer scroll fuera del barrido de pantalla o mover los caracteres justo cuando el barrido sobrepase la zona donde se muestren para ganar tiempo de proceso.
Me queda aun mucho trabajo.
LDA #$50
STA $0400
RTS
Lloré cuando conseguí hacer esto con el monitor del FC1.

Maniako

  • Desarrolladores
  • Commodore Master
  • ******
  • Mensajes: 1008
  • SYS 8*4096
    • Ver Perfil
Re:Rutinas en CM mas o menos útiles
« Respuesta #19 en: Mayo 29, 2016, 18:18:10 »
Ese Maniako interruptor :-)

No queriais programadores?. Pues en eso estoy.   :P

Cuando domine todas estas cosas y me vea preparado, veremos si podemos modificar los juegos multicarga y pasarlos a lo que se necesite. Aún me queda mucho trabajo. :-[
LDA #$50
STA $0400
RTS
Lloré cuando conseguí hacer esto con el monitor del FC1.

riq

  • Desarrolladores
  • Commodore Master
  • ******
  • Mensajes: 567
    • Ver Perfil
    • From the C64 until today, a developer's perspective
Re:Rutinas en CM mas o menos útiles
« Respuesta #20 en: Mayo 29, 2016, 19:12:16 »
Hay que escribir en D019 para limpiar la bandera de la interrupción. Si no, no funciona.
Pasa lo mismo que con los sprites creo recordar.

Si, creo que tenez razón. Me estaba confundiendo con limpiar los timers CIA.
Yo uso "ASL $D019" en vez de "LDA $D019; STA $D019", y me sirve también para saber si la IRQ fue generada por raster o no.
Viendo código viejo mio (el de los 90s), veo que también usaba el "LDA $D019; STA $D019;".

Maniako

  • Desarrolladores
  • Commodore Master
  • ******
  • Mensajes: 1008
  • SYS 8*4096
    • Ver Perfil
Re:Rutinas en CM mas o menos útiles
« Respuesta #21 en: Junio 12, 2016, 13:09:30 »
Despues de muchas pruebas con scroll de pantalla (sin scroll fino), he comprobado que al pobrecillo C64 le cuesta mucho esfuerzo mover 1000 caracteres de un sitio a otro.

Se pueden hacer rutinas cortas usando bucles, pero este modo crea frenos ya que hay que modificar valores, hacer comparaciones y saltar de nuevo para seguir trasladando caracteres.

Otra manera (para mi la mejor) es UNLOOP´ear XD. Riq me aconsejo sobre ello pero hasta que no hice pruebas, no me dí cuenta de lo que come en tiempo de proceso.

Aquí dejo tres ejemplos de código, uno con LOOPS y dos sin.
***********************************************************************
LOOPS:
Código: [Seleccionar]
;CBM prg STUDIO
;Scroll linea a linea . Solo mueve una linea cada vez que se llama.
;Intento de hacer scroll moviendo la linea que el raster acaba de mostrar
;para asi, aprovechar al máximo
;Lo le he puesto interrupciones por que aún es mas lento XD

; 10 SYS (4096)

*=$801

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


*=$1000
;
reset   lda #25
        sta ctrlinea
 
loop    ldx #39         ;#39 es el valor correcto

poke1   lda $0401
poke2   sta $0400
        jsr recoloca    ;Pasamos al siguiente caractera leer y pokear


pasa1   dex
        bne poke1
         
;Como es final de linea, dejamos lista la siguiente...
        lda poke2+1
        sta poke3+1
        lda poke2+2
        sta poke3+2
        lda $d012       ;Datos aleatorios tomados del raster
poke3   sta $0400       ;Y pokeados el final de la fila
       
       
        jsr recoloca    ;... deja lista la siguiente linea XD

;Una vez terminada la última linea de pantalla, puesta a cero de los vectores y vuelta a empezar.
;Puede ir fuera en la memoria normal. (fuera de la pag cero)
        dec ctrlinea
        bne fin
        lda #04
        sta poke1+2     ;HI
        sta poke2+2     ;HI
        lda #00
        sta poke2+1     ;LO
        lda #01
        sta poke1+1     ;LO
        jmp reset





fin     jmp loop        ;Deberia ser un RTS si la usas con JSR. En esta prueba
                        ;lo puse en loop continuo

;Rutina aumenta vectores de lectura/escritura de los caracteres de la linea.
recoloca
        inc poke1+1     ;LO
        bne pasa2
        inc poke1+2     ;HI
pasa2   inc poke2+1     ;LO
        bne pasa3
        inc poke2+2     ;HI
pasa3   rts


ctrlinea
*******************************************************************
UNLOOP:
Código: [Seleccionar]
;CBM prg STUDIO
;Esta forma es mucho mas rápida que un loop. Mucho mas.
; 10 SYS (4096)

*=$801

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

*=$1000

;Moviendo de der a izq.
main    ldx #01
        ldy #00

loop1   jsr move
        inx
        iny
        txa
        cmp #40
        beq fin

        jmp loop1

fin     jsr chars
;loop2   lda $d012       ;Bucle freno
;        bne loop2
        jmp main ;rts

;Rutina mover 8x8 pixels
move    ;X=Lectura. Y=Escritura.
        lda $0400,x
        sta $0400,y
        lda $0428,x
        sta $0428,y
        lda $0450,x
        sta $0450,y
        lda $0478,x
        sta $0478,y
        lda $04a0,x
        sta $04a0,y
        lda $04c8,x
        sta $04c8,y
        lda $04f0,x
        sta $04f0,y
        lda $0518,x
        sta $0518,y
        lda $0540,x
        sta $0540,y
        lda $0568,x
        sta $0568,y
        lda $0590,x
        sta $0590,y
        lda $05b8,x
        sta $05b8,y
        lda $05e0,x
        sta $05e0,y
        lda $0608,x
        sta $0608,y
        lda $0630,x
        sta $0630,y
        lda $0658,x
        sta $0658,y
        lda $0680,x
        sta $0680,y
        lda $06a8,x
        sta $06a8,y
        lda $06d0,x
        sta $06d0,y
        lda $06f8,x
        sta $06f8,y
        lda $0720,x
        sta $0720,y
        lda $0748,x
        sta $0748,y
        lda $0770,x
        sta $0770,y
        lda $0798,x
        sta $0798,y
        lda $07c0,x
        sta $07c0,y
        rts

;Rutina poner caracteres aleatorios a la derecha de la mantalla para ver como se desplaza
chars
        lda $d012
        sta $0427
        sta $044f
        sta $0477
        sta $049f
        sta $04c7
        sta $04ef
        sta $0517
        sta $053f
        sta $0567
        sta $058f
        sta $05b7
        sta $05df
        sta $0607
        sta $062f
        sta $0657
        sta $067f
        sta $06a7
        sta $06cf
        sta $06f7
        sta $071f
        sta $0747
        sta $076f
        sta $0797
        sta $07bf
        sta $07e7
        rts
**********************************************************************
UNLOOPS con IRQ:
Código: [Seleccionar]
;CBM prg STUDIO
;Pruebas de scroll de caracteres de la pantalla.El color negro es el tiempo que lleva
;ejecutar el desplazamiento de los caracteres un caracter hacia la izquierda.
;En lugar de desplazar la pantalla desde la misma interrupción, uso la interrupción para
;dar permiso al programa para desplazar los caracteres.
;No sé si me explico bién XD. Si es incorrecto hacerlo así,  no lo se, pero alargar el
;tiempo de la interrupción me parece incorrecto.
;De toda manera es un experimento para mejorar y aprender. A trastear señor@s.
;Si alguno averigua como acelerar esto aun más, que no se corte y lo diga. Grácias.
; 10 SYS (4096)

*=$801
 
        BYTE    $0E, $08, $0A, $00, $9E, $20, $28,  $34, $30, $39, $36, $29, $00, $00, $00

permiso=$FB     ;Usando pag cero para ahorrar ciclos (1) XD

*=$1000         ;Coloco el programa aquí para que no se desplace al
                ;entrar lineas de basic.

        jsr $ff81       ;Limpiar pantalla.
        sei             ;Desactivando interrupciones.                       
        lda #%00011011  ;27 original. 26 no flickea.Hibyte del raster pero                             
        sta $D011       ;si no es 27 aparecen "pelos" en los bordes pantalla.
        lda #<irq1                         
        sta $0314                           
        lda #>irq1                           
        sta $0315                           
        lda #%00000001  ;#127 en el ejemplo. Basta con activar el timer A #1     
        sta $DC0D       ;Registro control de la cia                   
        lda #1                             
        sta $D01A       ;Registro mascara IRQ activada. IRQ ON.
        cli             ;Conectando interrupciones.
        lda #230        ;#230 Linea del raster que activara el movimiento scroll
        sta $d012
        jsr random      ;Activa el SID para generar numeros aleatorios

main
        lda permiso     ;Tengo permiso para scroll?
        beq main        ;No, pues a esperar...
        ldx #02    ;De derecha a izq, no hace falta dibujar el ultimo caracter
        ldy #01    ;ya que queda por detras de el marco en pantalla de 38 caracteres.

        lda #0          ;Color negro para visionar tiempo
        sta $d020       ;es borrable 100% y ganamos ciclos.
loop1
        jsr move        ;Moviendo toda una columna
        inx
        iny
        cpx #40
        beq fin
        jmp loop1
fin
        jsr newchars
        lda #2          ;Color rojo para visionar tiempo
        sta $d020       ;Es borrable 100% y ganamos ciclos.
        lda #0          ;Desconectando el scroll .
        sta permiso
        jmp main        ;Vuelta al ruedo XD
irq1     
        asl $D019       ;Reset IRQ.ASL es consejo de Riq.Si no, se queda activado y falla.
        bcc salt0       ;Acarreo OFF? Salt0
sigue
        lda #1          ;Activando scroll desde las interrupciones para que se
        sta permiso     ;ejecuten fuera de las mismas.
        jmp $EA81       ;FEBC ;Saltar a restaurar a partir de la rutina NMI.
salt0
        jmp $EA7b ;$EA31       ;Rutina interrupcion normal Leer teclado, cursor y demás.     


;Rutina mover un caracter a la izq. Se puede usar en ambas direcciones jugando
;con X e Y.

move    ;X=Lectura. Y=Escritura.
;Aqui estan desconectadas las lineas que no interesan.
;Conectad y desconectad a placer para experimetar.
;Podreis ver lo que llega a consumir el mover 1000 caracteres.

;        lda $0400,x    ;Primera linea
;        sta $0400,y    ;Primera linea
        lda $0428,x     ;Segunda linea
        sta $0428,y     ;Segunda linea
        lda $0450,x     ;Tercera linea
        sta $0450,y     ;Tercera linea
        lda $0478,x     ;etc...
        sta $0478,y
        lda $04a0,x
        sta $04a0,y
        lda $04c8,x
        sta $04c8,y
        lda $04f0,x
        sta $04f0,y
        lda $0518,x
        sta $0518,y
        lda $0540,x
        sta $0540,y
        lda $0568,x
        sta $0568,y
        lda $0590,x
        sta $0590,y
        lda $05b8,x
        sta $05b8,y
        lda $05e0,x
        sta $05e0,y
        lda $0608,x
        sta $0608,y
        lda $0630,x
        sta $0630,y
        lda $0658,x
        sta $0658,y
        lda $0680,x
        sta $0680,y
        lda $06a8,x
        sta $06a8,y
        lda $06d0,x
        sta $06d0,y
        lda $06f8,x
        sta $06f8,y
        lda $0720,x
        sta $0720,y
        lda $0748,x
        sta $0748,y
        lda $0770,x
        sta $0770,y
 ;       lda $0798,x
 ;       sta $0798,y
 ;       lda $07c0,x
 ;       sta $07c0,y
        rts

;Rutina poner caracteres aleatorios a la derecha de la pantalla para ver como se desplaza.
newchars

;Leer valor aleatorio creado por el SID. Esto seria el siguiente caracter a mostrar del
;nivel del juego que andeis haciendo. Yo uso basura para ahorrar trabajo durante las pruebas XD
        LDA $D41B       ;Leyendo random del SID       
;Aqui estan desconectadas las lineas que no interesan.
;Conectad y desconectad a placer para experimentar.
;        sta $0427      ;Primera linea.
        sta $044f       ;Segunda linea.
        sta $0477       ;Tercera linea.
        sta $049f       ;etc...
        sta $04c7
        sta $04ef
        sta $0517
        sta $053f
        sta $0567
        sta $058f
        sta $05b7
        sta $05df
        sta $0607
        sta $062f
        sta $0657
        sta $067f
        sta $06a7
        sta $06cf
        sta $06f7
        sta $071f
        sta $0747
        sta $076f
        sta $0797
;        sta $07bf
;        sta $07e7
        rts

;Activar random usando el SID

random  LDA #$FF  ; maximum frequency value
        STA $D40E ; voice 3 frequency low byte
        STA $D40F ; voice 3 frequency high byte
        LDA #$80  ; noise waveform, gate bit off
        STA $D412 ; voice 3 control register
        RTS





Como podeis ver, sin loops hace que el programa crezca en tamaño, pero la velocidad bién lo vale.

Dejo los programas ya compilados para que podais abrirlos todos a la vez y apreciar la gran diferencia. Lo interesante es la que usa IRQ, mover la pantalla sin deformidades es esencial para cualquier juego y para eso, hay que moverla cuando el barrido de pantalla no esté un la "zona visual".

Si se desea mover toda la pantalla, se pueden usar técnicas de doble buffer como la descrita en este link:

http://1amstudios.com/2014/12/07/c64-smooth-scrolling/

En este otro link en el parrafo  Loop Unrolling hay una explicación con calculos de tiempo de procesos que lo deja bien claro.

http://www.antimon.org/code/Linus/demo_prog.html#SECTION000121000000000000000

Pero hasta que no haga pruebas con el double buffering, no comento XD.

Espero que os sea útil y didactico. Mi intención es incentivaros a trastear en CM y echar una mano para aprender comprendiendo, para mí algo esencial.
« última modificación: Junio 12, 2016, 13:19:29 por Maniako »
LDA #$50
STA $0400
RTS
Lloré cuando conseguí hacer esto con el monitor del FC1.

josepzin

  • Administrador
  • Commodore Master
  • *****
  • Mensajes: 13628
  • Commodoreador web
    • Ver Perfil
    • Mi blog
Re:Rutinas en CM mas o menos útiles
« Respuesta #22 en: Junio 12, 2016, 15:01:49 »
¿El último parece ser el que va mejor no?
www.retroinvaders.com | www.commodoreplus.org  | josepzin.blogspot.com

Maniako

  • Desarrolladores
  • Commodore Master
  • ******
  • Mensajes: 1008
  • SYS 8*4096
    • Ver Perfil
Re:Rutinas en CM mas o menos útiles
« Respuesta #23 en: Junio 12, 2016, 15:14:58 »
Se ve mejor por que uso las IRQ para que no haga extraños , no como en el segundo ejemplo UNLOOP que no usa interrupciones y se ven los flicks. Va más deprisa moviendo pero se vé mal.


LDA #$50
STA $0400
RTS
Lloré cuando conseguí hacer esto con el monitor del FC1.

Maniako

  • Desarrolladores
  • Commodore Master
  • ******
  • Mensajes: 1008
  • SYS 8*4096
    • Ver Perfil
Re:Rutinas en CM mas o menos útiles
« Respuesta #24 en: Junio 12, 2016, 23:58:10 »
Yastoyotravez.

Una vez le vas cogiendo el gusanillo a programar, cuesta dejarlo.
Reconozco que me ha costado arrancar y recordar métodos y demás técnicas para crear los programas.

Aquí dejo otra pequeña rutina donde muevo un mapa de 64 caractéres, del 0 al 63.
Uso un tamaño de mapa que me premita controlar los limites con un simple AND#63, de esta manera consigues devolver a 0 el vector de lectura del mapa.

Basta de rollos, aquí dejo la rutina para que la destripeís y la mejoreís ahí donde no llego o no veo.

Código: [Seleccionar]
;CBM prg STUDIO
;Scroll de una pantalla de 64 caracteres (0-63) en multicolor.
;Sin scroll fino. Solo probando tamaños de mapas para futuras pantallas de 127 o 256
;caracteres.
;En $3800 estan los caracteres programables
;En $4000 el mapa en sí.
;Para encontrar el principio de cada linea, solo hay que ir sumandole #64 cada
;vez para poder leerla sin problemas.
;He escogido este tamaño para con simplemente un AND poder controlar el bucle sin fin.
;El mapa y los caracteres se han editado con VChar64 0.013. Muy practica.
;La proxima le meto scroll fino y a la siguiente, moverse en ambas direcciones en el eje X.

; 10 SYS4096

*=$0801

        BYTE    $0B, $08, $0A, $00, $9E, $34, $30, $39, $36, $00, $00, $00

vectscroll byte $00     ;Vector de lectura para el mapa.

*=$1000
        jsr $ff81       ;Limpiar pantala
        lda #15+16      ;Cambio vector punteros programables $3800
        sta $D018       ; #53272
 
        lda $d016       ;Multicolor ON
        ora #16
        sta $d016       ; #53270

        lda #0          ;Fondo negro

        sta $d021
        lda #9          ;Color 1 marrón
        sta $d022       ;#53282

        lda #13         ;Color 2 verde claro
        sta $d023       ;#53283

        lda #5         ;Verde coscuro
        sta $d800       ;#55296

;Ram de color. Solo una vez ya que no altero su valor.
        lda #13
        ldx #39
buc4    sta $da08,x     
        sta $da30,x     
        sta $da58,x     
        sta $da80,x     
        sta $daa8,x     
        sta $dad0,x     
        sta $daf8,x     
        sta $db20,x     
        sta $db48,x     
        sta $db70,x
        dex
        bpl buc4

loop2   ldy vectscroll  ;Se va sumando hasta llegar al final del mapa y vuelta a empezar
        ldx #0 ;Escritura en ram de pantalla.
loop1
;Ram pantalla
        lda $4000,y
        sta $0608,x
        lda $4040,y
        sta $0630,x
        lda $4080,y
        sta $0658,x
        lda $40c0,y
        sta $0680,x
        lda $4100,y
        sta $06a8,x
        lda $4140,y
        sta $06d0,x
        lda $4180,y
        sta $06f8,x
        lda $41c0,y
        sta $0720,x
        lda $4200,y
        sta $0748,x
        lda $4240,y
        sta $0770,x

        iny             ;Al registro Y lo pongo a cero cuando llega al final del mapa
        tya             ;y así, empieza a leer desde el principio otra vez.
        and #63         
        tay

        inx
        cpx #40         ;He llegado al final de la pantalla?
        bne loop1       ;No, pues a seguir

        inc vectscroll  ;Como he llegado al final, incremento el vector de lectura
        lda vectscroll  ;Y le hago un AND 63 para devolverlo a 0
        and #63        ;si es mayor que 63
        sta vectscroll  ;y lo guardo.

pasa0   lda $d012       ;Bucle de raster.
        bne pasa0       ;para frenar esto un poco y eliminar flick sin usar interrupciones de la manera clasica XD
        jmp loop2

*=$3800 ;Caracteres programables.
          BYTE $3C,$66,$6E,$6E,$60,$62,$3C,$00,$18,$3C,$66,$7E,$66,$66,$66,$00,$7C,$66
          BYTE $66,$7C,$66,$66,$7C,$00,$3C,$66,$60,$60,$60,$66,$3C,$00,$78,$6C,$66,$66,$66,$6C
          BYTE $78,$00,$7E,$60,$60,$78,$60,$60,$7E,$00,$7E,$60,$60,$78,$60,$60,$60,$00,$3C,$66
          BYTE $60,$6E,$66,$66,$3C,$00,$66,$66,$66,$7E,$66,$66,$66,$00,$3C,$18,$18,$18,$18,$18
          BYTE $3C,$00,$1E,$0C,$0C,$0C,$0C,$6C,$38,$00,$66,$6C,$78,$70,$78,$6C,$66,$00,$60,$60
          BYTE $60,$60,$60,$60,$7E,$00,$63,$77,$7F,$6B,$63,$63,$63,$00,$66,$76,$7E,$7E,$6E,$66
          BYTE $66,$00,$3C,$66,$66,$66,$66,$66,$3C,$00,$7C,$66,$66,$7C,$60,$60,$60,$00,$3C,$66
          BYTE $66,$66,$66,$3C,$0E,$00,$7C,$66,$66,$7C,$78,$6C,$66,$00,$3C,$66,$60,$3C,$06,$66
          BYTE $3C,$00,$7E,$18,$18,$18,$18,$18,$18,$00,$66,$66,$66,$66,$66,$66,$3C,$00,$66,$66
          BYTE $66,$66,$66,$3C,$18,$00,$63,$63,$63,$6B,$7F,$77,$63,$00,$66,$66,$3C,$18,$3C,$66
          BYTE $66,$00,$66,$66,$66,$3C,$18,$18,$18,$00,$7E,$06,$0C,$18,$30,$60,$7E,$00,$3C,$30
          BYTE $30,$30,$30,$30,$3C,$00,$0C,$12,$30,$7C,$30,$62,$FC,$00,$3C,$0C,$0C,$0C,$0C,$0C
          BYTE $3C,$00,$00,$18,$3C,$7E,$18,$18,$18,$18,$00,$10,$30,$7F,$7F,$30,$10,$00,$00,$00
          BYTE $00,$00,$00,$00,$00,$00,$18,$18,$18,$18,$00,$00,$18,$00,$66,$66,$66,$00,$00,$00
          BYTE $00,$00,$66,$66,$FF,$66,$FF,$66,$66,$00,$18,$3E,$60,$3C,$06,$7C,$18,$00,$62,$66
          BYTE $0C,$18,$30,$66,$46,$00,$3C,$66,$3C,$38,$67,$66,$3F,$00,$06,$0C,$18,$00,$00,$00
          BYTE $00,$00,$0C,$18,$30,$30,$30,$18,$0C,$00,$30,$18,$0C,$0C,$0C,$18,$30,$00,$00,$66
          BYTE $3C,$FF,$3C,$66,$00,$00,$00,$18,$18,$7E,$18,$18,$00,$00,$00,$00,$00,$00,$00,$18
          BYTE $18,$30,$00,$00,$00,$7E,$00,$00,$00,$00,$00,$00,$00,$00,$00,$18,$18,$00,$00,$03
          BYTE $06,$0C,$18,$30,$60,$00,$3C,$66,$6E,$76,$66,$66,$3C,$00,$18,$18,$38,$18,$18,$18
          BYTE $7E,$00,$3C,$66,$06,$0C,$30,$60,$7E,$00,$3C,$66,$06,$1C,$06,$66,$3C,$00,$06,$0E
          BYTE $1E,$66,$7F,$06,$06,$00,$7E,$60,$7C,$06,$06,$66,$3C,$00,$3C,$66,$60,$7C,$66,$66
          BYTE $3C,$00,$7E,$66,$0C,$18,$18,$18,$18,$00,$3C,$66,$66,$3C,$66,$66,$3C,$00,$3C,$66
          BYTE $66,$3E,$06,$66,$3C,$00,$00,$00,$18,$00,$00,$18,$00,$00,$00,$00,$18,$00,$00,$18
          BYTE $18,$30,$0E,$18,$30,$60,$30,$18,$0E,$00,$00,$00,$7E,$00,$7E,$00,$00,$00,$70,$18
          BYTE $0C,$06,$0C,$18,$70,$00,$3C,$66,$06,$0C,$18,$00,$18,$00,$EF,$FE,$55,$55,$55,$55
          BYTE $55,$55,$55,$55,$55,$55,$55,$55,$55,$55,$03,$03,$03,$03,$03,$03,$03,$03,$C0,$C0
          BYTE $C0,$C0,$C0,$C0,$C0,$C0,$FE,$BF,$FB,$EF,$BD,$75,$55,$55,$BE,$FB,$BF,$FB,$7E,$5F
          BYTE $55,$55,$00,$03,$0D,$0D,$35,$35,$35,$D5,$C0,$F0,$F0,$70,$7C,$57,$57,$57,$5F,$5F
          BYTE $5F,$5C,$5C,$7C,$7C,$FC,$00,$00,$00,$E0,$F0,$38,$18,$18,$18,$18,$1C,$0F,$07,$00
          BYTE $00,$00,$18,$18,$38,$F0,$E0,$00,$00,$00,$C0,$C0,$C0,$C0,$C0,$C0,$FF,$FF,$C0,$E0
          BYTE $70,$38,$1C,$0E,$07,$03,$03,$07,$0E,$1C,$38,$70,$E0,$C0,$FF,$FF,$C0,$C0,$C0,$C0
          BYTE $C0,$C0,$FF,$FF,$03,$03,$03,$03,$03,$03,$00,$3C,$7E,$7E,$7E,$7E,$3C,$00,$00,$00
          BYTE $00,$00,$00,$FF,$FF,$00,$36,$7F,$7F,$7F,$3E,$1C,$08,$00,$60,$60,$60,$60,$60,$60
          BYTE $60,$60,$00,$00,$00,$07,$0F,$1C,$18,$18,$C3,$E7,$7E,$3C,$3C,$7E,$E7,$C3,$00,$3C
          BYTE $7E,$66,$66,$7E,$3C,$00,$18,$18,$66,$66,$18,$18,$3C,$00,$06,$06,$06,$06,$06,$06
          BYTE $06,$06,$08,$1C,$3E,$7F,$3E,$1C,$08,$00,$18,$18,$18,$FF,$FF,$18,$18,$18,$C0,$C0
          BYTE $30,$30,$C0,$C0,$30,$30,$18,$18,$18,$18,$18,$18,$18,$18,$00,$00,$03,$3E,$76,$36
          BYTE $36,$00,$FF,$7F,$3F,$1F,$0F,$07,$03,$01,$00,$00,$00,$00,$00,$00,$00,$00,$F0,$F0
          BYTE $F0,$F0,$F0,$F0,$F0,$F0,$00,$00,$00,$00,$FF,$FF,$FF,$FF,$FF,$00,$00,$00,$00,$00
          BYTE $00,$00,$00,$00,$00,$00,$00,$00,$00,$FF,$C0,$C0,$C0,$C0,$C0,$C0,$C0,$C0,$CC,$CC
          BYTE $33,$33,$CC,$CC,$33,$33,$03,$03,$03,$03,$03,$03,$03,$03,$00,$00,$00,$00,$CC,$CC
          BYTE $33,$33,$FF,$FE,$FC,$F8,$F0,$E0,$C0,$80,$03,$03,$03,$03,$03,$03,$03,$03,$18,$18
          BYTE $18,$1F,$1F,$18,$18,$18,$00,$00,$00,$00,$0F,$0F,$0F,$0F,$18,$18,$18,$1F,$1F,$00
          BYTE $00,$00,$00,$00,$00,$F8,$F8,$18,$18,$18,$00,$00,$00,$00,$00,$00,$FF,$FF,$00,$00
          BYTE $00,$1F,$1F,$18,$18,$18,$18,$18,$18,$FF,$FF,$00,$00,$00,$00,$00,$00,$FF,$FF,$18
          BYTE $18,$18,$18,$18,$18,$F8,$F8,$18,$18,$18,$C0,$C0,$C0,$C0,$C0,$C0,$C0,$C0,$E0,$E0
          BYTE $E0,$E0,$E0,$E0,$E0,$E0,$07,$07,$07,$07,$07,$07,$07,$07,$FF,$FF,$00,$00,$00,$00
          BYTE $00,$00,$FF,$FF,$FF,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$FF,$FF,$FF,$03,$03
          BYTE $03,$03,$03,$03,$FF,$FF,$00,$00,$00,$00,$F0,$F0,$F0,$F0,$0F,$0F,$0F,$0F,$00,$00
          BYTE $00,$00,$18,$18,$18,$F8,$F8,$00,$00,$00,$F0,$F0,$F0,$F0,$00,$00,$00,$00,$F0,$F0
          BYTE $F0,$F0,$0F,$0F,$0F,$0F,$C3,$99,$91,$91,$9F,$99,$C3,$FF,$E7,$C3,$99,$81,$99,$99
          BYTE $99,$FF,$83,$99,$99,$83,$99,$99,$83,$FF,$C3,$99,$9F,$9F,$9F,$99,$C3,$FF,$87,$93
          BYTE $99,$99,$99,$93,$87,$FF,$81,$9F,$9F,$87,$9F,$9F,$81,$FF,$81,$9F,$9F,$87,$9F,$9F
          BYTE $9F,$FF,$C3,$99,$9F,$91,$99,$99,$C3,$FF,$99,$99,$99,$81,$99,$99,$99,$FF,$C3,$E7
          BYTE $E7,$E7,$E7,$E7,$C3,$FF,$E1,$F3,$F3,$F3,$F3,$93,$C7,$FF,$99,$93,$87,$8F,$87,$93
          BYTE $99,$FF,$9F,$9F,$9F,$9F,$9F,$9F,$81,$FF,$9C,$88,$80,$94,$9C,$9C,$9C,$FF,$99,$89
          BYTE $81,$81,$91,$99,$99,$FF,$C3,$99,$99,$99,$99,$99,$C3,$FF,$83,$99,$99,$83,$9F,$9F
          BYTE $9F,$FF,$C3,$99,$99,$99,$99,$C3,$F1,$FF,$83,$99,$99,$83,$87,$93,$99,$FF,$C3,$99
          BYTE $9F,$C3,$F9,$99,$C3,$FF,$81,$E7,$E7,$E7,$E7,$E7,$E7,$FF,$99,$99,$99,$99,$99,$99
          BYTE $C3,$FF,$99,$99,$99,$99,$99,$C3,$E7,$FF,$9C,$9C,$9C,$94,$80,$88,$9C,$FF,$99,$99
          BYTE $C3,$E7,$C3,$99,$99,$FF,$99,$99,$99,$C3,$E7,$E7,$E7,$FF,$81,$F9,$F3,$E7,$CF,$9F
          BYTE $81,$FF,$C3,$CF,$CF,$CF,$CF,$CF,$C3,$FF,$F3,$ED,$CF,$83,$CF,$9D,$03,$FF,$C3,$F3
          BYTE $F3,$F3,$F3,$F3,$C3,$FF,$FF,$E7,$C3,$81,$E7,$E7,$E7,$E7,$FF,$EF,$CF,$80,$80,$CF
          BYTE $EF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$E7,$E7,$E7,$E7,$FF,$FF,$E7,$FF,$99,$99
          BYTE $99,$FF,$FF,$FF,$FF,$FF,$99,$99,$00,$99,$00,$99,$99,$FF,$E7,$C1,$9F,$C3,$F9,$83
          BYTE $E7,$FF,$9D,$99,$F3,$E7,$CF,$99,$B9,$FF,$C3,$99,$C3,$C7,$98,$99,$C0,$FF,$F9,$F3
          BYTE $E7,$FF,$FF,$FF,$FF,$FF,$F3,$E7,$CF,$CF,$CF,$E7,$F3,$FF,$CF,$E7,$F3,$F3,$F3,$E7
          BYTE $CF,$FF,$FF,$99,$C3,$00,$C3,$99,$FF,$FF,$FF,$E7,$E7,$81,$E7,$E7,$FF,$FF,$FF,$FF
          BYTE $FF,$FF,$FF,$E7,$E7,$CF,$FF,$FF,$FF,$81,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$E7
          BYTE $E7,$FF,$FF,$FC,$F9,$F3,$E7,$CF,$9F,$FF,$C3,$99,$91,$89,$99,$99,$C3,$FF,$E7,$E7
          BYTE $C7,$E7,$E7,$E7,$81,$FF,$C3,$99,$F9,$F3,$CF,$9F,$81,$FF,$C3,$99,$F9,$E3,$F9,$99
          BYTE $C3,$FF,$F9,$F1,$E1,$99,$80,$F9,$F9,$FF,$81,$9F,$83,$F9,$F9,$99,$C3,$FF,$C3,$99
          BYTE $9F,$83,$99,$99,$C3,$FF,$81,$99,$F3,$E7,$E7,$E7,$E7,$FF,$C3,$99,$99,$C3,$99,$99
          BYTE $C3,$FF,$C3,$99,$99,$C1,$F9,$99,$C3,$FF,$FF,$FF,$E7,$FF,$FF,$E7,$FF,$FF,$FF,$FF
          BYTE $E7,$FF,$FF,$E7,$E7,$CF,$F1,$E7,$CF,$9F,$CF,$E7,$F1,$FF,$FF,$FF,$81,$FF,$81,$FF
          BYTE $FF,$FF,$8F,$E7,$F3,$F9,$F3,$E7,$8F,$FF,$C3,$99,$F9,$F3,$E7,$FF,$E7,$FF,$FF,$FF
          BYTE $FF,$00,$00,$FF,$FF,$FF,$F7,$E3,$C1,$80,$80,$E3,$C1,$FF,$E7,$E7,$E7,$E7,$E7,$E7
          BYTE $E7,$E7,$FF,$FF,$FF,$00,$00,$FF,$FF,$FF,$FF,$FF,$00,$00,$FF,$FF,$FF,$FF,$FF,$00
          BYTE $00,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$00,$00,$FF,$FF,$CF,$CF,$CF,$CF,$CF,$CF
          BYTE $CF,$CF,$F3,$F3,$F3,$F3,$F3,$F3,$F3,$F3,$FF,$FF,$FF,$1F,$0F,$C7,$E7,$E7,$E7,$E7
          BYTE $E3,$F0,$F8,$FF,$FF,$FF,$E7,$E7,$C7,$0F,$1F,$FF,$FF,$FF,$3F,$3F,$3F,$3F,$3F,$3F
          BYTE $00,$00,$3F,$1F,$8F,$C7,$E3,$F1,$F8,$FC,$FC,$F8,$F1,$E3,$C7,$8F,$1F,$3F,$00,$00
          BYTE $3F,$3F,$3F,$3F,$3F,$3F,$00,$00,$FC,$FC,$FC,$FC,$FC,$FC,$FF,$C3,$81,$81,$81,$81
          BYTE $C3,$FF,$FF,$FF,$FF,$FF,$FF,$00,$00,$FF,$C9,$80,$80,$80,$C1,$E3,$F7,$FF,$9F,$9F
          BYTE $9F,$9F,$9F,$9F,$9F,$9F,$FF,$FF,$FF,$F8,$F0,$E3,$E7,$E7,$3C,$18,$81,$C3,$C3,$81
          BYTE $18,$3C,$FF,$C3,$81,$99,$99,$81,$C3,$FF,$E7,$E7,$99,$99,$E7,$E7,$C3,$FF,$F9,$F9
          BYTE $F9,$F9,$F9,$F9,$F9,$F9,$F7,$E3,$C1,$80,$C1,$E3,$F7,$FF,$E7,$E7,$E7,$00,$00,$E7
          BYTE $E7,$E7,$3F,$3F,$CF,$CF,$3F,$3F,$CF,$CF,$E7,$E7,$E7,$E7,$E7,$E7,$E7,$E7,$FF,$FF
          BYTE $FC,$C1,$89,$C9,$C9,$FF,$00,$80,$C0,$E0,$F0,$F8,$FC,$FE,$FF,$FF,$FF,$FF,$FF,$FF
          BYTE $FF,$FF,$0F,$0F,$0F,$0F,$0F,$0F,$0F,$0F,$FF,$FF,$FF,$FF,$00,$00,$00,$00,$00,$FF
          BYTE $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$00,$3F,$3F,$3F,$3F,$3F,$3F
          BYTE $3F,$3F,$33,$33,$CC,$CC,$33,$33,$CC,$CC,$FC,$FC,$FC,$FC,$FC,$FC,$FC,$FC,$FF,$FF
          BYTE $FF,$FF,$33,$33,$CC,$CC,$00,$01,$03,$07,$0F,$1F,$3F,$7F,$FC,$FC,$FC,$FC,$FC,$FC
          BYTE $FC,$FC,$E7,$E7,$E7,$E0,$E0,$E7,$E7,$E7,$FF,$FF,$FF,$FF,$F0,$F0,$F0,$F0,$E7,$E7
          BYTE $E7,$E0,$E0,$FF,$FF,$FF,$FF,$FF,$FF,$07,$07,$E7,$E7,$E7,$FF,$FF,$FF,$FF,$FF,$FF
          BYTE $00,$00,$FF,$FF,$FF,$E0,$E0,$E7,$E7,$E7,$E7,$E7,$E7,$00,$00,$FF,$FF,$FF,$FF,$FF
          BYTE $FF,$00,$00,$E7,$E7,$E7,$E7,$E7,$E7,$07,$07,$E7,$E7,$E7,$3F,$3F,$3F,$3F,$3F,$3F
          BYTE $3F,$3F,$1F,$1F,$1F,$1F,$1F,$1F,$1F,$1F,$F8,$F8,$F8,$F8,$F8,$F8,$F8,$F8,$00,$00
          BYTE $FF,$FF,$FF,$FF,$FF,$FF,$00,$00,$00,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$00
          BYTE $00,$00,$FC,$FC,$FC,$FC,$FC,$FC,$00,$00,$FF,$FF,$FF,$FF,$0F,$0F,$0F,$0F,$F0,$F0
          BYTE $F0,$F0,$FF,$FF,$FF,$FF,$E7,$E7,$E7,$07,$07,$FF,$FF,$FF,$0F,$0F,$0F,$0F,$FF,$FF
          BYTE $FF,$FF,$0F,$0F,$0F,$0F,$F0,$F0,$F0,$F0
 

*=$4000 ;Mapa a mostrar 63x10 caracteres

          BYTE $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20
          BYTE $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20
          BYTE $20,$20,$20,$20,$20,$20,$20,$20,$46,$45,$44,$47,$20,$20,$20,$20,$20,$20,$20,$20
          BYTE $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20
          BYTE $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20
          BYTE $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$46,$41,$41,$41,$41,$47,$20,$20,$20
          BYTE $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20
          BYTE $20,$20,$20,$20,$20,$46,$44,$47,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20
          BYTE $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$46,$41,$41,$41,$41,$41
          BYTE $41,$47,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20
          BYTE $20,$20,$20,$20,$20,$20,$20,$20,$42,$41,$41,$41,$47,$20,$20,$20,$20,$20,$20,$20
          BYTE $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$46,$41,$41
          BYTE $41,$41,$41,$41,$41,$41,$47,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20
          BYTE $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$46,$40,$41,$41,$41,$48,$20,$20,$20
          BYTE $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20
          BYTE $46,$41,$41,$41,$41,$41,$41,$41,$41,$41,$41,$47,$20,$20,$20,$20,$20,$20,$20,$20
          BYTE $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$42,$41,$41,$41,$41,$48
          BYTE $20,$20,$20,$20,$20,$20,$20,$46,$45,$47,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20
          BYTE $20,$20,$20,$46,$41,$41,$41,$41,$41,$41,$41,$41,$44,$44,$44,$44,$44,$44,$47,$20
          BYTE $20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$46,$40,$40,$41
          BYTE $41,$41,$48,$20,$20,$20,$20,$20,$20,$20,$46,$41,$41,$41,$47,$20,$20,$20,$46,$40
          BYTE $47,$20,$20,$20,$20,$20,$42,$41,$41,$41,$41,$41,$41,$41,$41,$41,$41,$41,$41,$41
          BYTE $41,$41,$48,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$42
          BYTE $41,$41,$41,$41,$41,$48,$20,$20,$20,$20,$20,$20,$46,$40,$41,$41,$41,$41,$41,$47
          BYTE $20,$46,$41,$41,$41,$47,$20,$20,$20,$20,$46,$41,$41,$41,$41,$41,$41,$41,$41,$41
          BYTE $41,$41,$41,$41,$41,$41,$47,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20,$20
          BYTE $20,$20,$20,$42,$41,$41,$41,$41,$41,$47,$20,$20,$20,$20,$20,$46,$41,$41,$41,$41
          BYTE $41,$41,$41,$41,$44,$41,$41,$41,$41,$41,$47,$20,$20,$46,$41,$41,$41,$41,$41,$41
          BYTE $41,$41,$41,$41,$41,$41,$41,$41,$41,$41,$41,$47,$20,$20,$20,$20,$20,$20,$44,$45
          BYTE $44,$45,$44,$44,$44,$45,$44,$45,$44,$45,$44,$45,$44,$45,$44,$45,$44,$44,$44,$45
          BYTE $44,$45,$45,$45,$44,$45,$44,$45,$44,$45,$44,$44,$45,$45,$44,$45,$44,$44,$44,$45
          BYTE $44,$45,$44,$45,$44,$45,$44,$45,$45,$45,$44,$45,$44,$45,$44,$45,$44,$45,$44,$45
          BYTE $44,$45

Seguiré colgando mis avances. Espero que le sea util a alguién XD
« última modificación: Junio 13, 2016, 00:00:51 por Maniako »
LDA #$50
STA $0400
RTS
Lloré cuando conseguí hacer esto con el monitor del FC1.

Maniako

  • Desarrolladores
  • Commodore Master
  • ******
  • Mensajes: 1008
  • SYS 8*4096
    • Ver Perfil
Re:Rutinas en CM mas o menos útiles
« Respuesta #25 en: Junio 14, 2016, 10:37:22 »
Solo hace algo raro cuando provocas un ?syntax error, se "clava" un poco y vuelve a la normalidad. Después, por muchos ?Syntax error que hagas, ni se inmuta.


He leido que eso lo hace al recolocar la memoria basic, al parecer reclama espacio. No se el por qué si ya sabe el tamaño de la única linea de basic.
LDA #$50
STA $0400
RTS
Lloré cuando conseguí hacer esto con el monitor del FC1.

Dashiad

  • Commodoremaníaco
  • ****
  • Mensajes: 160
  • SYS 0
    • Ver Perfil
Re:Rutinas en CM mas o menos útiles
« Respuesta #26 en: Junio 14, 2016, 11:33:46 »
Maniako,
Comentas que:
Citar
Lo interesante es la que usa IRQ, mover la pantalla sin deformidades es esencial para cualquier juego y para eso, hay que moverla cuando el barrido de pantalla no esté un la "zona visual".
Corrigeme si me equivoco: lo que no debe pasar, es que el raster intercepte una zona de la pantalla que se está cambiando en ese momento, cierto?
Es decir, si hablamos de caracteres: una vez que el raster ha pasado por la primera fila de caracteres, debería ser posible cambiarla sin que hubiera flicker. Mientras el raster no "alcance" a nuestro código, y nuestro código no "adelante" al raster, no debería haber problemas..
O sea, si se pusiera 1 interrupción en cada badline a partir de la primera, en esa interrupción se podría repintar los caracteres de la línea anterior.
Si esto es así, el tiempo disponible para repintar la pantalla, no es sólo el tiempo en el que el raster está en el borde, sino cualquier momento, siempre que el raster ni adelante, ni alcance al código..
Es esto así?

Maniako

  • Desarrolladores
  • Commodore Master
  • ******
  • Mensajes: 1008
  • SYS 8*4096
    • Ver Perfil
Re:Rutinas en CM mas o menos útiles
« Respuesta #27 en: Junio 14, 2016, 12:44:12 »
Maniako,
Comentas que:Corrigeme si me equivoco: lo que no debe pasar, es que el raster intercepte una zona de la pantalla que se está cambiando en ese momento, cierto?

Exacto. una vez el raster ha pasado la zona en la que deseas que haya cambios, los haces.

Es decir, si hablamos de caracteres: una vez que el raster ha pasado por la primera fila de caracteres, debería ser posible cambiarla sin que hubiera flicker. Mientras el raster no "alcance" a nuestro código, y nuestro código no "adelante" al raster, no debería haber problemas..

Eso seria lo ideal, pero la rutina que uses en ese intervalo de linea, no debe durar más tiempo que hasta la siguiente linea que vayas a cambiar.
Si tu rutina de movimiento consume 9 o más lineas del raster, a la siguiénte interrupción para movel la siguiente linea (8 lineas) ya no lllegas a tiempo y empiezan los fallos.

O sea, si se pusiera 1 interrupción en cada badline a partir de la primera, en esa interrupción se podría repintar los caracteres de la línea anterior.

El tiempo disponible hasta la siguiente linea a mover es el límite.
En la rutina de arcoirirs, se ve perfecta por que no hago más que cambiar el color Se podria poner toda la pantalla a barras , queda bonito, pero ya se captaba lo que queria compartir.
Tengo pendiente algo como lo que comentas pero como experimento.
Prefiero aprender a usar el doble bufer, una segunda pantalla donde aplicar los cambios según donde tengas el scroll fino. Tengo que leermelo más y probarlo.

Si esto es así, el tiempo disponible para repintar la pantalla, no es sólo el tiempo en el que el raster está en el borde, sino cualquier momento, siempre que el raster ni adelante, ni alcance al código..
Es esto así?

Si , correcto. Hay gente que hace maravillas y me encantaria llegar a ese nivel ;)
Hasta que no empecé con las interrupciones no me dí cuenta de lo importante que es el optimizar el código al máximo y contar los ciclos .

De todas maneras no soy un gurú en estas lides. llevo bastante tiempo documentandome y revisando códigos para encontrar como funcionan. No me gusta poner código sin entender para qué sirve.

Gracias a Riq, empece a enterarme un poco de como funcionaban realmente.
« última modificación: Junio 14, 2016, 12:58:21 por Maniako »
LDA #$50
STA $0400
RTS
Lloré cuando conseguí hacer esto con el monitor del FC1.

Maniako

  • Desarrolladores
  • Commodore Master
  • ******
  • Mensajes: 1008
  • SYS 8*4096
    • Ver Perfil
Re:Rutinas en CM mas o menos útiles
« Respuesta #28 en: Junio 15, 2016, 22:40:41 »
Por fin con algo de tiempo libre.
Me he puesto a hacer pruebas aprovechando la rutina de arcoiris para que podais comprobar los efectos de pasarse en tiempo entre las interrupciones y tratar de hacer más comprensible el "misterio" las IRQ.

Código: [Seleccionar]

;CMB prg STUDIO
; 10 SYS36864

*=$801

        BYTE    $0B, $08, $0A, $00, $9E, $33, $36, $38, $36, $34, $00, $00, $00


*=$9000         ;Coloco el programa aquí para que no se desplace al
                ;entrar lineas de basic.
vector=vect
        ldx #0
        stx vector
        jsr $ff81        ;Limpiar pantalla

        sei                                   
        lda #%00011011  ;27 original. 26 no flickea.Hibyte del raster pero                             
        sta $D011       ;si no es 27 aparecen "pelos" en los bordes pantalla.
        lda #<irq1                         
        sta $0314                           
        lda #>irq1                           
        sta $0315                           
        lda #%00000001  ;#127 en el ejemplo. Basta con activar el timer A #1     
        sta $DC0D       ;Registro control de la cia                   
        lda #1                             
        sta $D01A       ;Registro mascara IRQ activada. IRQ ON.
        cli 
        rts             ;Salida al basic para pruebas.

main    ;El programa empezaria aquí.
        inc $D021
        jmp main
irq1     
                        ;Reset bandera de registro IRQ manipulando su valor.
        asl $D019       ;asl es consejo de Riq.Si no, se queda activado y falla.
        ldx vector
        ldy linea,x
        sty $d012
        ldy color,x
        sty $d020       ;Color marco
        lda linea+1,x   ;Siguente nuevo valor
        cmp #255
        beq salt0
        inc vector

;Bucle de freno para test de tiempo disponible
        ldx #24         ;Alterad este valor para pruebas de des-sincronismo
looop   lda $d012       ;Valor "aleatorio" del raster
        sta $0400,x     ;Lo pokeo en pantalla
        dex
        bne looop       ;Sigue el bucle hasta que X=0

        jmp $EA81       ;FEBC ;Saltar a restaurar a partir de la rutina NMI.
salt0
        lda #0
        sta vector
        jmp $EA31       ;Rutina interrupcion normal Leer teclado y demás.     

linea   byte $32,$3A,$42,$4A,$52,$5A,$62,$6A,$72,$7A,$82,$8A,$92,$9A,$A2,$AA,$C8,$ff
color   byte $00,$01,$02,$03,$04,$05,$06,$07,$08,$09,$0a,$0b,$0c,$0d,$0e,$0f,$00
vect    byte $00
freno   byte $00

He añadido un bucle para que podais experimentar aumentando o disminuyendo el tiempo del mismo. Este bucle representa el trabajo de mover una linea nada más acabe de pasar el raster (tal y como sugirió Dashiad) u otra cosa.

Mientras el tiempo del bucle sea menor al tiempo entre llamadas de interrupción, todo permanecerá estable.
En cuanto el tiempo del bucle sea mayor...

La verdad es que hay más tiempo del que creia, sin bucles , quizás de tiempo a mover toda una linea completa... Lo dejo para el que quiera trastear con este tema ;)

Otra idea. Usando esta rutina, se podria mostrar una linea de texto con dos colores a la vez e incluso hacer deslizar los dos colores arriba y abajo creando un efecto curioso.

A ver quién se anima.

EDITO:

Se puede ganar algo de tiempo si en vez de saltar a $EA31 donde se lee la tecla STOP y el parpadeo del cursor , saltamos a $EA61 saltandonos un buén cacho de código del sistema. Ando leyendo el listado de la ROM.

No es mucho, pero estas pequeñas ayudas pueden ser valiosas.
Está claro que el cursor dejará de parpadear y la tecla RUN/STOP deja de actuar a nivel del BASIC, pero generalmente no se suele trastear con el BASIC mientras juegas XD

Otro ahorro de tiempo es eliminando jmp$EA81 y pegando este código que es el mismo que se ejecuta en $EA81
 
       pla
        tay
        pla
        tax
        pla
        rti

Entre $EA61 y esto último se consigue algo mas de estabilidad .

Es cuestión de rascar ciclos.

Otra vez editando jajajaja. Esto engancha.

Si no necesitais el datasete, podeis saltar a $EA7B. Aun se consigue mas estabilidad. Desaparecen casi todos los flicks con el bucle a #28. Por lo menos es lo que aprecio con el VICE.
« última modificación: Junio 15, 2016, 23:59:43 por Maniako »
LDA #$50
STA $0400
RTS
Lloré cuando conseguí hacer esto con el monitor del FC1.

Maniako

  • Desarrolladores
  • Commodore Master
  • ******
  • Mensajes: 1008
  • SYS 8*4096
    • Ver Perfil
Re:Rutinas en CM mas o menos útiles
« Respuesta #29 en: Junio 20, 2016, 00:20:12 »
Otra chorrada de las mias  ::).

Generalmente hacer que un personaje de un juego salte con cierta "elegancia" a veces no es sencillo. Suele acabar saltando en angulos de 45 grados y personalmente nunca me ha gustado demasiado.

Se puede hacer uso de tablas para hacer el salto algo más natural o "redondo" (y para muchisimas otras cosas interesantes).
Aquí dejo este pequeño ejemplo, como siempre lo más sencillo que sé hacerlo (tampoco llego a mucho más XD) para una fácil comprensión.

Código: [Seleccionar]
;CMB prg STUDIO 3.8.0
;Usando tablas para saltar.
;He usado para el calculo de la trayectoria del salto el programa SINUS CREATOR.
;Es excelente para estos menesteres.

; 10 SYS4096

*=$0801

        BYTE    $0B, $08, $0A, $00, $9E, $34, $30, $39, $36, $00, $00, $00




*=$1000
sprites=$D000   
;Activando sprite.
        lda eje
        sta sprites     ;Coordenada X sprite.
        sta sprites+1   ;Coordenada Y sprite.
        lda #1
        sta sprites+21  ;Conecta sprite 1
        lda #128
        sta $07f8       ;Puntero direccion sprite
        ldy #00
main
;Bucle de freno para poder ver como salta.
bu2     dec freno0
        bne bu2
        lda #10         ;Disminuyendolo acelera. Aumentandolo frena
        sta freno0
bu3     dec freno1
        bne bu2
;Fin bucle de freno0

;Aqui empieza el programa en sí.       
        inc sprites     ;Muevo sprite en X un pixel a la derecha.
        inc sprites     ;Muevo sprite en X un pixel a la derecha otra vez.
        lda eje         ;Eje Y del sprite. Aqui lo tengo en un valor fijo.
        sec             ;Activar acarreo antes de restar.
        sbc salty,y     ;Le resto el valor del salto que hay en la tabla.
        sta sprites+1   ;Y coloco el sprite en su nueva posicion.
        iny             ;aumento en uno el vector de lectura.
        cpy #16         ;Es =16?
        bne pasa0       ;No?. Pues pasando.
        ldy #00         ;Si es =16, lo pongo a 0 y vuelve a leer la tabla de salto.
pasa0   
        jmp main        ;Vuelta a  empezar.
       
;Tabla datos salto usando Y como vector de lectura.
salty   byte 2,4, 6,  8, 11, 14, 18, 19,19,19, 18, 15, 11,  6,  3,  0
;Si el salto no es de vuestro gusto, podeis ajustarlo a ojo.

*=$2000         ;Sprite puntero 128*64 =#8192-$2000
        BYTE 0,124,0,0,68,0,0,66,0,0,100,0,0,24,0,1,248,96,3,30
        BYTE 192,2,27,128,0,25,128,0,24,0,0,24,0,0,24,0,0,24,0,0
        BYTE 24,0,0,30,0,0,27,0,0,49,0,3,225,0,3,1,0,2,1,128
        BYTE 2,1,192,0

;Variables
eje     byte 100        ;Valor fijo de la posición del sprite.
freno0  byte 0          ;Para el freno
freno1  byte 0          ;Para el freno

Como se puede ver , he usado una herramienta para crear la tabla del salto. Se llama SINUS CREATOR. Es muy sencilla de usar . CBM prg STUDIO 3.8.0 lleva una herramienta similar pero tengo que aprender a usarla.

El programa se explica por si mismo, pero cualquier duda, ya sabeis donde estamos.

« última modificación: Junio 20, 2016, 00:24:22 por Maniako »
LDA #$50
STA $0400
RTS
Lloré cuando conseguí hacer esto con el monitor del FC1.