ELF 1, LA AVENTURA

javymetal · Mensajepor **javymetal** » Mar 08 Sep , 2015 11:42 am

Bueno, os presento este proyecto que llevo entre manos. Se trata de una adaptación del juego de pc ELF en formato aventura conversacional para Amstrad CPC. He elegido este juego porque siempre me ha gustado y que mejor manera para probar mi "parser" en basic.

Iré subiendo capturas de pantalla.

Portada:

Imagen

Historia:

El juego:

Dentro del marco superior estarán los gráficos de las localidades y en el inferior los objetos que llevemos (en modo edición me informa de la localidad y turnos).

Actualmente lleva los caracteres del Spectrum, cuando saque tiempo pasaré los del DAAD. (Si alguien las tiene pasadas a basic me haría un gran favor).
Como podéis ver queda mucho trabajo. Ya iré subiendo avances del juego.

Espero que os guste. Un saludo.

6128 · Mensajepor **6128** » Mar 08 Sep , 2015 12:01 pm

Como te dije en el otro foro te está quedando muy chula. En cuanto a los gráficos esas tonalidades anaranjadas tirando a marrón me evocan al Iron Lord de CPC.

javymetal · Mensajepor **javymetal** » Mar 08 Sep , 2015 12:42 pm

Cierto. Además le da un "aire" antiguo jajajaja

Mensajepor **Artaburu** » Mar 08 Sep , 2015 1:58 pm

Tiene muy bien aspecto!
Una duda, lo haces en Locomotive Basic? Las imágenes ocuparán bastante aun comprimidas. Planteas que sea versión en disco y que se acceda a las imágenes en tiempo de ejecución?

javymetal · Mensajepor **javymetal** » Mar 08 Sep , 2015 2:06 pm

En Locomotive Basic si.
La idea es esa principalmente, ir cargando las imagenes desde disco, aunque en algunas zonas se repetirían.

Mensajepor **MiguelSky** » Mar 08 Sep , 2015 2:18 pm

Mola, javymetal !! Deja que te mire eso de la fuente del DAAD. No prefieres otra?

javymetal · Mensajepor **javymetal** » Mar 08 Sep , 2015 2:51 pm

Es cuestión de probar MiguelSky, pero la del DAAD me trae grandes recuerdos.

Mensajepor **Artaburu** » Mié 09 Sep , 2015 8:21 pm

JAvymnetal me ha planteado l pregunta de cómo meter pantallas comprimidas que se carguen desde disco durante la ejecución.
A mí la solución que se me ocurre es cargar un descompresor en memoria antes de cargar el juego en BASIC (o cargarlo en las primeras líneas) par utilizarlo para descomprimir las pantallas que cargas desde disco.

Veo dos posibilidades. Una fácil pero menos "profesional" que consiste en comprimir pantallas enteras (con el marco y todo) y otra algo más compleja en la que tienes solo guardadas las imágenes de las pantallas pero solo la región del dibujo en sí.

Primer caso:
Necesitas un buffer donde cargar el archivo comprimido desde disco. Se carga con: load"dibujo",&dirección_datos_comprimidos
Una vez cargado ejecutas la rutina descompresora para que se descomprima en la pantalla con algo así:
call &dirección_rutina, &dirección_datos_comprimidos, &C000.

Segundo caso:
Esta es más compleja técnicamente y necesita más memoria,
Necesitas un buffer donde cargar el archivo comprimido desde disco y otro donde llevar el archivo descomprimido.
LA carga del archivo comprimido es como en el primer caso, la descompresión es igual también solo que no descomprimes en &c000 sino en el segundo buffer.
Y como paso final, necesitas una rutina que lea la imagen descomprimida y la lleve a la pantalla, concretamente dentro del marco donde va el dibujo de la localidad.

En cualquier caso, necesitas comprimir la imagen. Tienes dos buenas opciones de hacerlo desde MSDOS (o ventana Windows) con Pucrunch y con Exomizer. Si comprimes una pantalla, tienes que tener cuidado y comprimir sin la cabecera AMSDOS, si la extraes de un disco mira que no la lleve (WinApe te da es opción) o quítala con un editor hexadecimal (son los primeros 128 bytes).

Luego el archivo comprimido lo metes en un disco como cualquier otro archivo.

Dale una vuelta a ver si te cuadra esta opción, si vas a tener memoria libre para cargar los archivos comprimidos, creo que como vas desde BASIC andarás un poco apurado pero es cuestión de ver lo que te ocupa el archivo comprimido y la memoria que tienes libre. Además como lees desde disco no se si te compensa mucho liarte comprimiendo pantallas.

De todas formas, si te animas a probar, ya te preparamos los compresores para que puedas usarlos desde BASIC (no se si ya existen o están colgados por ahí)

6128 · Mensajepor **6128** » Mié 09 Sep , 2015 8:28 pm

Aunque se repitan pantallas y use disco para almacenarlas creo que si le compensa comprimir imágenes.

javymetal · Mensajepor **javymetal** » Mié 09 Sep , 2015 8:56 pm

Pues casi que prefiero usar la 1ª opción, comprimir imágenes completas (con marco y todo).
Dime que necesito y me pongo al lío.

Por cierto ya tengo una demo de 14 localidades (sin graficos). Queréis probarla?

Mensajepor **Artaburu** » Mié 09 Sep , 2015 9:15 pm

Aquí tienes los compresores y un editor hexadecimal para DOS.

Para comprimir:

Código: Seleccionar todo

pucrunch -d -c0 filein fileout

exo filein fileout

javymetal · Mensajepor **javymetal** » Mié 09 Sep , 2015 9:49 pm

Vaya lío!!, en cuanto pueda pruebo a ver que tal.

Lo que si se nota es mucha diferencia de carga y ejecución del Basic con respecto al DAAD.

Mensajepor **Artaburu** » Mié 09 Sep , 2015 10:06 pm

El descompresor en un disco con un ejemplillo. Está compilado en &a000, hay que cargarlo en esa posición de memoria. Si quieres otra, te dejo abajo el código fuente del unexo.

el uso para descomprimir es:
call &a000, origen, destino, tamaño

En la demo, cargo el archivo comprimido en &7000, y lo descomprimo en &c000 y ocupa &3ba bytes (sin cabecera)
call &a000,&7000,&c000,&b3a

Ojo que el archivo lo debes comprimir sin cabecera pero cuando esté en el disco debe tener cabecera. Imagino que las utilidades de disco para meter binarios pueden añadir la cabecera. Yo tengo un método más rústico que es usando WinApe, cargo el binario usando incbin"nombre" y luego lo grabo en disco y así se le pone la cabecera.

Código: Seleccionar todo

org &a000



di

push ix

push iy

ld ix,10

add ix,sp



ld h,(ix+5)

ld l,(ix+4)





ld d,(ix+3)

ld e,(ix+2)



ld b,(ix+1)

ld c,(ix+0)





.decod2

	

	call deexo

	

pop iy

pop ix

ei

	ret

	



.deexo

		ld	ixh,128



		ld	b,52

		ld	iy,exo_mapbasebits

		push	de

.exo_initbits

		ld	a,b

		sub	4

		and	15

		jr	nz,exo_node1



		ld	de,1		;DE=b2

.exo_node1

		ld	c,16

.exo_get4bits

		call	exo_getbit

		rl	c

		jr	nc,exo_get4bits

		ld	(iy+0),c	;bits(i)=b1



		push	hl

		inc	c

		ld	hl,0

		scf

.exo_setbit

		adc	hl,hl

		dec	c

		jr	nz,exo_setbit

		ld	(iy+52),e

		ld	(iy+104),d	;base(i)=b2

		add	hl,de

		ex	de,hl

		inc	iy



		pop	hl

		djnz	exo_initbits

		inc	c

		

.exo_literalseq

		pop	de

.exo_literalcopy

;		ldir			;copy literal(s)

		LD B,C

.buc_test

		; dec bc

		 ld a,(hl)

		 ld (de),a

		 INC HL

		 inc DE

		 djnz buc_test



.exo_mainloop

		ld	c,1

		call	exo_getbit	;literal?

		jr	c,exo_literalcopy

		ld	c,255

.exo_getindex

		inc	c

		call	exo_getbit

		jr	nc,exo_getindex

		ld	a,c		;C=index

		cp	16

		ret	z

		jr	c,exo_continue

		push	de

		ld	d,16

		call	exo_getbits

		jr	exo_literalseq

.exo_continue

		push	de

		call	exo_getpair

		push	bc

		pop	af

		ex	af,af'		;lenght in AF'

		ld	de,512+48	;1?

		dec	bc

		ld	a,b

		or	c

		jr	z,exo_goforit

		ld	de,1024+32

		dec	bc		;2?

		ld	a,b

		or	c

		jr	z,exo_goforit

		ld	e,16

.exo_goforit

		call	exo_getbits

		ld	a,e

		add	a,c

		ld	c,a

		call	exo_getpair	;bc=offset

		pop	de		;de=destination

		push	hl		

		ld	h,d

		ld	l,e

		sbc	hl,bc		;hl=origin

		ex	af,af'

		push	af

		pop	bc		;bc=lenght







		;ldir			;copy literal(s)









.buc_test2



		 ld a,(hl)

		 ld (de),a

		 INC HL

		 inc DE

		 dec bc

		 xor a

		 cp c

		 JR NZ, buc_test2		 

		 CP B

		 JR NZ, buc_test2









		pop	hl		;Keep HL, DE is updated

		jr	exo_mainloop	;Next!



.exo_getpair

		ld	iy,exo_mapbasebits

		ld	b,0

		add	iy,bc

		ld	d,(iy+0)

		call	exo_getbits

		ld	a,c

		add	a,(iy+52)

		ld	c,a

		ld	a,b

		adc	a,(iy+104)

		ld	b,a

		ret



.exo_getbits

		ld	bc,0		;get D bits in BC

.exo_gettingbits

		dec	d

		ret	m

		call	exo_getbit

		rl	c

		rl	b

		jr	exo_gettingbits



.exo_getbit

		ld	a,ixh		;get one bit

		add	a,a

		ld	ixh,a

		ret	nz

		ld	a,(hl)

		inc	hl

		rla

		ld	ixh,a

		ret



.exo_mapbasebits

defs	156	;tables for bits, baseL, baseHsave

_eof

6128 · Mensajepor **6128** » Mié 09 Sep , 2015 10:47 pm

Lo que si se nota es mucha diferencia de carga y ejecución del Basic con respecto al DAAD.

Pero programándolo como lo estás haciendo controlas mucho más el acabado artístico del juego.

Mode 2 · Mensajepor **Mode 2** » Jue 10 Sep , 2015 9:45 am

Lo que si se nota es mucha diferencia de carga y ejecución del Basic con respecto al DAAD.
Pero programándolo como lo estás haciendo controlas mucho más el acabado artístico del juego.

Ante todo felicidades por el proyecto, javymetal.

Efectivamente, como dice 6128, mejor tener libertad que ceñirte a algo más 'cuadriculado' aunque pierdas velocidad. Yo tengo un proyecto bastante parecido al tuyo ahora... por desgracia se está eternizando, cosas de tener tiempo y de ser un anárquico pérdido.

Segundo caso:
Esta es más compleja técnicamente y necesita más memoria,
Necesitas un buffer donde cargar el archivo comprimido desde disco y otro donde llevar el archivo descomprimido.
LA carga del archivo comprimido es como en el primer caso, la descompresión es igual también solo que no descomprimes en &c000 sino en el segundo buffer.
Y como paso final, necesitas una rutina que lea la imagen descomprimida y la lleve a la pantalla, concretamente dentro del marco donde va el dibujo de la localidad.

Arta, esa es la opción que he tomado para el 'Zombi Terror', pero a la hora de volcar la pantalla recuerdo que me salía basura, creo que lo hable contigo. Estoy haciendolo en Locomotive Basic más rutinas en ensamblador.

Saludos.