Commodore manía
Commodore 64 => Desarrollo => Ensamblador => Mensaje iniciado por: Manu en Mayo 23, 2012, 18:01:16
-
Estoy empezando a hacer un emulador de varios sistemas en Java (incluído el C64), y como no conocía las tripas estoy empezando a meterle mano, al menos con emuladores :P
Uno de mis primeros programas es esta chorrada, que seguro que le hace gracia a más de uno:
processor 6502
org $1000
lda #$20
clrloop: sta $0400,x
sta $0500,x
sta $0600,x
sta $0700,x
dex
bne clrloop
start:
ldy #$2
mainloop:
sty $d020
sty $d021
lda $d012
cmp #$60
bne mainloop
ldy #$7
rastloop:
sty $d020
sty $d021
lda $d012
cmp #$d0
bne rastloop
jmp start
¿Qué pensáis que sale en pantalla al hacer un sys 4096? xDDDD
-
Tengo que poner en marcha un ensamblador para probar cosas como esta!
* Pon el PRG :P
-
Aquí tienes el PRG 8)
Programita (http://dl.dropbox.com/u/37131/c64/raster.prg)
-
Aquí tienes el PRG 8)
Programita (http://dl.dropbox.com/u/37131/c64/raster.prg)
¿Estas seguro que eso hace algo?? :D yo no veo nada...
Por cierto, cuenta un poco que herramientas estas usando, etc...
-
Tienes que cargarlo (yo lo hago en el vice con "x64 raster.prg"), y luego hacer un sys 4096 en basic :)
Para hacerlo de momento no he hecho nada fuera de lo común, salvo documentarme de los registros del VIC II, usar un editor de texto, y ensamblarlo con el Dasm (http://dasm-dillon.sourceforge.net/) 8)
Ten en cuenta que el raster se hace de forma muy burda, sin interrupciones ni nada :P
-
España!!! España!!!
Esta Eurocopa es nuestra con este programita :D
-
¡Ese es el espíritu! xDDD
A ver si luego publico una nueva versión algo más optimizada :)
-
Version facil para Josepzin ;)
; 10 SYS (4096)
*=$800
BYTE $00, $0E, $08, $0A, $00, $9E, $20, $28, $34, $30, $39, $36, $29, $00, $00, $00
*=$1000
LDA #$20
CLRLOOP
STA $0400,X
STA $0500,X
STA $0600,X
STA $0700,X
DEX
BNE CLRLOOP
START
LDY #$2
MAINLOOP
STY $D020
STY $D021
LDA $D012
CMP #$60
BNE MAINLOOP
LDY #$7
RASTLOOP
STY $D020
STY $D021
LDA $D012
CMP #$D0
BNE RASTLOOP
JMP START
-
Genial que la gente se vaya animando con la programación del C64.. no pierdo la esperanza de que algún día podamos hacer una colaboración made in foreros :)
PD: Por cierto, alguien sabe que es de Lobogris?? hace tiempo que no se deja ver.
-
PD: Por cierto, alguien sabe que es de Lobogris?? hace tiempo que no se deja ver.
Hasta donde sé, Lobogris esta liado con cosas personales...
-
Version facil para Josepzin ;)
Esta tarde lo pruebo!
-
Ahora lo mismo, con interrupciones raster y música de Snap xDDD
processor 6502
org $810
lda #$00
tax
tay
jsr $1000 ; init music
jsr $e544 ; clear screen
sei ; disable interrupts and clear pending irqs
lda #$7f
sta $dc0d
sta $dd0d
lda #$01
sta $d01a
lda #$1b ; text mode
ldx #$08
ldy #$14
sta $d011
stx $d016
sty $d014
lda #<irq1
ldx #>irq1
sta $0314
stx $0315
ldy #$60 ; first raster interrupt
sty $d012
lda $dc0d ; clear interrupts and VIC ACK
lda $dd0d
asl $d019
cli
loop:
jmp loop ; loop forever
irq1:
lda #$7 ; yellow
sta $d020
sta $d021
jsr $1003 ; update music
lda #<irq2 ; set the next interrupt vector at raster line RASTER2
ldx #>irq2
sta $0314
stx $0315
ldy #$d0
sty $d012
asl $d019 ; VIC ACK
jmp $ea81
irq2:
lda #$2 ; red
sta $d020
sta $d021
lda #<irq1 ; set the next interrupt vector at raster line RASTER1
ldx #>irq1
sta $0314
stx $0315
ldy #$60
sty $d012
asl $d019; VIC ACK
jmp $ea81
org $1000-$7e
INCBIN "snap.sid"
PRG (http://dl.dropbox.com/u/37131/c64/spain.prg) (Luego hacer SYS2064)
¿Alguien sabe porqué se produce ese flickering en los bordes a pesar de que lo primero que haga en la interrupción sea cambiar el color? :'(
-
Bueno, y ya lo último de hoy...
Sorpresita (http://dl.dropbox.com/u/37131/c64/pac.zip)
Ejecutar el prg y luego hacer un SYS2064
La verdad esto esto es más fácil de lo que pensaba...
-
Genial !!!!!!!!!!! El PAC de Commodore mania. A este paso antes de las 12 nos haces una demo :)
-
Mo-la! un poco mas y ya tenemos "el PRG oficial" de Commodore Manía!!
-
Bueno, y ya lo último de hoy...
Sorpresita (http://dl.dropbox.com/u/37131/c64/pac.zip)
Ejecutar el prg y luego hacer un SYS2064
La verdad esto esto es más fácil de lo que pensaba...
Muy bien :) ya tenías experiencia en la programación de C64 u otros sistemas??
-
Muy bien :) ya tenías experiencia en la programación de C64 u otros sistemas??
No he tocado un C64 en la vida (ni ningún ordenador basado en 6502), pero empecé a investigar cómo funcionaba internamente hace unas semanas, primero la CPU, y ahora el resto de componentes.
Eso sí, el ensamblador de Z80 sí me es más familiar, y en la carrera también he tocado el de arquitecturas x86, ya que soy "teleco técnico" ;)
En cualquier caso, la arquitectura del C64 me parece muy interesante. Estoy aprendiendo algunas cosillas más, y para la semana que viene a ver si me da tiempo a hacer alguna cosita más avanzada con rasters y efectos :)
-
Eso si que es ir rápido.. a mi me costo meses entender bien toda la parte gráfica y de rasters. Como nos despistemos en un par de semanitas nos preparas el Call of Duty para C64 :D
-
Bueno, puede que tenga facilidad para ciertas cosas, pero no creo que domine el SID nunca, y seguramente me costará emularlo un huevo. Creo que es, con diferencia, la parte más compleja del ordenador. Menos mal que al menos reproducir una melodía "ripeada" es insultantemente fácil ^_^
-
Joe que envidia como controláis el ensamblador :)
Estaría bien un cursillo como el que empezo lobogris :)
-
Mira, este tutorial me ha venido bien para empezar y conocer algunas cosas básicas:
http://digitalerr0r.wordpress.com/category/commodore-64/ (http://digitalerr0r.wordpress.com/category/commodore-64/)
-
Gracias!!
-
Bueno, nueva "chorradilla" de la semana :)
Animacion (http://dl.dropbox.com/u/37131/c64/animacion28052012.zip) (PRG y fuentes)
Esta vez he ripeado los sprites del Pacmania de Grandslam (http://www.lemon64.com/?mainurl=http%3A//www.lemon64.com/games/details.php%3FID%3D1877) con el Spritepad, porque quería hacer una animación con Pac y los fantasmitas. Haciendo esto, he visto que con poquitos frames de animación, si cambiamos cada barrido de pantalla, la animación va extremadamente rápido. Para esto, he puesto un pequeño "delay" para hacer un cambio cada cinco barridos.
Por otro lado, también he mejorado el movimiento, ya que antes me limitaba a los primeros 256 píxeles de ancho, y ahora se recorren los 320. El siguiente paso será quitar los bordes laterales 8)
(https://lh4.googleusercontent.com/-BZuP8jxTJ3c/T8OIG2atPLI/AAAAAAAAIFQ/uShIWXEW3pM/s800/sprites.png)
La musiquilla la he sacado de HSVC (http://www.hvsc.c64.org/), y la ha hecho un tal Ádám Dávidovics. Esta vez, en vez de cargar el SID a lo bruto, he quitado la cabecera de 126 bytes con la utilidad dd de Linux.
También os habréis dado cuenta de que ya no es necesario hacer un SYS en BASIC al cargar el PRG. He visto cómo almacena el intérprete de BASIC los listados, y he metido a pelo 10 SYS 2061. Luego el autocargador de VICE hace el resto ;)
Lo siguiente que quiero hacer es poner el logo de Commodore Mania arriba, hacer un scroller abajo con letras de colorines y un fondo animado detrás de los sprites.
La verdad es que esto de programar para el C64 engancha ;D
-
Joder... que rápido vas!! :D
-
Manu, a tu experimiento con el Pacman, si le agregas el logotipo (bueno, lo que tenemos ahora) de CManía podríamos hacer una pequña intro promocional de la web/foro, para publicar en CSDb!
Si quieres puedo intentar hacer las letras de CommodoreManía en gráficos de C64
-
Ahora estaba experimentando con tiles, y había hecho esto:
PRG (http://dl.dropbox.com/u/37131/c64/intro20120602.prg)
Todavía me queda bastante por aprender de gráficos para hacer algo decente :P
-
¿Cuando dices "tiles" te refieres a "chars"?
Tu sigue asi, que a eso le agregamos un texto que explique quienes somos y ya lo podemos usar para hacernos conocer!
¿Que letra usaste para el texto de COMMODORE MANIA?
-
Cuando digo tiles me refiero a grupos de chars. Esas letras son de 2x2 si no recuerdo mal, y vienen en el charpad :D
-
Mira, este tutorial me ha venido bien para empezar y conocer algunas cosas básicas:
http://digitalerr0r.wordpress.com/category/commodore-64/ (http://digitalerr0r.wordpress.com/category/commodore-64/)
He empezado el tutorial
http://digitalerr0r.wordpress.com/2011/03/19/commodore-64-programming-a-quick-start-guide-to-c-64-assembly-programming-on-windows/ (http://digitalerr0r.wordpress.com/2011/03/19/commodore-64-programming-a-quick-start-guide-to-c-64-assembly-programming-on-windows/)
pero cuando trato de compilar el archivo asm con el dasm
dasm test.asm –otest.prg
me dice...
test.asm (1): error: Unknown Mnemonic '6502'.
test.asm (4): error: Unknown Mnemonic 'inc'.
test.asm (5): error: Unknown Mnemonic 'jmp'.
por que? :(
-
Es importante que respetes la tabulación con el dasm (con espacios preferiblemente).
Por ejemplo, es:
processor 6502
org $810
no:
processor 6502
org $810
-
¿El dasm hace lo mismo que Python con la tabulacion??
-
Algo similar sí, aunque no es tan exigente :)
-
He copiado el texto tal cual esta en el tutorial...
processor 6502
org $1000
loop: inc $d021
jmp loop
y ahora compila perfecto, no da error
pero cuando pongo sys 4096 en el emulador...
no hace nada :o
-
¿Y has cargado el emulador con x64 PROGRAMA.prg? Es raro, a mí me salen las rayitas :P
-
vale, después de hacer muchas pruebas ya lo he conseguido :D
ponía esto copiado del tutorial, ahí tiene como varios espacios..
processor 6502
org $1000
loop: inc $d021
jmp loop
Compilaba.. pero no funcionaba el SYS 4096
pero poniendo sólo un espacio para en las instrucciones , para el loop no, si que funciona
processor 6502
org $1000
loop: inc $d021
jmp loop
Gracias, Si, era un tema de tabulación.
-
Buenas, esta semana que estoy de vacaciones estoy dandole Al Hierro un poco, la verdad es que este Mini Curso que habeis enlazado esta muy bien, es sencillo y directo, en este sentido me ha interesado muchisimo el tema de cargar una Bitmap (Capitulo 7),.aqui os dejo el enlace especifico...
http://digitalerr0r.wordpress.com/2011/04/30/commodore-64-programming-7-creating-and-rendering-bitmaps/ (http://digitalerr0r.wordpress.com/2011/04/30/commodore-64-programming-7-creating-and-rendering-bitmaps/)
Incluso he aparcado el Gang-Ed y estoy utilizando el Editor Grafico que recomienda y ya he creado una Bitmap que quiero cargar,...es importante recordar que yo utilizo el 64TASS como Compilador Cruzado...
No se que leches pasa que no soy capaz de arrancar una bitmap, de hecho al compilar el Listado con el 64Tass me alude a "Palabras que no entiende", imagino que seran comandos que no son compatibles con el 64 Tass como por ejemplo el inicio del alojamiento de graficos que si en el curso lo hace como:
ORG $1FFE ; para el inicio de bitmap
ORG $1000 ;inicio de programa
en el 64 Tass esto se haria así:
*=$1FFE
*=$1000
Pero cambiando esto en el listado me lo compila pero me da luego error en el programa en el emulador...en el listado del curso la carga del archivo de bitmap la llama con:
INCBIN “DCC.PRG”
A mi esta orden el 64Tass no me la entiende, cambio la que yo utilizo en dicho compilador que es .binary con el nombre de la bitmap que he creado yo con el editor que recomienda quedando de esta forma, pero aun compilado me da error en el programa en el emulador
.BINARY BITMAP.PRG
Aqui el listado original (que viene en el capitulo 7 que enlazo al principio) y que no consigo compilar con el 64 tass, a ver si alguien me pued decir que tengo que cambiar o me pasa algun listado sencillo de carga de Bitmap que me valga para el 64tass,.
PROCESSOR 6502
ORG $1000
LDA $4710
STA $D020
STA $D021
LDX #$00
LOADDCCIMAGE:
LDA $3F40,X
STA $0400,X
LDA $4040,X
STA $0500,X
LDA $4140,X
STA $0600,X
LDA $4240,X
STA $0700,X
LDA $4328,X
STA $D800,X
LDA $4428,X
STA $D900,X
LDA $4528,X
STA $DA00,X
LDA $4628,X
STA $DB00,X
INX
BNE LOADDCCIMAGE
LDA #$3B
STA $D011
LDA #$18
STA $D016
LDA #$18
STA $D018
LOOP: JMP LOOP
ORG $1FFE
INCBIN "DCC.PRG"
Hoy llevo todo el dia a puñetazos con esto, cualquier ayuda la agradezco, Muchas Gracias!!! en este correo adjunto la bitmap que quiero cargar y que he creado con el editor que recomienda en el curso.
-
Puedes pegar el error que te da? no tengo instalado el 64TASS para poder probar el listado.
De todas formas el error podría estar a la hora de incluir el bitmap, deberías hacer algo así:
*=$1FFE
.binary "bitmap.prg",2
para ignorar los dos primeros bytes de cabecera.
-
Si yo compilo el listado tal y como lo ponen en el curso, (que es el listado que adjunte en el post anterior), el 64Tass me da cuatro errores
Assembling file: original.asm
original.asm:1: General syntax "PROCESSOR 6502"
original.asm:17592186044418: General syntax "ORG $1000"
original.asm:17592186044451: Double defined org "ORG $1FFE"
original.asm:17592186044452: General syntax "INCBIN "BITMAP.PRG""
Que son las instrucciones a las que aludia enteriormente,...modifico el listado para que el 64Tass me lo entiendo, es decir hago esto:
- Lo de PROCESSOR 6502 lo borro
- Cambio ORG $1000 por *=$1000
- Cambio ORG $1FFE por *=$1FFE
- Cambio INCBIN "BITMAP.PRG" por .BINARY "BITMAP.PRG" o por .BINARY "BITMAP.PRG",2
Hecho esto el 64Tass entonces si me lo compila con exito, pero cuando arranco en el emulador si bien no me da ya error como antes, se me queda que no hace nada, aun tecleando RUN, LIST o lo que sea
Aqui dejo una foto en la que se ve el NotePad con el Listado y las modificaciones, tambien se ve el Simbolo del Sistema con el Programa recien compilado y luego se ve en el emulador funcionando, pero no hace nada (pulsando sobre la foto con boton izquierdo se amplia un poco)..
(http://a6.sphotos.ak.fbcdn.net/hphotos-ak-ash3/577496_245034645612879_683109598_n.jpg)
SALUDOS.
-
Has probado a arrancarlo con SYS 4096 desde el emulador?
-
Has probado a arrancarlo con SYS 4096 desde el emulador?
Como dice Laddh, estas colocando el código del programa en la dirección $1000 por lo que para ejecutarlo desde BASIC deberías poner SYS 4096 (que es $1000 en decimal).
-
SOLUCIONADO!!!,lo habia hecho bien..simplemente era eso, el programa no se autoarrancaba!!, tecleando SYS 4096, el programa arranca!!,...solo me queda una ultima pregunta,..¿que agrego al programa para que se arranque solo al cargarlo y no tenga que teclear el sys 4096...
Os copio pego la cabecera de otro programa que tengo que arranca solo, quizas agregandole alguna linea de él, consigo que la bitmap se vea automatica sin llamarla con SYS!!!
*=$0801 ; INICIO BASIC
.WORD NEXT,10 ; PUNTERO SIGUIENTE LINEA Y NUM. LINEA 10
.NULL $9E,^START ; SENTENCIA "SYS START" (START=INICIO C.M.)
NEXT .WORD 0 ; FIN DE PROGRAMA BASIC
.INCLUDE HARDWARE.INC ;DIRECTIVA CON ETIQUETAS
*=$2000 ; INICIO GRAFICOS
; CARGA GRAFICOS
.BINARY SPRITES.BIN ; BANCO DE SPRITES
.BINARY CHARS.RAW ; BANCO DE CARACTERES
; VARIABLES (DEFINIDAS CON ".BYTE" O ".WORD" SEGUN OCUPEN 1 O 2 BYTES)
FRAMES .BYTE 0 ; CONTADOR DE FRAMES DE VIDEO
; START
START SEI ; DESHABILITAR INTERRUPCIONES
Me contais y muchas gracias, a ver si hoy puedo ingresar la rutina de carga de bitmap en otro programa y puedo enseñaros ya algo de mis humildes avances en ensamblador...
Una ultima cosa Carlos en relacion a la resta de los dos primeros bytes, si te fijas la posicion de carga de graficos esta en $2000 y desde el programa original se la llama en
ORG $1FFE (*=$1FFE en el 64Tass)
Esto es asi porque esos dos bytes ya van restados...
$2000-$02=$1FFE no me hizo falta teclearlo así: .BINARY "BITMAP.PRG",2
Bueno, lo dicho, a ver si os puedo mostrar algo hoy y a ver si sabe alguien que incluyo en el listado para que arranque automatico sin necesidad de teclear el SYS, tambien me estoy dando cuenta de una ultima cosa,..cuando meta esa rutina de carga de bitmap en otro programa tendre que eliminar la linea
LOOP: JMP LOOP
Para que una vez mostrada el programa no se me quede "colgado" y continue su curso animando sprites y todo el tinglado que contenga.
AL HIERRO!!!
-
¡Que ganas de ponerme a hacer algo de todo esto!!
Me alegro verte de nuevo por aquí, Raúl.
Un consejo, si al código lo marcas como "código" se ve mucho mejor (es el ícono #)
-
Ya que estoy aquí os dejo otra pregunta con permiso de la moderacion,..resulta que al insertar la rutina de carga de bitmap en un programa me he dado cuenta que la bitmap se comienza a hubicar en la posicion $2000 (8192) que es la misma donde yo ponia los Sprites (que solo son 4)
Lo que quiere decir que tengo que mover los sprites,..el programa por otro lado se inicia en la posicion $801 (2049, que creo que esta bien),..el caso es que no se donde poner los Sprites ahora, tendria dos opciones:
- comerme cuatro bloques del bufer de cassette (lo que son 4 sprites) desde la posicion $400 (1024) hacia atras,..utilizando como punteros de sprites los bloques: 16,15,14,13
- llevarlos al Banco 1, pero no se como direccionar los punteros en este banco o si necesita alguna rutina adicional
- o buscarles algun sitio en el Banco 0 donde entre todo, el programa, la bitmap y los sprites
Bueno me contais, adjunto foto orientativa...
(http://a3.sphotos.ak.fbcdn.net/hphotos-ak-snc7/599816_245334598916217_1999856334_n.jpg)
AL HIERRO!!!
-
A ver, varias cosas :)
Para que se auto arranque, tienes que hacer algo así (te pongo la sintaxis dasm):
.org $800
; make a SYS call in BASIC to start the intro (10 SYS2061)
.byte $0
.word $080b ; pointer to the next instruction
.word $0a ; 10
.byte $9e ; SYS
.byte $34 ; 4
.byte $30 ; 0
.byte $39 ; 9
.byte $36 ; 6
.byte 0
.byte 0,0 ; end ($080b)
Esto hace que se añada un listado de basic que luego se autoejecuta en emuladores como Vice al cargar el PRG.
Los sprites o los colocas después de la imagen (y luego los referencias los punteros adecuados), o en otro banco (pero es más movida). Tendrás que tocar el registro en $d018 adecuadamente.
En cuanto al jmp loop, si lo haces todo por interrupciones de raster no hay que quitarlo.
-
A ver, el tema de la ubicación de los sprites....
El chip gráfico (VIC-II) del C64 solo es capaz de 'ver' 16k de la memoria total de 64k que tiene la máquina, lo bueno es que le puedes decir que 16k quieres que vea. Cada uno de estos bloques de 16k se denomina banco y logicamente hay 4 diferentes (16k x 4 = 64k). Si no me equivoco el banco por defecto es el 0 (los primeros 16k de la máquina).
bank0: $0000-$3fff (defecto)
bank1: $4000-$7fff
bank2: $8000-$bfff
bank3: $c000-$ffff
Todo lo que vayas a mostrar por pantalla sea un bitmap, chars o sprites tiene que estar en el mismo banco, no puedes tener el bitmap en un banco y los sprites en otro por ejemplo. El banco que vayas a usar es una de las decisiones de diseño de tu programa, lo normal es usar el bank 1 o el 3 para no interferir con el juego de caracteres de la ROM.
Sí puedes tener bitmap, sprites o caracteres en el rango de memoria de otro banco pero sólo a modo de almacenamiento, en el momento en que desees mostrarlos por pantalla los tienes que llevar al banco que tengas como activo.
Para que no se te solape el bitmap con los sprites pues haz lo que comenta Manu, pon los sprites antes o después del bitmap (pero sin salirte del banco recuerda).
Para cambiar de banco es muy sencillo, sólo tienes que jugar con el registro $dd00 que es el que lo controla.
-
Gracias Manu y Carlos!!
@ Manu, voy a mirar a ver si simplemente incluyendola en un programa que ya se autorranca me funciona y sino probare con el listado que me adjuntas, tambien vere el comportamiento del bucle en loop a ver si hace falta quitarlo o no ya que el programa donde lo quiero meter ya que el programa lleva interrupciones de raster si no me equivoco.
@ Carlos, interesante, no sabia que la bitmap y sprites tenian que estar en el mismo banco que esta operativo, me cuentas que para cambiar el registro actuo sobre $dd00, es decir, si le quiero decir a la maquina que pongo operativo el banco uno,...hare?
LDA #$01
STA $DD00
Y por ultimo, como se sabe el valor de los punteros de sprite en el Bank 1,...¿simplemente se divide el valor de memoria por 64 como en el banco 0?
La verdad es que esto de trabajar en el Banco 0 con las limitaciones de espacio me esta viniendo bien para ser ordenado y aprovechar el espacio bien,..probe a meter los 5 sprites en la posicion 1024 (buffer de cassette) hacia atras, pero no me entran 5 y pisaba peligrosamente la zona de punteros y registros y el programa malfuncionaba.
Al final los he metido al final de la zona que utilizaba para el inicio de programa, es decir (consultar mapa) desde la 4096 hacia 5 bloques hacia atras hasta la 3776 utilizando como punteros los valores 59,60,61,62 y 63 y me funciona perfecto ya que el listado no llega hasta esa zona...ahora solo me queda meterle la bitmap a partir de la 8192,..os cuento
(http://a3.sphotos.ak.fbcdn.net/hphotos-ak-snc7/599816_245334598916217_1999856334_n.jpg)
-
Gracias Manu y Carlos!!
...
@ Carlos, interesante, no sabia que la bitmap y sprites tenian que estar en el mismo banco que esta operativo, me cuentas que para cambiar el registro actuo sobre $dd00, es decir, si le quiero decir a la maquina que pongo operativo el banco uno,...hare?
LDA #$01
STA $DD00
Y por ultimo, como se sabe el valor de los punteros de sprite en el Bank 1,...¿simplemente se divide el valor de memoria por 64 como en el banco 0?
...
No exactamente, son los dos bits menos significativos de ese registro los que controlan el banco del VIC. Por ejemplo para seleccionar el bank 1:
lda $dd00
and #$fc ; pongo a 0 los 2 bits menos significativos del registro manteniendo el resto
ora #$02 ; establezco el bank 1
sta $dd00
a lo mejor no queda claro porqué almacenar un 2 para seleccionar el bank 1, la explicación es esta:
$DD00 = %xxxxxx11 -> bank0
$DD00 = %xxxxxx10 -> bank1
$DD00 = %xxxxxx01 -> bank2
$DD00 = %xxxxxx00 -> bank3
para estas cosas lo mejor es que consultes el mapa de memoria del C64 donde se explica el valor de todos los registros: http://sta.c64.org/cbm64mem.html (http://sta.c64.org/cbm64mem.html)
-
He incluido la rutina de carga de bitmap en un programa,..me la autoarranca (es decir me muestra la bitmap), pero AHI SE QUEDA!!!, no se porque no sigue el curso el programa. una vez que muestra la bitmap ahi se queda parado y no muestra los sprites y menos continua el programa con toda su retaila,..pense que el fallo estaria en el bucle de loop en el programa original,...si elimino la linea:
BUCLE
JMP BUCLE ; EN EL LISTADO ORIGINAL ERA LOOP: JMP LOOP
el programa se me va al garete, no se que ocurre, adjunto principio del listado donde se ve el ingreso de la rutina en ; CARGAR BITMAP hasta ; COLORES DE PANTALLA,..pero no se porque el programa no sigue su curso, a ver si me podeis decir algo y el fallo tiene que estar en esa rutina porque si la quito aunque la bitmap no se muestre, el programa sigue su curso....
; ************************************
; * TITLE: CALIGULA *
; * CODER/GRAPHICS: INTERNATIONAL *
; * YEAR: 2012 *
; ************************************
*=$0801 ; INICIO BASIC
.WORD NEXT,10 ; PUNTERO SIGUIENTE LINEA Y NUM. LINEA 10
.NULL $9E,^START ; SENTENCIA "SYS START" (START=INICIO C.M.)
NEXT .WORD 0 ; FIN DE PROGRAMA BASIC
.INCLUDE HARDWARE.INC ;DIRECTIVA CON ETIQUETAS
; VARIABLES (DEFINIDAS CON ".BYTE" O ".WORD" SEGUN OCUPEN 1 O 2 BYTES)
FRAMES .BYTE 0 ; CONTADOR DE FRAMES DE VIDEO
; CARGA SPRITES
*=$0EC0 ; INICIO SPRITES
.BINARY SPRITES.BIN ; BANCO DE SPRITES
; START
START SEI ; DESHABILITAR INTERRUPCIONES
; ESTO NO SE QUE HACE TODAVIA
LDA $D018 ; TOVIA NO SE QUE HACEN ESTAS CUATRO LINEAS
AND #$F1 ; VIC-II CHIP MEMORY CONTROL REGISTER LO TENGO QUE MIRAR
ORA #$0A ; DE MOMENTO LO INCLUYO
STA $D018 ; VIC-II CHIP MEMORY CONTROL REGISTER
; BORRAR PANTALLA
LDA #$20 ; VALOR DEL ESPACIO EN BLANCO
LDX #$00 ; DESPLAZAMIENTO
CLS STA $0400,X ; METER ESPACIO EN BLANCO EN FRANJA 1
STA $0500,X ; METER ESPACIO EN BLANCO EN FRANJA 2
STA $0600,X ; METER ESPACIO EN BLANCO EN FRANJA 3
STA $0700,X ; METER ESPACIO EN BLANCO EN FRANJA 4
DEX ; DECREMENTAR DESPLAZAMIENTO
BNE CLS ; REPETIR HASTA QUE NO LLEGUE A CERO
; CARGAR BITMAP
LDA $4710
STA $D020
STA $D021
LDX #$00
LOADDCCIMAGE
LDA $3F40,X
STA $0400,X
LDA $4040,X
STA $0500,X
LDA $4140,X
STA $0600,X
LDA $4240,X
STA $0700,X
LDA $4328,X
STA $D800,X
LDA $4428,X
STA $D900,X
LDA $4528,X
STA $DA00,X
LDA $4628,X
STA $DB00,X
INX
BNE LOADDCCIMAGE
LDA #$3B
STA $D011
LDA #$18
STA $D016
LDA #$18
STA $D018
BUCLE
JMP BUCLE
*=$1FFE
.BINARY "BITMAP.PRG"
; COLORES DE PANTALLA
LDA #$08 ; COLOR NARANJA
STA $0286 ; A LA POSICION 646 COLOR CURSOR
LDA #$00 ; VALOR DEL COLOR NEGRO
STA $D020 ; ASIGNARLO AL BORDE
LDA #$00 ; VALOR DEL NEGRO
STA $D021 ; Y TAMBIEN AL FONDO
; ASIGNAR PUNTEROS SPRITES
LDA #$3B ; BLOQUE MEMORIA 59 BANCO 0 GRAFICO NAVE DERECHA
STA $07F8 ; ASIGNAR A SPRITE #0 PUNTERO 2040
LDA #$3E ; BLOQUE MEMORIA 62 BANCO 0 GRAFICO NAVE ENEMIGA
-
El programa continua aqui, lo que pasa es que si lo adjunto todo de golpe "peta"...
; ASIGNAR PUNTEROS SPRITES
LDA #$3B ; BLOQUE MEMORIA 59 BANCO 0 GRAFICO NAVE DERECHA
STA $07F8 ; ASIGNAR A SPRITE #0 PUNTERO 2040
LDA #$3E ; BLOQUE MEMORIA 62 BANCO 0 GRAFICO NAVE ENEMIGA
STA $07F9 ; ASIGNAR A SPRITE 1 PUNTERO 2041
LDA #$3E ; BLOQUE MEMORIA 62 BANCO 0 GRAFICO NAVE ENEMIGA
STA $07FA ; ASIGNAR A SPRITE 2 PUNTERO 2042
LDA #$3E ; BLOQUE MEMORIA 62 BANCO 0 GRAFICO NAVE ENEMIGA
STA $07FB ; ASIGNAR A SPRITE 3 PUNTERO 2043
LDA #$3F ; BLOQUE MEMORIA 63 BANCO 0 GRAFICO DISPARO
STA $07FC ; ASIGNAR A SPRITE 4 PUNTERO 2044
; ASIGNAR COLORES SPRITES
LDA #$06 ; VALOR COLOR AZUL
STA SP0COL ; METERLO EN LA ETIQUETA SPOCOL COLOR SPRITE #0
LDA #$06 ; VALOR COLOR AZUL
STA SP1COL ; METERLO EN LA ETIQUETA SPOCOL COLOR SPRITE #1
LDA #$06 ; VALOR COLOR AZUL
STA SP2COL ; METERLO EN LA ETIQUETA SPOCOL COLOR SPRITE #2
LDA #$06 ; VALOR COLOR AZUL
STA SP3COL ; METERLO EN LA ETIQUETA SPOCOL COLOR SPRITE #3
LDA #$07 ; VALOR COLOR AMARILLO
STA SP4COL ; METERLO EN LA ETIQUETA SPOCOL COLOR SPRITE #4
; ASIGNAR MULTICOLOR 1 Y 2 PARA TODOS LOS SPRITES
LDA #$0B ; VALOR 11 GRIS OSCURO
STA SPMC0 ; AL REGISTRO MULTICOLOR 1
LDA #$01 ; VALOR 1 BLANCO
STA SPMC1 ; AL REGISTRO MULTICOLOR 2
; ASIGNAR POSICION INICIAL SPRITES
LDA #0 ; BIT MAYOR PESO COORDENADA X = 0
STA MSIGX ; AL HIERRO!
LDA #70 ; COORDENADA X = 70
STA SP0X ; AL SPRITE 0
LDA #110 ; COORDENADA Y = 110
STA SP0Y ; AL SPRITE 0
LDA #85 ; COORDENADA X = 85
STA SP4X ; AL SPRITE 4
LDA #110 ; COORDENADA Y = 110
STA SP4Y ; AL SPRITE 4
LDA #255 ; COORDENADA X = 255
STA SP1X ; AL SPRITE 1
LDA #80 ; COORDENADA Y = 80
STA SP1Y ; AL SPRITE 1
LDA #255 ; COORDENADA X = 255
STA SP2X ; AL SPRITE 2
LDA #135 ; COORDENADA Y = 135
STA SP2Y ; AL SPRITE 2
LDA #155 ; COORDENADA X = 155
STA SP3X ; AL SPRITE 3
LDA #190 ; COORDENADA Y = 190
STA SP3Y ; AL SPRITE 3
; ACTIVAR MODO MULTICOLOR SPRITES
LDA #$FF ; A TODOS
STA SPMC ; AL HIERRO
; DESHABILITAR TECLADO
LDA 224
STA CIDDRA
; - - - - - - - -
; BUCLE PRINCIPAL
; - - - - - - - -
UPDATE
; HIERRO DE SPRITES
LDA #$0F ; ACTIVO SPRITES 0 1 2 3
STA SPENA ; VALOR A ETIQUETA SPENA ACTIVACION SPRITES
MAINLOOP
; ESPERAR RAYO DE ELECTRONES
LDA RASTER
CMP #$FF
BNE MAINLOOP
; LECTURA DEL JOYSTICK Y MOVIMIENTO SPRITE
Asi todo en esta parte del listado (que todavia sigue mas) no esta el asunto,..sino en la primera del post anterior, en la que no se porque el programa no sigue su curso y tiene que estar en la rutina que he ingresado de carga de bitmap, a ver si me podeis decir algo...
Gracias.
-
Raúl, quizás esto te sirva para cuando son códigos tan largos: hay unas webs que permite pegar un código y luego pones aqui un enlace, por ejemplo asi: http://pastebin.com/n8cUTX9L (http://pastebin.com/n8cUTX9L)
Esta http://pastebin.com (http://pastebin.com) o esta http://dpaste.com (http://dpaste.com)
-
No consigo entender que es lo que ocurre, he creado un nuevo programa aislando el meollo para intentar solucionarlo en un programa mas corto, en el listado vereis que se carga la bitmap y luego mostrada se pretende mostrar un Sprite...
La bitmap la muestra pero nunca llega a mostrar el sprite, alguien me puede ayudar, donde esta el error, porque no me muestra el sprite y se queda atorado al mostrar la bitmap?
*=$0801 ; INICIO BASIC
.WORD NEXT,10 ; PUNTERO SIGUIENTE LINEA Y NUM. LINEA 10
.NULL $9E,^START ; SENTENCIA "SYS START" (START=INICIO C.M.)
NEXT .WORD 0 ; FIN DE PROGRAMA BASIC
.INCLUDE HARDWARE.INC ;DIRECTIVA CON ETIQUETAS
; VARIABLES (DEFINIDAS CON ".BYTE" O ".WORD" SEGUN OCUPEN 1 O 2 BYTES)
FRAMES .BYTE 0 ; CONTADOR DE FRAMES DE VIDEO
; CARGA SPRITES
*=$0EC0 ; INICIO SPRITES
.BINARY SPRITES.BIN ; BANCO DE SPRITES
; START
START SEI ; DESHABILITAR INTERRUPCIONES
; ESTO NO SE QUE HACE TODAVIA
LDA $D018 ; TOVIA NO SE QUE HACEN ESTAS CUATRO LINEAS
AND #$F1 ; VIC-II CHIP MEMORY CONTROL REGISTER LO TENGO QUE MIRAR
ORA #$0A ; DE MOMENTO LO INCLUYO
STA $D018 ; VIC-II CHIP MEMORY CONTROL REGISTER
; CARGAR BITMAP
LDA $4710
STA $D020
STA $D021
LDX #$00
LOADDCCIMAGE
LDA $3F40,X
STA $0400,X
LDA $4040,X
STA $0500,X
LDA $4140,X
STA $0600,X
LDA $4240,X
STA $0700,X
LDA $4328,X
STA $D800,X
LDA $4428,X
STA $D900,X
LDA $4528,X
STA $DA00,X
LDA $4628,X
STA $DB00,X
INX
BNE LOADDCCIMAGE
LDA #$3B
STA $D011
LDA #$18
STA $D016
LDA #$18
STA $D018
BUCLE
JMP BUCLE
*=$1FFE
.BINARY "BITMAP.PRG"
PARAMETROS
; ASIGNAR PUNTEROS SPRITES
LDA #$3B ; BLOQUE MEMORIA 59 BANCO 0 GRAFICO NAVE DERECHA
STA $07F8 ; ASIGNAR A SPRITE #0 PUNTERO 2040
; ASIGNAR COLORES SPRITES
LDA #$06 ; VALOR COLOR AZUL
STA SP0COL ; METERLO EN LA ETIQUETA SPOCOL COLOR SPRITE #0
; ASIGNAR MULTICOLOR 1 Y 2 PARA TODOS LOS SPRITES
LDA #$0B ; VALOR 11 GRIS OSCURO
STA SPMC0 ; AL REGISTRO MULTICOLOR 1
LDA #$01 ; VALOR 1 BLANCO
STA SPMC1 ; AL REGISTRO MULTICOLOR 2
; ASIGNAR POSICION INICIAL SPRITES
LDA #0 ; BIT MAYOR PESO COORDENADA X = 0
STA MSIGX ; AL HIERRO!
LDA #70 ; COORDENADA X = 70
STA SP0X ; AL SPRITE 0
; ACTIVAR MODO MULTICOLOR SPRITES
LDA #$FF ; A TODOS
STA SPMC ; AL HIERRO
; DESHABILITAR TECLADO
LDA 224
STA CIDDRA
; MUESTRA SPRITE
LDA #$0F ; ACTIVO SPRITES 0 1 2 3
STA SPENA ; VALOR A ETIQUETA SPENA ACTIVACION SPRITES
MAINLOOP
; ESPERAR RAYO DE ELECTRONES
LDA RASTER
CMP #$FF
BNE MAINLOOP
FIN
JMP FIN
-
SOLUCIONADO!!!, no se que leches he tocado pero ya me funciona!!!, voy a hacer el arreglo en el listado grande y os muestro la CHURUFLETA.
-
Bueno, os muestro mis humildes avances en Ensamblador, en este correo os adjunto un archivo .prg que podeis autoarrancar (Autostar disk/tape image) en el Vice.
Una vez cargado podreis pilotar la nave con el Joystick (con teclado no es posible), vereis que la nave tiene una cierta ondulacion cuando se mueve hacia arriba y abajo, el tema de la colision de sprites esta sin hacer y el tema del disparo es un poco "despelote" una vez que lo pulsas, solo desaparece reseteando el juego.
Poco a poco voy aprendiendo a hacer cositas, ahora quiero manejarme con el tema de la colision de Sprites y dejar bien el tema del disparo,..seguro que os preguntare algunas dudillas que me salgan.
Al final lo que ocurria era que el juego se quedaba pillado en la linea:
LOOP JMP LOOP
Pero si la quitaba el programa se iba al garete, lo que hice fue crear una Etiqueta llamada PARAMETROS una vez terminada la rutina de carga de Bitmap,..en la famosa linea del bucle cambien esto:
LOOP JMP PARAMETROS
Y solucionado!!!,..el programa sigue su curso sin verse afectado.
Un saludo.
-
Te ha quedado muyyyyyyyyy chulo. Un buen comienzo para un matamarcianos.
-
Ya tengo preparado un Plan de Batalla que lleva muchas mejoras en la Churufleta,..en especial me interesa la de superar la barrera de los 255 en la Coordenada X,...Alguien me puede dar un poco de luz?:
PROXIMAS MEJORAS:
- CAMBIAR CONFIGURACION DE COLORES EN SPRITES PARA PODER VARIAR COLORES EN NAVES ENEMIGAS
- CREAR UN NUEVO SPRITE DE "FUEGO DE REACTORES"
- AGREGAR EL NUEVO SPRITE Y HACER QUE APAREZCA CUANDO LA NAVE SE MUEVE A LA DERECHA
- MEJORAR LA BITMAP DE FONDO
- SUPERAR LA BARRERA DE LOS 255 EN LA COORDENADA X POR LO MENOS PARA LAS NAVES ENEMIGAS
- DETECTAR COLISION DE SPRITES
- MEJORAR EL TEMA DEL LASER UNA VEZ DISPARADO
- MODIFICAR EN ZIG-ZAG EL MOVIMIENTO DE LAS NAVES ENEMIGAS
- INCLUIR BITMAP DE PRESENTACION Y JUGAR AL PULSAR CUALQUIER TECLA
- INCLUIR MUSICA
AL HIERRO!!!
-
Ya tengo preparado un Plan de Batalla que lleva muchas mejoras en la Churufleta,..en especial me interesa la de superar la barrera de los 255 en la Coordenada X,...Alguien me puede dar un poco de luz?:
para superar esa barrera de los 255, lo que tienes que hacer es guardar las coordenadas x e y en variables (aunque se puede prescindir de variables, te recomiendo asi), siendo la variable que guarda la coordenada X del tamaño de un word (16 bits) y la de la coord. Y, en un simple byte.
A la hora de querer visualizar el sprite, haremos unas pocas comprobaciones sobre la coord. X, nos interesa saber si el bit mas a la izq. de todo de su byte alto está encendido o no, y lo traspasaremos al registro MSB X del VIC para el sprite que pertoque (con ayuda de la máscara que lo representa).
Aunque se puede hacer de varias maneras, aqui te va un ejemplo:
(registros del VIC:)
VIC_SPR_XMSB = $d012
VIC_SPR_X = $d000
VIC_SPR_Y = $d001
(variables y constantes:)
VIC_SPR_MASK = 1 ; para el sprite 0 (ya sabes, 1,2,4,8,16,32,64,128, o 2 elevado al num. sprite, siendo los sprites numerados del 0 al 7)
spr_x: .word 0
spr_y: .byte 0
lda spr_x
sta VIC_SPR_X ; metemos el byte bajo de la variable que guarda la coord. X
; en el registro del VIC del sprite correspondiente
; en este caso el primero, o sprite "0"
lda #VIC_SPR_MASK ; cargamos el acu con el cod. de mascara del sprite
ldx spr_x+1 ; obtenemos en x el byte alto de la coord. X
beq no_aj ; si el byte alto es = 0 no habrá que ajustar: saltamos...
; en caso contrario, valores >255, ajustamos:
ora VIC_SPR_XMSB ; aqui al hacer un ORA encedemos el bit del sprite
; indicado por VIC_SPR_MASK en el reg. VIC_SPR_XMSB
bne nz ; salto incondicional para saltar bloque de ajustes
; en este caso la condicion siempre se cumplirá
; es como poner jmp nz, pero es más economico asi
no_aj: eor #$ff ; invertimos el valor cuando no habia
; que ajustar ya que esto nos permite
; "jugar" con la instruccion que sigue
and VIC_SPR_XMSB ; pone a 0 o no, según si se ajustó o no
nz: sta VIC_SPR_XMSB ; ACTUALIZA el registro del VIC que guarda el XMSB
lda spr_y ; ACTUALIZA la coordenada Y tal cual
sta VIC_SPR_Y ; de la variable al registro del VIC del sprite 0
Cualquier duda me preguntas. Te va quedando muy chula la churufleta, ánimo Raúl! ;) me alegra saber de ti despues de varios dias, luego te contesto los correos con calma.
-
Gracias Lobo, la verdad es que con el listado que me has dejado creo que no voy a tener ningun problema, te contare segun lo vaya haciendo, ademas que veo que no voy a tener que cambiar nada de la sintaxis para que me lo compile sin problemas el 64Tass...
Unas ultimas preguntas:
- ¿tendre que hacer una rutina nueva para cada sprites, no?
- ¿en que lugar del listado coloco cada rutina, en los momentos donde se regula el movimiento derecha izquierda de la Nave, Enemigos o Disparo?
Bueno tronco, seguimos hablando por privado y vamos preparando algo para Retrospectiva 2012.
AL HIERRO REVIVERO!!!
-
Manu, en la Pagina 2 de este hilo en relacion al programa que estabas mejorando dijiste esto:
"Por otro lado, también he mejorado el movimiento, ya que antes me limitaba a los primeros 256 píxeles de ancho, y ahora se recorren los 320"
Me interesa tu opinion o listadito en relacion al tema de superar los 255 en la Coordenada X.
SALUDOS!!!
-
Yo lo que hago es una comparación, y ajusto los registros correspondientes. Aquí tienes el trozo de código que anima un sprite a partir de una tabla precalculada de senos:
; print sprite 1
sprite1:
inc x1
bne calculatey1
; if x1 == 0
lda $d010
ora #$02
sta $d010
calculatey1:
ldx x1
lda $d010
and #$02
cmp #$02
bne loady1
; if x1 > 256
ldy #SINETABLE+256,x
txa
cmp #$40
bne prints1
; if x1 > 320
lda $d010
and #$fd
sta $d010
lda #$00
sta x1
beq prints1
loady1:
ldy #SINETABLE,x
prints1:
stx $d002
sty $d003
-
- ¿tendre que hacer una rutina nueva para cada sprites, no?
puedes hacer una rutina nueva para cada sprite, con su variable independiente (xspr1, xspr2, etc) para lo cual es recomendable usar macros.
O crear una tabla de sprites y una rutina general tipo PutSprite y llamarla con parámetros con JSR.
de esta manera recorrerias la tabla de todos los sprites y los irias imprimiendo en pantalla en sus coordenadas.
Por ejemplo seria:
IMPRIME_SPRITES:
; imprime 5 sprites en sus correspondientes coordenadas
XSPR: .word 0
XSPRITES: .word 50,80,90,100,110
YSPRITES .byte 60,80,100,120,150
ldx #$00
BUCLE: lda YSPRITES,x
tay
lda XSPRITES,x
sta XSPR
lda XSPRITES+1,x
sta XSPR+1
txa
pha
jsr PUTSPRITE ; entradas: la variable de 16 bits temporal XSPR, en el reg. y la coord. vert. Y
pla
tax
inx
cpx #5
bne BUCLE
jmp MAIN
Esto sólo imprimiria los sprites en sus coordenadas. En otro punto del programa deberias hacer un bucle similar (o si se tercia dentro de este mismo), donde modificaras las coordenadas para crear los movimientos, claro.
- ¿en que lugar del listado coloco cada rutina, en los momentos donde se regula el movimiento derecha izquierda de la Nave, Enemigos o Disparo?
En todo programa o juego, hay un bucle principal (el motor en si de todo programa) donde se van llamando a todas las rutinas una a una de forma continua. El orden en que hagas las llamadas, es el que dicta la lógica mayormente. Aqui te pongo un pseudocódigo:
(puedes poner las rutinas directamente en lugar de llamarlas con un JSR donde pertoque, aunque por motivos de claridad lo pongo asi)
/* Esqueleto de un videojuego cualquiera */
JSR PORTADA
INICIO:
JSR MENU
JSR INICIALIZA_VARIABLES
JSR INICIALIZA_VIC
JSR INICIALIZA_SID
JSR IMPRIME_FONDO
MAIN: JSR IMPRIME_SPRITES
JSR COMPRUEBA_CONTROLES ; y actualiza coordenadas de movimientos del player
JSR MUEVE_ENEMIGOS ; La "IA" de los enemigos, actualiza movimientos según
; ciertas reglas
JSR COMPRUEBA_COLISIONES_PLAYER ; actualiza VIDAS si hubo colision critica
JSR COMPRUEBA_COLISIONES_ENEMIGOS ; actualiza desaparicion enemigos
lda VIDAS
beq FIN
JMP MAIN
FIN: JSR GAMEOVER ; llama pantalla de GAME OVER
JMP INICIO ; inicio de todo otra vez
por supuesto faltan otras cosas (comprbobar si pasó de nivel, cargar nuevo mapa de nivel, etc), pero ya vale para un plan general, que te hagas una idea de la "macro" estructura interna de un juego con sus bloques que lo componen relacionados.
Salu2!
-
Ah! otro consejo, intenta encontrar posiciones de la pág. 0 (direcciones desde 0-255, pero excluye 0 y 1) para las variables que intervengan en la impresión de sprites que te conté. Asi todo quedará más compacto y irá más rápido. Ten en cuenta que si tu juego no va a emplear el basic tienes una gran selección de bytes libres de esa página!! y son como tener registros adicionales del 6510
La velocidad de ejecución y lo que ocupan en memoria toda instrucción con direccionamiento de pag 0 es más rápida y ocupa bastante menos espacio que con los demás direccionamientos.
-
ERES UNA MAQUINA!!!,..esta semana vuelvo al curro de vacas y estare mas ocupado, en el proximo Claustro le dare mas caña y volvere con mas preguntas y avances, que no esta mal hablar por aqui estos temas, ya que quedan guardados y a la gente que comience le puede venir bien como consulta...Hablamos.
AL HIERRO!!
-
Buenasl, hoy que libro me he levantado a puñetazos otra vez con esto,...esta vez lo que quiero es mostrar una pantalla de presentacion en la Churufleta antes de pasar al juego, he hecho la siguiente prueba y funciona:
- Muestro la pantalla como hacia y una vez mostrada introduzco este pequeño listado que dejo Nathan hace tiempo en otro hilo con el cual el ordenador se queda esperando a que el jugador pulse espacio y luego continua su curso
ESPACIO
LDA $DC01
CMP #$EF
BNE ESPACIO
Para luego mostrar un sprite,...hasta aqui todo va bien, primero me muestra la bitmap y luego tras pulsar espacio me muestra un sprite.
El problema viene cuando lo que quiero hacer es que me muestre una bitmap y al pulsar espacio me muestre OTRA BITMAP, pero no se porque leches cuando hago esto el programa no se queda esperando que se pulse espacio, sino que ignora la rutinilla y carga la siguiente DEL TIRON!!!
Las bitmaps las cargo en la misma posicion las dos, primero una y luego otra, pero como os cuento no se queda esperando que pulse espacio,...si en vez de dos bitmpas lo hago primero una bitmap y luego un sprite si funciona, pero si lo hago con dos bitmaps ignora la rutina de espera.
-
Aqui comienza el programa y carga la primera bitmap (en ; LOAD BITMAP) , pero en ;ESPACIO no se queda esperando que el jugador pulse la tecla espacio:
*=$0801 ; 2049 POSITION
.WORD NEXT,10 ; PUNTERO SIGUIENTE LINEA Y NUM. LINEA 10
.NULL $9E,^START ; "SYS START" (START=INICIO C.M.)
NEXT .WORD 0 ; END BASIC
.INCLUDE HARDWARE.INC ;DIRECTIVA DE ETIQUETAS
FRAMES .BYTE 0 ; VIDEO FRAMES COUNTER
; LOAD SPRITES
*=$0EC0 ; 3776 POSITION
.BINARY SPRITES.BIN
; START
START SEI ; OFF INTERRUPTS
; UNKONW
LDA $D018
AND #$F1
ORA #$0A
STA $D018
; CLEAR SCREEN
LDA #$20
LDX #$00
CLS STA $0400,X
STA $0500,X
STA $0600,X
STA $0700,X
DEX
BNE CLS
; LOAD BITMAP
LDA $4710
STA $D020
STA $D021
LDX #$00
LOADDCCIMAGE
LDA $3F40,X
STA $0400,X
LDA $4040,X
STA $0500,X
LDA $4140,X
STA $0600,X
LDA $4240,X
STA $0700,X
LDA $4328,X
STA $D800,X
LDA $4428,X
STA $D900,X
LDA $4528,X
STA $DA00,X
LDA $4628,X
STA $DB00,X
INX
BNE LOADDCCIMAGE
LDA #$3B
STA $D011
LDA #$18
STA $D016
LDA #$18
STA $D018
BUCLE
JMP PARAMETROS
*=$1FFE ; 8190 POSITION
.BINARY "PRESENTACION.PRG"
PARAMETROS
; SCREEN COLOR
LDA #$08 ; ORANGE
STA $0286 ; 646 CURSOR POSITION
LDA #$00 ; BLACK
STA $D020 ; SCREEN BORDER
LDA #$00 ; BLACK
STA $D021 ; SCREEN
ESPACIO
LDA $DC01
CMP #$EF
BNE ESPACIO
Sino que tira como un cohete y carga la segunda (En ; BITMAP 2), sin embargo con la segunda si se queda esperando a que se pulse espacio en ;ESPA aqui lo veis:
; BITMAP 2
LDA $4710
STA $D020
STA $D021
LDX #$00
LOADIMAGE
LDA $3F40,X
STA $0400,X
LDA $4040,X
STA $0500,X
LDA $4140,X
STA $0600,X
LDA $4240,X
STA $0700,X
LDA $4328,X
STA $D800,X
LDA $4428,X
STA $D900,X
LDA $4528,X
STA $DA00,X
LDA $4628,X
STA $DB00,X
INX
BNE LOADIMAGE
LDA #$3B
STA $D011
LDA #$18
STA $D016
LDA #$18
STA $D018
CONTINUA
JMP CONT
*=$1FFE ; 8190 POSITION
.BINARY "BITMAP.PRG"
CONT
ESPA
LDA $DC01
CMP #$EF
BNE ESPA
y una vez que es pulsado espacio el programa continua su curso y es mostrado el sprite:
; SCREEN COLOR
LDA #$08 ; ORANGE
STA $0286 ; 646 CURSOR POSITION
LDA #$00 ; BLACK
STA $D020 ; SCREEN BORDER
LDA #$00 ; BLACK
STA $D021 ; SCREEN
; SPRITE POINTERS
LDA #$3B ; BLOCK 59 RIGHT
STA $07F8 ; SPRITE 0 POINTER 2040
; SPRITE COLOR
LDA #$01 ; WHITE
STA SP0COL ; SPRITE 0 NAVE
; SPRITE MULTICOLOR 1 Y 2
LDA #$0B ; 11 DARK GRAY
STA SPMC0 ; MCOLOR 1
LDA #$06 ; BLUE
STA SPMC1 ; MCOLOR 2
; ASIGNAR POSICION INICIAL SPRITES
LDA #0
STA MSIGX
LDA #70
STA SP0X ; X SPRITE 0
LDA #110
STA SP0Y ; Y SPRITE 0
; ON MULTICOLOR SPRITES
LDA #$FF
STA SPMC
; OFF KEYS
LDA 224
STA CIDDRA
; ***************
; * MAINLOOP *
; ***************
UPDATE
; ON SPRITES
LDA #$0F ; ON 0 1 2 3
STA SPENA ; SPRITE ENABLE
MAINLOOP
; WAIT ELECTRONS´ACE
LDA RASTER
CMP #$FF
BNE MAINLOOP
FIN
JMP FIN
Ya os digo que el problema viene al cargar dos bitmaps y marcar la condicion de pulsar espacio para mostrar la segunda y luego el sprite, cosa que no hace, sin embargo con una sola bitmap si lo hace, de hecho entre el intervalo de mostrar la segunda bitmap y el sprite si funcion, pero en el intervalo de la primera y segunda bitmap no se queda esperando.
-
O si alguien me lo puede explicar adjuntando alguna rutinita que tengo se lo agradezco, la historia es esta por orden de actuacion
1º - Mostrar una Bimap (presentacion)
2º - Solicitar al jugador que pulse espacio o cualquier tecla (dependiendo de la rutina)
3º - El programa sigue su curso
3º - Mostrar otra Bitmap (bitmap) que cargo en la misma posicion donde estaba la anterior y comienza el juego.
-
Creo, asi de pronto, que es que el buffer de teclado contiene varias pulsaciones de la tecla espacio (recuerda que en CM todo va rapidisimo). Deberias vaciar el buffer o poner a cero la variable que registra tecla pulsada (no me he fijado en tu código todavia exactamente). Pero esa podria ser la causa, y esta mi pista ;)
Para borrar el buffer de teclas, sólo tenemos que poner a 0 la posición de memoria $c6.
Haz una prueba simple, en lugar de esperar una pulsación de tecla, pon un buen retardo entre bitmap y bitmap... o usa CHARIN del SO, para esperar una tecla, en lugar de la rutina de Nathan...
te paso mi rutina que usé en RN, para pasar entre bitmaps:
Antes una anotación al respecto: en el inicio de la demo configuro todas las teclas como no autorepetibles, asi:
lda #$7f
sta $28a // las teclas no repiten
De esta manera al pulsar un espacio no se llena el buffer de espacios con una pequeña pulsación, y sólo entra 1 pulsación por toque de tecla.
En la rutina, se comprueba si se pulsa espacio o el disparo del joy en port 2. Se desconecta el teclado para que no interfiera en la lectura del joystick ya que ambos teclado y joystick estan integrados en el mismo CIA.
.const GETIN = $ffe4 // GET IN para entrada de char en a
.macro desconecta_teclado() {
lda #$f4
sta $dc02
}
.macro conecta_teclado() {
lda #$ff
sta $dc02
}
espera_pulsador:
!:
:conecta_teclado()
lda $dc00
cmp #$6f // disparador joy port 2?
beq !end+
jsr GETIN
cmp #$20 // tecla espacio?
beq !end+
cmp #$0d
beq !end+
cmp #$d2 // Shift + R Restart demo
bne !-
jmp back2menu
!end: lda #$00
sta $c6 // ignora buffer de teclado
:desconecta_teclado()
rts
-
Leyendote más detenidamente no estoy seguro que lo que dije en el post anterior sea la causa. Aunque puede servirte, eso seguro.
Y es que a simple vista, veo un fallo muy gordo. Incluyes los datos de los bitmap ambos, en $1fffe...
Independientemente de si esta es la causa de que "no espere espacio", no puedes poner los datos de los dos bitmaps ubicados en el mismo sitio, el segundo pisará al primero. ¡Esa puede ser la causa que no veas el primero!... Lo raro es que el compilador no te haya dado un warning o un error informándote que usas porciones de memoria iguales...
Mira a ver esto.
Edito: Simplemente pon la otra bitmap justo debajo de la primera (nunca en la MISMA posición), o carga las bitmaps de disco, antes y despues de pulsar espacio, para que siempre se carguen en $1ffe. Si haces esto, hazte una rutina que cargue el bitmap pasandole los parametros de nombre de fichero y que lo muestre tras cargarlo en memoria, para evitar bytes adicionales engordando el programa.
Mirate en codebase wiki como se carga un fichero de disco:
http://codebase64.org/doku.php?id=base:loading_a_file (http://codebase64.org/doku.php?id=base:loading_a_file)
-
interesante todo lo que dices dos puntos:
- Curioso lo de que una pulsacion lleve varios impulsos, me acuerdo que eso me pasaba en basic y de ahi que sustutuyera algunos get por input porque se pulsaban solos al pasar de una pagina a otra.
No se hasta que punto las varias pulsaciones que almacena sea el problema, ya que yo no toco el teclado para nada, simplemente arranco con autostar en el vice, asi todo es curioso que si paso de una bitmap a mostrar un sprite el ordenador si se queda esperando que se pulse una tecla,...pero si lo hago de que muestre una bitmap y luego otra, el programa ignora la espera de pulsacion de espacio y tira como un cohete (cosa que no entiendo)
- alomejor influye el tema de cargar las dos bitmaps en el mismo sitio, pero utilizo la misma posicion porque una vez mostrada la pantalla de presentacion y no la vuelvo a utilizar y uso ese espacio para mostrar otra, asi todo sigo sin entender porque no para en la rutina de espera de pulsacion de espacio, no tenia porque influir la carga de la segunda, ya que dicha rutina esta antes de que comience la rutina de carga de la segunda..
Voy a probar algunas cosas de las que me has dicho y te cuento.
No termino de entender porque no se puede utilizar un mismo espacio para cargar y mostrar dos bitmaps en diferente momento en el tiempo, me cuentas.
Saludos!!!
-
No se puede utilizar un mismo espacio para cargar y mostrar dos bitmaps dentro del código, por que el compilador al crear el PRG pone las cosas en su sitio. Y un sitio solo es UN sitio :D
Ten en cuenta que un compilador interpreta cada linea del codigo y la va poniendo por orden en el fichero PRG que luego se cargara del tiron en la memoria en ese orden secuencial.
Si no le dices nada ira poniendo cada linea compilada a partir de la cuenta que lleve del Puntero contador de programa (PC). Con una directiva del ensamblador puedes decirle al compilador que en ese punto olvide la cuenta del PC que lleva (internamente) y decirle una nueva, lo que hará será poner ceros (o un byte predefinido) a partir del PC actual hasta el que tu le has dado y esa será su nueva cuenta de PC.
Es secuencial. Si le dices que ponga el PC en una dirección que ya habia compilado cosas, las pisará, o dará una advertencia/error de solapamiento de bloques, según que compilador uses...
-
Adjunto la foto del mapa de memoria de la churufleta actualizado:
(http://a3.sphotos.ak.fbcdn.net/hphotos-ak-prn1/532689_249675418482135_912856237_n.jpg)
no puedes poner los datos de los dos bitmaps ubicados en el mismo sitio, el segundo pisará al primero. ¡Esa puede ser la causa que no veas el primero!...
Lo curioso es que entre ambas esta la rutina de espera de pulsacion de espacio la cual ignora (no lo entiendo)
Simplemente pon la otra bitmap justo debajo de la primera (nunca en la MISMA posición),
Comnooorrr?,..donde es "debajo", porque fijate que ya me voy quedando con el sitio justo, de hecho metere la musica en el bufer de cassette, y en esa zona amplia donde cargo la bitmap $1FFE imagino que solo me entra una.
Como siempre Gracias...Que pesado soy con mis preguntitas!!!
Aviso: Hemos contestado los dos a la vez,..que rapidez!!!
-
va a ser lo que dices en el ultimo correo, al ser compilado se guardan solo los datos de la ultima bitmap en dicha posicion y se solapa,..es verdad!!!,..tiene logica, luego estudiare tus correos atentamente,..voy a la ducha y a cenar que acabo de llegar de currar!!
-
otra peguntita...una de las dos bitmaps podria ser almacenada en el Banco 1 para ser llamada y utilizada sin problemas cuando quieres en el Banco 0?
Hoy en el curro he estado todo el dia dandole vueltas a esto (cada vez me mola mas) y tambien a Retrospectiva.
HABLAMOS!!!
-
Si vas a poner más cosas, como música y tal te quedarás sin espacio.
Es que incrustar 2 bitmaps, son 16K, algo excesivo, sin compresión almenos... Te recomiendo que los bitmaps los pongas en el disco y desde ahi los cargues.
Por supuesto, deja el "segmento" donde se ubicarán los bitmaps al cargarse, en tu listado fuente reservando los bytes que ocupe un bitmap (lo que ocupa el fichero, exceptuando la cabecera de 2 bytes de dirección)
yo en kickass lo hago asi:
// espacio para carga de bitmaps
BITMAP_BUFFER:
.fill 10000, 0
Tambien te recomiendo que uses etiquetas/constantes intensivamente en tus rutinas. Por que si tienes que cambiar algo no tienes que modificar una constante que aparece en 20 sitios, no tienes que modificar 20 lineas solo 1, la de la definición de la constante.
Por ejemplo cuando visualizas el bitmap, en lugar de usar $1ffe usa una constante como BITMAPSTART (que tenga asignado ese valor). Incluso como todas las posiciones están relacionadas con el comienzo del bitmap, luego puedes usar expresiones matemáticas como por ejemplo, BITMAPSTART+256 y cosas asi... Es un consejo que te doy, y creéme que es muy útil ;)
-
CONCLUSION: como tu dices es imposible meter dos bitmaps en ese espacio, osea QUE PASO de momento del tema de dos bitmaps en la churufleta, total, todavia tengo cosas para mejorar, voy a probar otras, quiero hacer lo de superar la barrera de los 255 y ponerle musica.
- CREAR UN NUEVO SPRITE DE "FUEGO DE REACTORES"
- AGREGAR EL NUEVO SPRITE Y HACER QUE APAREZCA CUANDO LA NAVE SE MUEVE A LA DERECHA
- MEJORAR LA BITMAP DE FONDO
- SUPERAR LA BARRERA DE LOS 255 EN LA COORDENADA X POR LO MENOS PARA LAS NAVES ENEMIGAS
- DETECTAR COLISION DE SPRITES
- MEJORAR EL TEMA DEL LASER UNA VEZ DISPARADO
- MODIFICAR EN ZIG-ZAG EL MOVIMIENTO DE LAS NAVES ENEMIGAS
- INCLUIR MUSICA
AL HIERRO!!!
-
otra peguntita...una de las dos bitmaps podria ser almacenada en el Banco 1 para ser llamada y utilizada sin problemas cuando quieres en el Banco 0?
Tu puedes poner los bitmaps donde quieras (y que tengas sitio) en la memoria, lo de cambiar de banco es a la hora de visualizarlos. Si tienes el bitmap almacenado en el banco 1 para verlo, tienes que configurar el vic para que "vea" en el banco 1 y si está en el 0, pues lo mismo pero en ese banco. Ahora bien, la screen ram y la color ram deben estar bien configuradas en el VIC tambien para "apuntar" al sitio correcto.
-
Es que ahora que lo pienso, mi programa funcionaba PERFECTO!!!,...que ocurria?
Que al compilar dos bitmaps en la misma posicion, solo se quedaron los datos de la ultima (la segunda), es decir me mostraba los mismos graficos en las dos, el programa funcionaba bien solo que me estaba mostrando dos bitmaps iguales y por eso no notaba el cambio.
Algo mas que he aprendido.
-
eso es :D
-
Una nueva preguntita, esta vez sencilla:
Muestro una Bitmap de Presentacion, al ser pulsado Espacio el programa sigue su curso, es decir la Bitmap es borrada de la Pantalla pero no desaparece completamente, quedan Pixeles perdidos, imagino que es porque no desactivo antes el modo Bitmap y vuelvo al modo texto.
¿Alguien me puede decir como desactivo el Modo Bitmap y activo el Modo texto?
En esta foto podeis ver como la P. De Presentacion no se borra totalmente:
(http://a4.sphotos.ak.fbcdn.net/hphotos-ak-ash3/553758_252865711496439_542941255_n.jpg)
Como siempre Mil Gracias
-
Para poner el modo texto usando C (ese lenguaje que tanto te gusta jaja):
poke(0xD011, peek(0xD011) & 0xDF);
De todos modos la lógica creo que se entiende bien asi lo pasas a ensamblador: leer 0xD011, con el valor leído hacer AND con 0xDF y volver a ponerlo en 0xD011
Lo otro que puedes hacer es rellenar toda la memoria de la pantalla de video con 00.
-
Gracias Jose, lo unico que no me termino de enterar bien con la explicacion que me adjuntas, a ver si alguien me pude dar luz sobre el tema en un lenguaje mas de Ensamblador.
Ya que estoy aqui, otra preguntita:
Mostrada la Bitmap al jugador se le pide que pulse ESPACIO y se queda a la espera con esta rutina:
;WAIT SPACE
SPACE
LDA $DC01
CMP #$EF
BNE SPACE
Pero me encuentro que el ESPACIO interfiere con el Disparo, es decir, cuando comienza el juego,..comienza disparando, ocurre lo que decia Lobo de que el ordenador guarda varias pulsaciones, a pesar de que adjunto esta otra rutina que hace que el ordenador solo cuente UNA pulsacion,..el fallo persiste:
; NOT REPEAT KEY
LDA #$7F
STA $28A
Y aqui mi pregunta,...quiero cambiar la pulsacion de la tecla, es decir que en vez de ESPACIO se pulse por ejemplo: RETURN (ENTER), o CUALQUIER TECLA o simplemente la "S",...alguien me podria pasar alguna rutinilla enla que el ordenador se quede esperando que el jugador pulse RETURN (como primera opcion) o alguna de las otras opciones que he dicho?
SALUDOS!!!
-
Gracias Jose, lo unico que no me termino de enterar bien con la explicacion que me adjuntas, a ver si alguien me pude dar luz sobre el tema en un lenguaje mas de Ensamblador.
Yo creo que sería asi, pero tampoco lo podría asegurar!
LDA $D011
AND #$DF
STA $D011
-
Ya,.... si eso segun lo has escrito tu lo entiendo perfectamente e incluso yo mismo te lo podria haber hecho,..lo que me refiero que no entiendo es que para activar el modo texto tengas que utilizar la Logica AND (solo ambos bits encendidos) para dicha accion ya que no se trata de "comparar" nada,..sino de "activar"
Consultando en el curso al que se enlaza veo esto,..aqui va una rutina de activacion de modo texto en la que no se utiliza AND para nada:
LDA #1B
STA $D011
Voy a probarlo a ver si ya funciona bien...os cuento.
-
En realidad habría que saber qué hacen los otros bits de $D011, ya que el AND se usa para modificar sólo el bit del modo texto y no a los demás.
-
Comorrr??,..Gracias Jose.
-
El tema es asi, $D011 se usa para varias cosas:
Bits #0-#2: Vertical raster scroll.
Bit #3: Screen height; 0 = 24 rows; 1 = 25 rows.
Bit #4: 0 = Screen off, complete screen is covered by border; 1 = Screen on, normal screen contents are visible.
Bit #5: 0 = Text mode; 1 = Bitmap mode.
Bit #6: 1 = Extended background mode on.
Bit #7: Read: Current raster line (bit #8). Write: Raster line to generate interrupt at (bit #8).
Valor por defecto de $D011: $1B, %00011011.
Para poner el modo texto solo tenemos que desactivar el bit#5 y el resto no tocarlos porque sino estarías haciendo alguna de las otras cosas que se controlan con los otros bits, por eso para hacerlo de forma segura hay que usar el AND asi:
LDA $D011
AND #%11011111
STA $D011
Para estas asignaciones el ensamblador es realmente bueno y claro! algún día me pondré a trastear, ¡promesa!
-
Para poner el modo texto:
1º) desactivar el modo bitmap, desactivando el bit 5 en $d011
2º) ajustar las posiciones de la RAM de video si fueran distintas (usualmente lo son). La RAM de color es siempre fija en $d800. Por supuesto el banco del VIC debe cambiarse al que pertenezca la dirección de la nueva RAM de video.
3º) ajustar la dirección del generador de caracteres. Esto es, el lugar de memoria donde se alojan los patrones de pixels (bits) de cada caracter, en el modo de texto estándard, la memoria de video es un indice directo a esta tabla del generador de caracteres.
4º) ajustar el banco en el VIC
5º) informar el SO (kernal) de la nueva dirección de la RAM de video (sólo si pretendes usar el editor de pantalla en BASIC correctamente, o rutinas relacionadas del kernal/basic)
Aquí te pongo mi código para cambiar al modo texto:
// --------------------------------------
// Modo texto estandard 40 x 25
// --------------------------------------
modo_texto:
:set_vic_bank(VIC_BANK_TXT)
//configura ram video y memoria generador caracteres ($d018)
lda #[[txtmem & $3fff] / 64] | [[chmem & $3fff] / 1024]
sta $d018
lda #[txtmem/256]
sta $0288 // informamos al kernal de la nueva mem. pantalla
lda $d011 // valor estandar para modo texto (modo bmp off, etc)
and #%11011111 // modo bitmap (bit5) = 0
sta $d011
lda #$08
sta $d016 // valores estandar VIC modo texto
rts
txtmem, es la dirección donde comienza mi ram de video (del modo texto)
chmem, es la dirección donde comienza mi generador de caracteres (del modo texto)
La macro para cambiar de banco, ya la puse antes, y bueno seguro que ya sabes como hacerlo, a tu manera.
El bit 4 en $d016, controla el modo multicolor (on/off). Podria haberlo configurado con máscaras binarias, pero me resulta más práctico, en este caso, poner el valor estándar del modo texto en $d016. Este valor, simplemente se averigua haciendo un PEEK en basic, nada más encender el ordenador.
Espero que te sirva. ;)
-
Para leer cualquier tecla, de forma sencilla, usa la rutina del SO llamada GETIN ($ffe4)
al llamarla, en el acumulador tienes el codigo ASCII (PETSCII hablando apropiadamente) de la tecla pulsada...
Si se pulsó una A, es 65, B es 66, etc.
si pulsas RETURN, el código 13
Supongo que tendrás el manual del c64 a mano por ahi (hay una tabla con todos los códigos en los apéndices)
De todas maneras es más rapido saber el código desde el mismo basic:
PRINT ASC("A")
65
ahi te va un ejemplo de GETIN, en ensamblador donde se espera a que se pulse return:
lda #$00
sta $c6 // limpia buffer de teclado
espera_tecla:
jsr $ffe4
cmp #13
beq pulsaron_return
bne espera_tecla
pulsaron_return:
rts
es como usar el GET del basic...
Para CALIGULA, creo que pulsar S quedaria bien (cód. "S" = 83).
-
Bueno, y ya lo último de hoy...
Sorpresita (http://dl.dropbox.com/u/37131/c64/pac.zip)
Ejecutar el prg y luego hacer un SYS2064
La verdad esto esto es más fácil de lo que pensaba...
Que chulo Manu!
Hace un tiempo queria hacer una demo en c64 usando senos y cosenos, en ensamblador (por supuesto con tablas)
Algo asi hacia hace tiempo, pero se me ha olvidado...
Podrias ponerme como generaste la tabla de senos, o la "fórmula" ? Por que tiene tela pasar un valor de -1 a 1 a una coordenada de pantalla de 0...200 por ejemplo para la Y...
En código máquina los números decimales son una pesadilla para mi... y quiero ampliar mis conocimientos sobre ellos ¿Que consejos podrias darme acerca de usarlos? Tengo pendiente estudiar bien el tema de los FAC del SO, pero tambien y más importante saber como van realmente los números en coma flotante, esos que les sumas una constante y tal...
Te agradeceria si pudieras arrojarme algo más de luz en estos campos (o quien lo sepa bien por aqui)
Salu2!
-
La respuesta es muy sencilla...
Sinus Creator (http://www.pouet.net/prod.php?which=14718)
Sólo me limité a copiar y pegar xD
-
Gracias, yo hacia estas cosas con un programa en basic. Sinus Creator es lo que necesito.
Hace poco me acordé de un detalle sobre todo esto... para que el numero de -1 a 1 en la tabla oscilara habia que multiplicarlo por una constante de escalado y luego redondearlo con INT (en basic) a lo que se le añade, por supuesto coord. de centrado!!
¿de lo de coma flotante y tal, ni papa no?
-
Muchas Gracias a todos!!!,..ahora Jueves, Viernes y Sabado estoy "petado" de Curro, pero el Domingo me pongo a "digerir" toda la información.
SALUDOS!!!
-
Lobo, lo de la coma flotante la verdad es que se me escapa un poco (de no usarlo), aunque me acuerdo que lo vi en la universidad y no era complicado :)
-
Ok, Manu, yo algo sabia hace tiempo tambien, recuerdo que se guardaban como dos bytes por ejemplo 10 05 era 10,5 y que se multiplicaban por un factor... etc, pero me veo liado a la hora de aplicarlo seriamente, se que no era muy dificil ( pero tenia su telilla) y la verdad, no recuerdo casi nada !!
A ver si me leo algún documento por ahi y lo vuelvo a pillar... de momento con tablas precalculadas ya me apañaré jeje
-
Jose, fue muy interesante la explicacion de las distintas funciones de los Bits en dicha posicion,..luego Lobo me lo explico por privado (en una autentica tarde de batalla, que no olvidare),..la rutina que muestra Lobo hace unos calculos que son necesarios para establecer los inicios de la Memoria de Video y la de Color en los distintos Bancos de Memorias segun se situen...Lobo me ha mandado unas Tablas que ya te dan los valores para hacer los calculos sencillos y darle al Yunque que son Bestiales!!!
El Caso es que si queremos fijar el principio en el Banco 0 y con los valores por defecto,..todo "digeridito" y "picadito" se le queda al Hierro en esto:
TEXT MODE
LDA #$14
STA $D018
LDA #$1B
STA $D011
LDA #$08
STA $D016 Visto asi parece sencillo pero detras hay que hacer ciertos calculos...
Gracias Lobo por todo, como siempre!!!, sigo diciendo que esas Tablas que me has mandado son MONUMENTALES y me van a venir divinas...y sobre todo por esas explicaciones desinteresadas en tiempo real durante mas de una y dos horas de Claustro!!!
SALUDOS!!
-
De nada, ¡ un placer ayudarte ! ;)
Esas tablas que te di son una ampliación que meticulosamente me puse a calcular hace tiempo, a partir de la tabla del banco 0, según aparece en la guia de referencia del programador de Commodore. Durante mucho tiempo me han resultado muy útiles, evitándome tener que hacer sumas de banco y tal, hasta que hallé esa pequeña fórmula, aún más ahorradora de tiempo je je
-
Estaría bien que esas tablas aparecieran en el curso Tutorial sobre ensamblador :)
-
Te lo adjunto yo en esta Respuesta en un archivo, aquí las tienes, las tablas te dan los valores (A) de la Memoria de Pantalla y de Caracter segun el banco que utilices y dependiendo en que posicion de memoria lo situes (veras que dan saltos minimos para que entren los Sets), luego aplicando un OR a los dos resultados llegas al valor final que tendras que atribuir a $D018.
Saludos!!!
(Tablas para calculos para distintas acciones tengo mas, te mando las referidas a lo que nos ocupaba que es volver al Modo Texto en los diferentes Bancos.)
-
Gracias, muy interesante
para programar en ensamblador es imprescindible conocer todas estas cosillas de como se organiza la memoria
-
@Zonacas: Por supuesto, todo ese material, y todo lo que tenga, o pueda elaborar, lo iré añadiendo de una forma u otra en el curso de ensamblador que estoy haciendo.
-
Está claro que hay que leerse todos los hilos del foro.
Sinus creator es practiquisismo!!!.
Que ganas tengo de empezar mis 2 semanitas de vacaciones para poder poner en práctica lo que voy viendo por aquí.
-
Una pena que a Lobogris se lo haya tragado la estepa :-(
-
Una pena que a Lobogris se lo haya tragado la estepa :-(
Este forero hizo mucho por y para enseñar. Pero en fin, la gente va y viene.
Queda su legado y para mi ha sido muy útil, lo cual le agradezco.
Este donde este, le deseo lo mejor.