Primeros pasos para pogramar un emulador

[Bubu]

OK, ZX-81, para mí esa es desde luego la parte más fácil, pues es todo operaciones con bits, etc, y eso lo controlo bastante.

Por cierto, me imagino que como lenguaje de pogramación, el 100% me aconsejaréis VC++, ¿nor? ¿se puede encasquetar el VC++ al entonno "Visual Studio Code?

[robcfg]

Claro que se puede: https://code.visualstudio.com/docs/languages/cpp

Hay mucha información en internet si tienes cualquier problema.

[Bubu]

Aro, lo malo es dibujar la pantalla. Por lo que veo el VC++ en VS-Code sólo es pal código, no hay un entonno gráfico pa poner menús, botones, etc. Creo que la solución es con el VS-Community.

[chernandezba]

Por cierto, me imagino que como lenguaje de pogramación, el 100% me aconsejaréis VC++, ¿nor? ¿se puede encasquetar el VC++ al entonno "Visual Studio Code?

100%?? No, como recordarás yo dije C, puro y duro, nada de Visual ni de ++
El Visual Studio Core puedes usarlo como editor, también tienes Atom o CLion, cada cual con sus gustos

[chernandezba]

OK, ZX-81, para mí esa es desde luego la parte más fácil, pues es todo operaciones con bits, etc, y eso lo controlo bastante.

Si te refieres a emular el Z80, no basta con saber de bits. Como te dice @ZX-81, hay que hacerlo muy bien o habrán juegos que fallarán.
Sobretodo temas de opcodes no documentados, comportamientos no documentados o la memoria contenida... si no haces esto perfecto, aunque sepas de operaciones de bits, pues...

[Namek]

Me he animado y voy a intentar hacer un emulador de Spectrum lo mas básico posible, estoy usando FreeBASIC y por ahora tengo la representacion de la pantalla sin efecto FLASH por ahora, a ver que os parece...

Se podria simplificar este código? Ya que lo que me interesa es simplicidad, no rendimiento, mi idea es que pueda servir de base a los interesados.

Código: Seleccionar todo

DIM MEMORY(65536) AS BYTE
DIM key AS STRING
DIM AS INTEGER X,Y1,Y2,Y3,SCR,ATTR,INK,PAPER,COL,BORDER
DIM V AS BYTE

SCREEN 14,8

dim as integer mypal(0 to 255)
mypal(1)=&hB90000
mypal(2)=&h0000B9
mypal(3)=&hB900B9
mypal(4)=&h00B900
mypal(5)=&hB9B900
mypal(6)=&h00B9B9
mypal(7)=&hB9B9B9
mypal(9)=&hFF0000
mypal(10)=&h0000FF
mypal(11)=&hFF00FF
mypal(12)=&h00FF00
mypal(13)=&hFFFF00
mypal(14)=&h00FFFF
mypal(15)=&hFFFFFF
palette using mypal

open "screen.scr" for binary as #1

SCR=16384
do until(eof(1))
    get #1,,V
    MEMORY(SCR)=V
    SCR=SCR+1
loop
close #1

BORDER=0
ATTR=22528
SCR=16384

mypal(0)=mypal(BORDER)
palette using mypal

FOR Y1=24 TO 215 STEP 64
    FOR Y2=0 TO 7
        FOR Y3=Y1+Y2 TO Y1+63 STEP 8
            FOR X=32 TO 287 STEP 8
                INK=MEMORY(ATTR) AND 7
                PAPER=(MEMORY(ATTR) AND 56)/8
                IF (MEMORY(ATTR) AND 64)=64 THEN
                    INK=INK+8
                    PAPER=PAPER+8
                END IF
                IF INK=0 THEN INK=8
                IF PAPER=0 THEN PAPER=8

                V=MEMORY(SCR)
                COL=PAPER
                IF V<0 THEN
                    COL=INK
                    V=V+128
                END IF
                PSET (X,Y3),COL
                COL=PAPER
                IF V>63 THEN
                    COL=INK
                    V=V-64
                END IF
                PSET (X+1,Y3),COL
                COL=PAPER
                IF V>31 THEN
                    COL=INK
                    V=V-32
                END IF
                PSET (X+2,Y3),COL
                COL=PAPER
                IF V>15 THEN
                    COL=INK
                    V=V-16
                END IF
                PSET (X+3,Y3),COL
                COL=PAPER
                IF V>7 THEN
                    COL=INK
                    V=V-8
                END IF
                PSET (X+4,Y3),COL
                COL=PAPER
                IF V>3 THEN
                    COL=INK
                    V=V-4
                END IF
                PSET (X+5,Y3),COL
                COL=PAPER
                IF V>1 THEN
                    COL=INK
                    V=V-2
                END IF
                PSET (X+6,Y3),COL
                COL=PAPER
                IF V=1 THEN COL=INK
                PSET (X+7,Y3),COL
                SCR=SCR+1
                ATTR=ATTR+1
            NEXT X
        NEXT Y3
        IF Y2<7 THEN ATTR=ATTR-256
    NEXT Y2
NEXT Y1

WHILE key=""
    key=INKEY
WEND


[Urusergi]

Me he animado y voy a intentar hacer un emulador de Spectrum lo mas básico posible, estoy usando FreeBASIC y por ahora tengo la representacion de la pantalla sin efecto FLASH por ahora, a ver que os parece...

Lo he intentado pero solo me aparecen dos ventanas en negro

EDIT: Ah! vale, es que hace falta un archivo .scr
Ahora si que funciona, estoy viendo la pantalla del Athena y es la reos$·%

[dondiego]

Por lo que veo el VC++ en VS-Code sólo es pal código

Es que el VS Code no es un IDE es un editor. El IDE es el VS 2017.
Yo uso tanto VS (porque tengo que hacerlo) como Code::Blocks con MinGW y en linux (gcc).
El editor de VS no me convence mucho y el compilador de C no vale nada, reconocido por ellos mismos, no soporta ni C99. El de C++ tampoco es que sea muy bueno que digamos.

[Bubu]

Namek, el poblema es que FreeBASIC no implementa disparadores (triggers), y sin ellos nu sé cómo vas a hacer que el Z80 ejecute cosas y la ULA muestre los pantallazos, ni sé cómo vas a controlar los timings.
Lo que sí veo que es un acierto es a la hora de pintar: simplemente haces PSET y ya tienes un puntito dibujado.

dondiego, yo estoy ahora instalando el VS Community, que sí integra IDE's, y además le instalas el VC++ y por lo visto va fino, fino. A ver si lo consigo y te cuenco. Si alguien tiene una opción mejón soy todo orejas.

[Namek]

Namek, el poblema es que FreeBASIC no implementa disparadores (triggers), y sin ellos nu sé cómo vas a hacer que el Z80 ejecute cosas y la ULA muestre los pantallazos, ni sé cómo vas a controlar los timings.
Lo que sí veo que es un acierto es a la hora de pintar: simplemente haces PSET y ya tienes un puntito dibujado.

Pues simplemente voy a usar una variable para el PC (Program Counter) y empezando desde el valor 0 ire leyendo el byte al que apunte y segun que valor sea emulare la instruccion del Z80 correspondiente, y cada cierto numero de operaciones dibujare la pantalla y a ver que pasa... Los timings los ignoraré miserablemente por ahora...