Emulador de CHIP8 en basic

[Hark0]

@Jepalza, cappicci


Cuanto más leo, más fascinado estoy con el Chip-8.

Resumiendo, se trataba de un "lenguaje" de programación que se incluía en kits DIY que se vendieron allá por 1976... las máquinas se podian programar en código máquina o bien usar el interprete de Chip-8.

Por ejemplo, buscar "RCA Cosmo VIP Manual", para encontrar el manual de una de estas máquinas... muy bueno.

He descargado también de la web mencionada en mi post anterior de la foto, las revistas que se publicaron en aquella época acerca del Cosmo VIP, llamada "Viper",... SUPER interesantes... me he "tragado" ya las de la primera "temporada" y tienen contenido para flipar... muy recomentable

He estado probando casi todos los emuladores que he encontrado para windows del Chip-8. Me encuentro con el problema de que NO todos los emuladores funcionan correctamente... o bien no dibujan correctamente, o no detectan bien el teclado, o ambas !!??

Como tampoco pude lanzar la máquina de @Jepalza por desconocer FBC / FBIde, me dispuse a leer documentación técnica acerca de los opcodes, memoria, etc.... y a trabajar!

En fin, he empezado mi emulador, he declarado todos los registros, la memoria, un "driver" de teclado y otro para el display... el mainloop también lo tengo implementado... así que hoy me pelearé con la parte más "cachonda" del juego... leer e interpretar correctamente los opcodes...

Ya os cuento!

[jepalza]

Cuanto más leo, más fascinado estoy con el Chip-8.

Eso me ocurrió a mi hace porrón de años, cuando hice el emulador en QBasic45. Por entonces traté de añadirle soporte de SCHIP8 (Super Chip 8), pero no lo terminé, quedó a medias.

Como tampoco pude lanzar la máquina de @Jepalza por desconocer FBC / FBIde

Si es muy simple.... Si ves el pantallazo que puesto antes, solo es ir al menú desplegable, elegir "Deprecated console" y darle a run o F5.... (dos pasos)

tengo el original en QB45, si es necesario lo pego aquí.

[Hark0]

Cuanto más leo, más fascinado estoy con el Chip-8.

Eso me ocurrió a mi hace porrón de años, cuando hice el emulador en QBasic45. Por entonces traté de añadirle soporte de SCHIP8 (Super Chip 8), pero no lo terminé, quedó a medias.

Como tampoco pude lanzar la máquina de @Jepalza por desconocer FBC / FBIde

Si es muy simple.... Si ves el pantallazo que puesto antes, solo es ir al menú desplegable, elegir "Deprecated console" y darle a run o F5.... (dos pasos)

tengo el original en QB45, si es necesario lo pego aquí.

Yo me he enamorado desde luego... aunque no olvido a mi amante de toda la vida (ZX Spectrum)

Si si, ya lo he leido, luego lo pruebo.

Tengo también el QB45, lo compre en una tienda hace 1 vida, jutno con 1 dsikettera de 3 1/2... (7500 ptas de la epoca la disketera)

Si lo subes, mejor para mi (todos) ;D

[jepalza]

Pues aquí va: (acuérdate del copirrite y esas cosas ;- ) )

Código: Seleccionar todo

DEFINT A-Z
DECLARE SUB RUNCPU ()
WIDTH 80, 50

DIM SHARED RAM(4096): REM ­SOLO TIENE UN TOTAL DE 4K DE RAM!

DIM SHARED STACK(16): REM PILA DE MAXIMO DE 16 SALTOS A SUBRUTINAS
DIM SHARED V(16): REM REGISTROS DE VARIABLES DE 0 A F. LA V(F) ES LA DE ESTADOS
DIM SHARED VK(16): REM REGISTROS DE TECLAS DE 0 A F

KR = 0: REM REGISTRO DE TECLA PULSADA (DE 0 A F)
RI = 0: REM REGISTRO INDEXADO "I" DE 12 BITS
PILA = 0: REM DIRECCION DE LA PILA DE RETORNO (MAXIMO 16)
RST = 0: REM RESET SI RST=1
DIR = &H200: REM INICIO DE PROGRAMA SIEMPRE EN LA &H200

CLS
RANDOMIZE TIMER: REM PARA LA SUBRUTINA DE NUMEROS ALEATORIOS


FOR F = 0 TO 15: V(F) = 0: NEXT: REM INICIALIZA LAS VARIABLES

REM CARGA LAS FUENTES EN LA DIRECCION 0 DE LA RAM
D = 0
FOR F = 1 TO 40
READ A
RAM(D) = (A AND &HF0)
D = D + 1
RAM(D) = (A AND &HF) * 16
D = D + 1
NEXT F

FF = 0
AA = 1: BB = 1
DIM FILES$(50): REM max 50 ficheros . ­OJO!
SHELL "dir /B /ON games >files": REM SEGUN VERSION DEL MSDOS DE WIN98
OPEN "files" FOR INPUT AS 1
WHILE NOT EOF(1)
FF = FF + 1
LINE INPUT #1, FILES$(FF)
WEND
CLOSE 1

INICIO:
FOR F = 1 TO 48 - (48 - FF)
LOCATE F, 1: PRINT F; TAB(6); FILES$(F);
   OPEN "GAMES\" + FILES$(F) FOR BINARY ACCESS READ AS 1
   A$ = "  "
   REG& = 1
   WHILE REG& < 100
   GET #1, REG&, A$
   IF A$ = CHR$(0) + CHR$(255) THEN COLOR 6, 0: PRINT TAB(20); "SUPER CHIP8": COLOR 7, 0
   REG& = REG& + 2
   WEND
   CLOSE 1
NEXT

LOCATE AA, 6: COLOR 0, 7: PRINT FILES$(AA); : COLOR 7, 0
1
A$ = UCASE$(INKEY$): IF A$ = "" THEN GOTO 1
IF A$ = CHR$(27) THEN CLS : END
IF LEN(A$) = 2 THEN IF RIGHT$(A$, 1) = "P" THEN AA = AA + 1
IF LEN(A$) = 2 THEN IF RIGHT$(A$, 1) = "H" THEN AA = AA - 1
IF A$ = CHR$(13) THEN N$ = FILES$(AA): CLS : GOTO EMPIEZA
IF AA < 1 THEN AA = FF - 1
IF AA > FF - 1 THEN AA = 1
LOCATE AA, 6: COLOR 0, 7: PRINT FILES$(AA); : COLOR 7, 0
IF BB <> AA THEN LOCATE BB, 6: COLOR 7, 0: PRINT FILES$(BB); : BB = AA
GOTO 1

EMPIEZA:
     
       FOR F = 8 TO 80 - 7: LOCATE 1, F: PRINT CHR$(254): NEXT
       FOR F = 2 TO 33: LOCATE F, 8: PRINT CHR$(254): LOCATE F, 80 - 7: PRINT CHR$(254): NEXT
       FOR F = 8 TO 80 - 7: LOCATE 34, F: PRINT CHR$(254): NEXT

OPEN "GAMES\" + N$ FOR BINARY ACCESS READ AS 1

A$ = " "
REG& = 1: REM PARA SUPERCHIP8, PONER 129 EN VEZ DE 1
D = &H200
WHILE NOT EOF(1)
GET #1, REG&, A$: RAM(D) = ASC(A$)
D = D + 1
REG& = REG& + 1
WEND
CLOSE 1

BUCLE:
  CALL RUNCPU
  IF SALIR = 1 THEN CLS : DIR = &H200: SALIR = 0: GOTO INICIO
GOTO BUCLE


REM DATOS DE LAS FUENTES INTERNAS (SPRITE FONTS) EN LA DIRECCION &H0
REM PARA LOS CARACTERES "0" AL "9", Y "A" A "F" DE 5*8 PIXELS
DATA &Hf9,&H99,&Hf2,&H62,&H27
DATA &Hf1,&Hf8,&Hff,&H1f,&H1f
DATA &H99,&Hf1,&H1f,&H8f,&H1f
DATA &Hf8,&Hf9,&Hff,&H12,&H44
DATA &Hf9,&Hf9,&Hff,&H9f,&H1f
DATA &Hf9,&Hf9,&H9e,&H9e,&H9e
DATA &Hf8,&H88,&Hfe,&H99,&H9e
DATA &Hf8,&Hf8,&Hff,&H8f,&H88

SUB RUNCPU
SHARED RI, DIR, PILA, PAUSA, SALIR

REM RI=REGISTRO INDEXADO

REM FOR F# = 0 TO 10000: NEXT: REM PAUSA DE PRUEBAS

REM CADA VEZ QUE SE EJECUTA UNA INSTRUCCION, DESCUENTA UN 1 A CONTADOR DE PAUSA
PAUSA = PAUSA - 1: : IF PAUSA < 0 THEN PAUSA = 0

REM LEE TECLAS PARA ALMACENAR LA PULSADA EN VK(x)
FOR F = 0 TO 15: VK(F) = 0: NEXT F
INK$ = UCASE$(INKEY$)
    TECLA = 0
    IF (INK$ >= "0" AND INK$ <= "9") = -1 THEN TECLA = VAL(INK$)
    IF (INK$ >= "A" AND INK$ <= "F") = -1 THEN TECLA = VAL("&H" + INK$)
    VK(TECLA) = 1
IF INK$ = CHR$(27) THEN SALIR = 1
OPH = RAM(DIR)
OPL = RAM(DIR + 1)

REM SOLO DEBUG
REM GOTO NODEBUG
LOCATE 35, 1
PRINT "DIRECCION:"; HEX$(DIR); " OPCODE:"; HEX$(OPH); " "; HEX$(OPL); "   "
PRINT "RI="; HEX$(RI); "    "
PRINT "PILA="; PILA; " --> "; HEX$(STACK(PILA)); "   "
FOR F = 0 TO 7: LOCATE 40 + F, 40: PRINT "V"; HEX$(F); ":"; HEX$(V(F)); " "; V(F); "    ": NEXT
FOR F = 8 TO 15: LOCATE 40 + (F - 8), 60: PRINT "V"; HEX$(F); ":"; HEX$(V(F)); " "; V(F); "    ": NEXT
REM A$ = INPUT$(1)
NODEBUG:

DIR = DIR + 2

N0 = (OPH AND &HF0) / 16
N1 = (OPH AND &HF)
N2 = (OPL AND &HF0) / 16
N3 = (OPL AND &HF)

ON N0 + 1 GOTO s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sa, sb, sc, sd, se, sf

s0:
REM codigos 0 **************************************************************
 
   REM 00E0 --> CLS
   IF OPL = &HE0 THEN
       CLS
       FOR F = 8 TO 80 - 7: LOCATE 1, F: PRINT CHR$(254): NEXT
       FOR F = 2 TO 33: LOCATE F, 8: PRINT CHR$(254): LOCATE F, 80 - 7: PRINT CHR$(254): NEXT
       FOR F = 8 TO 80 - 7: LOCATE 34, F: PRINT CHR$(254): NEXT
   END IF
 
   REM 00EE --> RTS: RETORNO DE SUBRUTINA "JSR (1xxx)"
   IF OPL = &HEE THEN
        IF PILA = 0 THEN PRINT "ERROR: PILA DE RETORNO VACIA.": END
        DIR = STACK(PILA)
        PILA = PILA - 1
        IF PILA < 0 THEN PILA = 0
   END IF

   REM 00FF --> HIGH MODE: ACTIVA MODO SUPER CHIP8 (128x64) (EN PRUEBAS)
   IF OPL = &HFF THEN
      CLS : PRINT "JUEGO DE MODO SUPER CHIP8. NO SOPORTADO POR AHORA.": A$ = INPUT$(1): SALIR = 1
   END IF

EXIT SUB

s1:
REM codigos 1 **************************************************************

   REM 1xxx --> JMP: SALTO SIN RETORNO (INCONDICIONAL)
   DIR = N1 * 256 + OPL
   
EXIT SUB

s2:
REM codigos 2 **************************************************************

   REM 2xxx --> JSR: SALTO CON RETORNO (MAXIMO 16 SALTOS)
   PILA = PILA + 1
   STACK(PILA) = DIR
   IF PILA > 16 THEN PRINT "ERROR: DESBORDAMIENTO DE LA PILA": END
   DIR = N1 * 256 + OPL

EXIT SUB

s3:
REM codigos 3 **************************************************************
 
   REM 3rxx --> SKEQ VR,XX: SALTAR SIGUIENTE DIRECCION (2 BYTES) SI VR=XX
   IF V(N1) = OPL THEN DIR = DIR + 2

EXIT SUB

s4:
REM codigos 4 **************************************************************

   REM 4rxx --> SKNE VR,XX: SALTAR SIGUIENTE DIRECCION (2 BYTES) SI VR<>XX
   IF V(N1) <> OPL THEN DIR = DIR + 2

EXIT SUB

s5:
REM codigos 5 **************************************************************

   REM 5ry0 --> SKEQ VR,VY: SALTAR SIGUIENTE DIRECCION (2 BYTES) SI VR=VY
   IF V(N1) = V(N2) THEN DIR = DIR + 2

EXIT SUB

s6:
REM codigos 6 **************************************************************

   REM 6rxx --> MOV VR,XX: CARGA REGISTRO V(R) CON XX
   V(N1) = OPL

EXIT SUB

s7:
REM codigos 7 **************************************************************

    REM 7rxx --> ADD VR,XX: A¥ADE A V(R) EL VALOR XX (SIN ACARREO)
    V(N1) = (V(N1) + OPL) AND &HFF

EXIT SUB

s8:
REM codigos 8 **************************************************************

    REM 8ry0 --> MOV VR,VY: COPIAR VY EN VR
    IF N3 = 0 THEN V(N1) = V(N2): EXIT SUB

    REM 8ry1 --> OR VR,VY: "OREAR" VY EN VR
    IF N3 = 1 THEN V(N1) = V(N1) OR V(N2): EXIT SUB
   
    REM 8ry2 --> AND VR,VY: "ANDEAR" VY EN VR
    IF N3 = 2 THEN V(N1) = V(N1) AND V(N2): EXIT SUB
   
    REM 8ry3 --> XOR VR,VY: "XOREAR" VY EN VR
    IF N3 = 3 THEN V(N1) = V(N1) XOR V(N2): EXIT SUB
   
    REM 8ry4 --> ADD VR,VY: A¥ADIR A VR EL VY (SIN ACARREO)
    IF N3 = 4 THEN
        V(N1) = V(N1) + V(N2)
        IF V(N1) > 255 THEN V(N1) = V(N1) AND &HFF: V(&HF) = 1 ELSE V(&HF) = 0
        EXIT SUB
    END IF

    REM 8ry5 --> SUB VR,VY: RESTA A VR EL VY (VF=1 SI <0)   **(R - Y)**
    IF N3 = 5 THEN
       V(N1) = V(N1) - V(N2)
       IF V(N1) < 0 THEN V(N1) = 256 + V(N1): V(&HF) = 0 ELSE V(&HF) = 1
       EXIT SUB
    END IF

    REM 8r06 --> SHR VR: ROTA A LA DERECHA EL VR. EL BIT 0 SE CARGA EN VF
    IF N3 = 6 THEN V(&HF) = V(N1) AND 1: V(N1) = V(N1) \ 2: EXIT SUB

    REM 8ry7 --> RSB VR,VY: RESTA A VY EL VR (VF=1 SI <0)   **(Y - R)**
    IF N3 = 7 THEN
       V(N1) = V(N2) - V(N1)
       IF V(N1) < 0 THEN V(N1) = 256 + V(N1): V(&HF) = 0 ELSE V(&HF) = 1
       EXIT SUB
    END IF
   
    REM 8r0E --> SHL YR: ROTA A LA IZQUIERDA EL VR. EL BIT 7 SE CARGA EN VF
    IF N3 = &HE THEN V(&HF) = (V(N1) AND &H80) / &H80: V(N1) = (V(N1) * 2) AND &HFF

EXIT SUB

s9:
REM codigos 9 **************************************************************
 
   REM 9ry0 --> SKEQ VR,VY: SALTAR SIGUIENTE DIRECCION (2 BYTES) SI VR<>VY
   IF V(N1) <> V(N2) THEN DIR = DIR + 2

EXIT SUB

sa:
REM codigos a **************************************************************
   
   REM Axxx --> MVI XXX: CARGA EL INDEXADO CON XXX
   RI = N1 * 256 + OPL

EXIT SUB

sb:
REM codigos b **************************************************************

   REM Bxxx --> JMI XXX : SALTA A XXX + V0 (VARIABLE 0)
   STOP: DIR = (N1 * 256 + OPL) + V(0): REM VERIFICAR
   IF DIR > 4096 THEN PRINT "ERROR: DIRECCION DE SALTO FUERA DE 4096": END

EXIT SUB

sc:
REM codigos c **************************************************************

   REM Crxx --> RAND VR,XX: CARGA EN V(R) EL DATO ALEATORIO MENOR O IGUAL A XX
   V(N1) = RND(1) * OPL

EXIT SUB

sd:
REM codigos d **************************************************************
 
   REM Drys --> SPRITE VR,VY,S : DIBUJA GRAFICO EN "VR,VY" DE ALTURA "S"
   
     X = V(N1)
     Y = V(N2)
     S = N3
     V(&HF) = 0: REM BORRA EL ACARREO

   FOR F = 0 TO S - 1
     
     A = RAM(RI + F)
     G = 256
     WHILE G <> 1
       G = G / 2
       IF A AND G THEN A$ = CHR$(219) ELSE A$ = CHR$(32)
       IF Y > 31 THEN Y = 31: A$ = ""
       IF Y < 0 THEN Y = 0: A$ = ""
       IF X > 63 THEN X = 63: A$ = ""
       IF X < 0 THEN X = 0: A$ = ""
       B = SCREEN(Y + 2, X + 9)
     
       IF (A$ = CHR$(219) AND B = 219) = -1 THEN A$ = CHR$(32): V(&HF) = 1: GOTO NOPINTAR
       IF (A$ = CHR$(219) AND B = 32) = -1 THEN A$ = CHR$(219): GOTO NOPINTAR
       IF (A$ = CHR$(32) AND B = 219) = -1 THEN A$ = CHR$(219): GOTO NOPINTAR
       IF (A$ = CHR$(32) AND B = 32) = -1 THEN A$ = CHR$(32):  GOTO NOPINTAR

NOPINTAR:
       LOCATE Y + 2, X + 9: PRINT A$: X = X + 1
     WEND
     Y = Y + 1: X = V(N1)

   NEXT F
   REM    AA$ = INPUT$(1)

EXIT SUB

se:
REM codigos e **************************************************************

   REM Ek9E --> SKPR K: SALTAR SIGUIENTE DIRECCION (2 BYTES) SI VK(KEY)=1
   IF OPL = &H9E THEN IF VK(N1) = 1 THEN DIR = DIR + 2
 
   REM EkA1 --> SKUP K: SALTAR SIGUIENTE DIRECCION (2 BYTES) SI VK(KEY)=0
   IF OPL = &HA1 THEN IF VK(N1) = 0 THEN DIR = DIR + 2

EXIT SUB

sf:
REM codigos f **************************************************************

   REM Fr07 --> GDELAY VR: CARGA LA PAUSA EN VR
   IF OPL = &H7 THEN V(N1) = PAUSA: EXIT SUB
 
   REM Fr0A --> KEY VR: SE PARA EN ESPERA DE UNA TECLA A PULSAR EN VR
   IF OPL = &HA THEN
      WHILE INK$ = ""
        INK$ = UCASE$(INKEY$)
      WEND
      TECLA = 0
      IF (INK$ >= "0" AND INK$ <= "9") = -1 THEN TECLA = VAL(INK$)
      IF (INK$ >= "A" AND INK$ <= "F") = -1 THEN TECLA = VAL("&H" + INK$)
      V(N1) = TECLA
      EXIT SUB
   END IF

   REM Fr15 --> SDELAY VR: ACTIVA LA PAUSA SEGUN VR
   IF OPL = &H15 THEN PAUSA = V(N1): EXIT SUB
 
   REM Fr18 --> SSOUND VR: EMITE UN SONIDO DE DURACION VR (OJO CON LA DURACION)
   IF OPL = &H18 THEN EXIT SUB: REM SOUND 500, V(N1) / 3: EXIT SUB
 
   REM Fr1E --> ADI VR: A¥ADE AL INDEXADO RI EL CONTENIDO DE VR
   IF OPL = &H1E THEN
      RI = RI + V(N1)
      IF RI > 4095 THEN RI = RI - 4096
      EXIT SUB
   END IF
 
   REM Fr29 --> FONT VR: HACE QUE EL INDEXADO RI APUNTE AL CARACTER VR
   IF OPL = &H29 THEN RI = (V(N1) AND &HF) * 5: EXIT SUB

   REM Fr33 --> BCD VR: ALMACENA EN "RI,RI+1,RI+2" EL BCD DEL VR
   IF OPL = &H33 THEN
      A$ = LTRIM$(RTRIM$(STR$(V(N1))))
      IF LEN(A$) = 1 THEN A$ = "00" + A$
      IF LEN(A$) = 2 THEN A$ = "0" + A$
      B = VAL(MID$(A$, 1, 1))
      C = VAL(MID$(A$, 2, 1))
      D = VAL(MID$(A$, 3, 1))
      RAM(RI + 0) = B
      RAM(RI + 1) = C
      RAM(RI + 2) = D
      EXIT SUB
   END IF

   REM Fr55 --> STR V0-VR: ALMACENA (PUSH) LOS REGISTROS DE V(0) A V(R) EN RI
   IF OPL = &H55 THEN
     FOR F = 0 TO N1
       RAM(RI) = V(F)
       RI = RI + 1
     NEXT
     EXIT SUB
   END IF
 
   REM Fr65 --> LDR V0-VR: RECUPERA (POP ) LOS REGISTROS DE V(0) A V(R) DE RI
   IF OPL = &H65 THEN
     FOR F = 0 TO N1
       V(F) = RAM(RI)
       RI = RI + 1
     NEXT
     EXIT SUB
   END IF

END SUB



No cambia mucho respecto al del FB, pero funciona mejor (problemas de velocidad lo único, que va demasiado rápido)

[Hark0]

BRAVO!

Ahora a buscar los diskettes XD

Por cierto... que he encontrado software para el chip8 para hi-res (Super chip-8), por si te interesa terminar esa parte...

[na_th_an]

No hace falta que busques ningún diskette. Hace diez años recopilé esta lista y un amigo polaco parece que sigue hospedándola: http://deger.republika.pl/Download_MS_B ... rsions.htm

[Hark0]

No hace falta que busques ningún diskette. Hace diez años recopilé esta lista y un amigo polaco parece que sigue hospedándola: http://deger.republika.pl/Download_MS_B ... rsions.htm

Pues me has ahorrado un curro si señor... ya estaba yo pensando donde tenia mis IMG "originales"...

@na_th_an, PEDAZO compilación!!!!

[Hark0]

Tengo una duda acerca del DONDE y EN QUE POSICION exacta se guardan los valores de los registros, variables,etc...

En la wikipedia leo esto:

Código: Seleccionar todo

Las direcciones de memoria del CHIP-8 tienen un rango 200h a FFFh, lo que hacen 3.584 bytes. La razón del porqué la memoria comienza en 200h varía de acuerdo a la máquina. Para el Cosmac VIP y el Telmac 1800, los primeros 512 bytes son reservados para el intérprete. En esa máquinas, los 256 bytes más altos (F00h-FFFh en máquinas de 4K) fueron reservados para el refresco de pantalla, y los 96 bytes más bajos (EA0h-EFFh) fueron reservados para los llamados de la pila, uso interno y otras variables.

Pero en tu emulador @Jepalza, no veo que implementes eso... en otros tampoco lo he visto...

Aunque podemos usar matrices tipo stack[n] o bien V[n] para almacenar los valores de los registros, etc

¿no seria lo suyo ALMACENARLOS en la ubicación de la Ram correspondiente?

Y la otra que no entiendo según el texto que he pegado... ¿256 bytes para la pantalla? ¿como?

[na_th_an]

Así, calculando rápido, 64x32 pixels en monocromo ocuparían 256 bytes.

[jepalza]

No te puedo hablar de cómo hice el emulador. Son muchos años ya. La última vez que le hice algo, fué en 2002, hace 11 años. Como para acordarme de lo que hice.
Pero funciona ¿no? por lo tanto, está bien hecho (y no está inventado, es un emulador en toda regla, de cada INS del CHIP8)