¿Recuerdan el "Cancionero Argentino" que hicimos con los Pungas?
este:
http://csdb.dk/release/?id=153497

Bueno, el código fuente del cancionero esta aca:
https://github.com/c64scene-ar/chipdisk-nac-vol.1


Y no solo eso, sino que hicimos un "cursito" de assembler donde explica como de hace un Chipdisk, contanto todos los truquitos que usamos, y demás.

Esta acá:
http://pungas.space/blog/index.php/tutoriales-tutorials/7-cursito-intermedio-de-asm-para-la-c64-haciendo-un-chipdisk

Si ven algún error, o quieren agregar algo, se puede enviar un "pull request" acá:
https://github.com/c64scene-ar/chipdisk-nac-vol.1/blob/master/chipdisk_internals.es.rst

Preguntas/comentarios más que bienvenidos.

Finalmente pude "recuperar" los fuentes del jueguito que hice para la c128 allá por el '92.

Lo que hice fue pasarle el regenerator:
http://csdb.dk/release/?id=149429

y comentar, ordenar el código un poco. Por ahora lo quiero dejar lo más intacto posible para poder ver de que manera codeaba en el '92. No lo pude dejar intacto ya que tuve que ordenarlo un poco para entender de que se trataba.

Lo que hice también fue generar el mapa con el vchar64 (hice un import de la imagen de VICE + algunos otros dumps) y recuperé bien ese.

Arreglé algunos bugs y lo hice "single load" (todo en un archivo, antes eran 4).

El original se puede bajar de aca: https://github.com/ricardoquesada/c128-the-race/raw/master/bin/therace.d71
El "nuevo" de aca: https://github.com/ricardoquesada/c128-the-race/raw/master/orig/therace.d71
Y los fuentes, para los curiosos, estan aca: https://github.com/ricardoquesada/c128-the-race/tree/master/src


Mis primeras observaciones son:

* El jueguito tiene su complejidad para haberlo hecho solo con el "monitor". La verdad que podría tener muchos más bugs. Y si bien el código es desordenado, no es terrible. Para los que no usaron un "monitor" antes, es un garrón.
* El código se puede optimizar mucho, aunque el jueguito parece no necesitarlo
* Aún no entiendo bien como armé el mapa. Supongo que habré copiado / pegado pedazos de a poco. Usaba mi propio editor allá entonces pero lo único que se podia hacer era mapas de 40x25. Y el jueguito usa un mapa de 512x8

Quizás en el futuro le agregue más niveles, guardar los records y algunas pavadas más.
Así como esta, portarlo para la c64 debería ser trivial ya que no usa nada especifico de la c128.

La hago corta:
¿Alguien con un gamepad Xbox 360 puede probar si se prenden de rojo las flechas?

Bajarse esta aplicación:
http://ricardoquesada.github.io/unijoysticle/bin/unijoysticle_controller-v0.4.1.win32.zip

Poner en "Address": 1.1.1.1 y ir al "Commando mode" y mover el joystick Xbox.

La hago larga

Le agregué soporte al UniJoystiCle para poder jugar a juegos de la C64 usando un joystick de Xbox.
La cosa es que no tengo ningún controlador de Xbox. Ayer me compré un contralador para windows bien bien pedorro, y resulta que es "DirectInput" y que esta deprecado (no tenía ni la más p*** idea que había dos APIs para los joysticks). Pero estoy usando Qt y solo soporta Xinput, que es lo nuevo desde hace algunos años y no es compatible con DirectInput.

Asi que si alguien con un controlador Xbox 360 (o cualquier otro que sea Xinput) puede probar esta aplicación y decirme si las flechas se ponen rojas, le agradeceré!

* Bajar la aplicación de acá: http://ricardoquesada.github.io/unijoysticle/bin/unijoysticle_controller-v0.4.1.win32.zip
* Poner en "Address": 1.1.1.1
* Ir al "Commando Mode" y mover el joystick.

Aclaro: No hace falta tener el unijoysticle. Las flechas se van prender de rojo con o sin unijoysticle.

gracias!!!

Amiguitos,

Tengo algunas placas para regalar / vender el UniJoystiCle.

Antes que nada, todo lo del UniJoystiCle es open source / open hardware asi que cualquiera se puede hacer una.


Para regalar:
 - PCB del unijoysticle solo para aquellos que lo usen con un monociclo.
   A cambio pido que se saquen una foto usandolo.

Para vender:
 - PCB del unijoysticle a $5
 - o la placa armada: PCB + componentes + todo soldado: a $25 c/u
 (baratito baratito para los amiguitos de C.Mania)

El shipping a España no se cuanto cuesta, pero a Holanda me costó $14.50. Supongo que será similar a España.

Que se puede hacer con un UniJoystiCle? Tantas cosas
- Jugar al "The Uni Games" con un monociclo de verdad
- Jugar al Gyruss en modo "Gyruss"
- Jugar al cualquier jueguito en modo D-Pad
- O controlar los dimmer de tu casa en modo Linear

Las placas armadas que ofrezco son estas:



y los PCBs, son eso, pero sin los componentes.


Instrucciones: https://retro.moe/unijoysticle/docs/

Demo usandolo en "UniJoystiCle" mode:
https://www.youtube.com/watch?v=LDTGW7ZXje8

Demo usandolo en "Gyruss" mode:
https://www.youtube.com/watch?v=n2YHoj1pXB8

Demo usandolo en "D-Pad" mode:
https://www.youtube.com/watch?v=RhEGogreM0E

Solo tengo algunas placas disponibles. Si alguien quiere alguna avise rápido. Gracias!

Tengo una c64 que apriori funciona todo bien:
  - puede cargar juegos con la disketera, y funcionan bien
  - sonido y video Ok
  - teclado Ok
  - Joystick Ok (probe uno solo puerto)

Pero cuando enchufo el cartucho de Fast Load, no aparece la pantalla azul/celeste con la leyenda "*** commodore ....".
En vez, aparece una pantalla vacia. No funciona ninguna tecla. Si apreto RunStop + Restore, aparece "READY", pero no puedo hacer nada.

El cartucho de Fast Load parece funcionar bien en otras c64.
Además probé con el 1541U2 (que se que funciona bien), y tiene un problema similar.

Lo curioso es que cartuchos de jueguitos (ej: Centipede) funcionan bien.

Alguna idea donde mirar? que puede se que este roto?
Gracias!

Buenas,

se como grabar una image .d64 a un disquette en una 1541.
pero todavía no encontré como hacer lo mismo con los .d71 + una 1571.

¿alguna idea?
1541-ultimate-II parece que no soporta montar imagenes d71.
TC64 no lo soporta tampoco, y tampoco funciona en la C128.
EasyFlash + EasyTransfer parece que no lo soporta...

gracias!

Radare es un desensamblador, que entre otras cosas soporta asembler del 6502 y también puede leer archivos VSF (los snapshots del VICE).

Escribí 2 articulitos que explican como usarlo (estan en inglés, pero si alguien quiere que traduzca algo al castellano, avise).

* Parte I: introducción: http://retro.moe/2015/11/18/disassembling-6502-code-with-radare-part-i/
* Parte II: VICE snapshots: http://retro.moe/2015/12/09/disassembling-6502-core-with-radare-part-ii/

¡Hola programadores!

Esto no pretende ser un curso de assembler, ni nada parecido.
Solo quiero compartir con Uds. las cosas que voy aprendiendo mientras desarrollo un jueguito. Nada de lo que les voy a contar es nuevo... todo respecto a la c64 ya esta descubierto y bien detallado en codebase64 y otros sitios. De hecho, es de ahí de donde yo aprendo casi todo de la c64.

¿Entonces por qué hago esto si ya esta todo descubierto? Bueno, porque no todo lo que esta en codebase64 se entiende facilmente. Creo que varios artículos presuponen que uno sabe ciertas cosas, y cuesta bastante seguirlos. Y además porque tengo ganas de hacerlo

Yendo al grano, mi primer aprendizaje es...

Cómo hacer un IRQ estable

Si alguna vez trataron de hacer un "raster bar", o un simple scroll fino usando IRQ, habrán notado que la primer linea del raster hace "flicker"... es como que se corre a veces un poco hacia la derecha, o la izquierda y no se sabe bien porque.

Lo que aprendí estos días, es saber porqué pasa eso, y como prevenirlo y de esa manera lograr efectos que se vean bien.

Así es como se ve la intro del jueguito que estoy haciendo:


Basicamente tiene 4 IRQs (Código https://github.com/ricardoquesada/c64-the-race/blob/ec5f2f6b6ec8e1b4c4ad32ca95834af1398aead2/src/intro.s#L108 )

irq1: Pone una barrita violeta. Pone color gris de fondo. Comienza el scroll fino de arriba.
irq2: Pone una barrita violeta. Cambia los colores a negro. Termina el scroll fino.
irq3: Comienza el scroll fino de abajo y pone color gris de fondo.
irq4: Termina con el scroll fino y pone los colores a negro nuevamente.

Parece sencillo, pero para poner las barritas violetas me costó una eternidad.

El tema es que cuando uno esta dentro de una IRQ, el "raster beam" (o haz de luz... no se como se traduce) se sigue moviendo, entonces hay que cambiar los colores en los momentos justos.



( Para saber bien qué es el raster y demás recomiendo leer este articulo: http://dustlayer.com/vic-ii/2013/4/25/vic-ii-for-beginners-beyond-the-screen-rasters-cycle )

Para simplificar las cosas, vamos a asumir que tenemos una c64 PAL (no NTSC).
Del gráfico se puede ver que el raster para hacer una linea entera tarda 63 ciclos de CPU. Y lo más interesante de todo que hay momentos en los que el raster no es visible.
Y es justamente en esos momentos cuando uno tiene que cambiar el color del fondo de pantalla... porque sino el color aparece cortado.

Ejemplo: Aca la barra violeta aparece "cortada"...y es que cambié el color mientras el "raster beam" estaba por la mitad.


Entonces la teoría es sencilla: cambiar el color cuando el "raster beam" esta invisible.

Ciclos, interrupciones y demás:

Cuando uno instala una interrupción raster, uno no puede saber con exactitud cuantos ciclos fueron ejecutados por la siguiente razón:
Supongamos que tengo mi IRQ instalado, y en estoy ejecutando en mi ciclo principal un código que hace algo.
Justo en ese momento se prende mi IRQ ("raster beam" esta en la posición deseada).
El tema es que como la CPU puede estar ejecutando una instrucción, hay que dejar que se termine de ejecutar esa instrucción para que se llama a mi IRQ. Y eso consume ciclos.
Y como hay instrucciones de hasta 7 ciclos, cuando se llama a mi IRQ yo no se cuantos ciclos entre 0 y 7 se ejecutaron de más.

Y es exactamente por este motivo que a veces los raster bars o efectos hacen "flicker"... ya que a veces estan corridos 0, 1, ... y hasta 7 ciclos hacia la "derecha".

Lo que aprendí es que hay varias técnicas para hacer el raster estable: http://codebase64.org/doku.php?id=base:making_stable_raster_routines
Pero la que yo estoy usando en la intro es la "doble IRQ": Basicamente uso una IRQ para lograr que la CPU esta ejecutando un NOP cuando se produzca la siguiente IRQ. Eso se logra poniendo varios NOPs dentro de la primera IRQ, y luego nunca volver (no usar "rti"). De esa manera me garantizo que solo va a haber entre 0 y 1 ciclos de diferencia (y no hasta 7 como antes)... y luego ese ciclo de "sobra" se arregla con una comparación.
Los detalles están aca: http://codebase64.org/doku.php?id=base:stable_raster_routine Si alguien no entiende algo de la técnica "Doble IRQ" con gusto lo explico.

Y eso... basicamente para poner esas 2 barras violetas, tuve que aprender a usar la "doble IRQ" y contar ciclos