Tag Archives: programando NewPong

Programando NewPong. Parte 3

21 Abr

Bueno, pues continuando con el anterior artículo sobre NewPong (https://comunidadmsx.com/2014/03/21/programando-newpong-parte-2/) ya por fin tengo una versión mínimamente funcional para poder subirla y que la podáis probar del juego NewPong (v.0.1) en ensamblador.

NewPong 0.1a

 

NewPong 0.1b

En esta versión podéis:

  •  Jugar con las opciones del menu principal “2 -> Jugador vs Jugador. V” (movimiento sólo en vertical de la raqueta) y “3 -> Jugador vs Jugador. V+H” (movimiento en vertical y horizontal de la raqueta en tu medio campo).
  • Pulsa ESC cuando estés jugando si quieres volver al menu principal.
  • Gana el jugador que marca 9 tantos al contrario.
  • El jugador 1 (izquierda de la pantalla) se controla con los cursores o joystick 1 indistintamente y el jugador 2 (derecha de la pantalla) con el joystick 2.
  • En las siguientes versiones implementaré jugar con dos raquetas cada jugador: una en vertical haciendo de portero y otra que pueda jugar en tu medio campo. También intentaré implementar jugar contra el ordenador… ya veremos que “inteligencia” le consigo simular al MSX… que espero que pueda ganarme… 🙂

Recordar que es una versión beta muy primaria que busca ir aprendiendo y practicando entre todos en el mundo del ensamblador de nuestro MSX, por lo tanto todos los errores que veáis y mejoras que se os ocurran serán bien recibidas.

Por otro lado, al final del artículo, ajunto los ficheros:

  • NPong100.rom. Que es un fichero ejecutable en emulador o directamente en un MSX real.
  • NPong100.asm. Fichero fuente que directamente se carga con el ensamblador cruzado asMSX.
  • NPong100.txt. Es el fichero anterior pero en texto plano para poder echarle un vistazo sin necesidad del ensamblador cruzado.

Como ya comenté en el anterior artículo de programación del NewPong, es una versión basada en el Pong de Eduardo Robsy Petrus y Jon Cortazar Abraido a quien agradezco su trabajo educativo y sobre todo por compartirlo. La idea es, tal y como comenté , la de empezar a trastear con el ensamblador.

Podéis coger el fichero adjunto y empezar por teclear, por ejemplo la rutina de dibujar el campo de juego o la del movimiento de la pelota y conforme la vayáis entendiendo y modificando pues ir avanzando en la programación, con lo cual de forma natural y poco a poco iréis dando forma a vuestro juego y con ello ir aprendiendo mientras practicáis.

Pues con esto espero haberos animado un poco más a ir creando cosillas en ensamblador para nuestros queridos MSX y que así siga vivo su software.

Por favor, comentar todo lo que os ocurra sobre el listado y así entre todos aprenderemos más rápidamente.

Cuando tenga una nueva versión la subiré para seguir compartiendo y aprendiendo.

Descargas

NPong100.rom

NPong100.asm

NPong100.txt

Si algún fichero, por ejemplo el Npong100.txt, en lugar de bajar se abre en otra ventana, utilizar el botón derecho sobre el nombre y la opción de Guardar Enlace/Fichero…

 

Programando NewPong. Parte 2

21 Mar

Hola a todos… Ya hacía tiempo que no escribía por aquí… pero eso no quiere decir que haya abandonado mi MSX… más bien al contrario como ahora os contaré.

NewPong_EnsambladorComo muchos sabéis para mi el MSX está muy ligado a la programación y después de muchos años volví a empezar el programa NewPong (tenéis varios artículos en el Blog sobre este tema) en MSX Basic, pero igual que hace casi treinta años me volví a dar cuenta de la poca velocidad del MSX Basic para realizar este juego… y de nuevo me dije “Tengo que intentarlo con ensamblador”, es decir, la historia se repite tres décadas después 🙂 , pero por diversos motivos y sobre todo yo creo que por el “miedo escénico” a meternos de lleno en este lenguaje de bajo nivel después de tantos años,  nunca veía la forma de empezar.

Pero finalmente, me dije y ¿ por qué no empezar como hace 30 años con el MSX Basic y con el MSX Assembler?, es decir, a base de mirar código e ir haciendo pruebas e ir entendiendo el código y entonces volver a mirar documentación… en fin el proceso que muchos ya seguimos en nuestra época juvenil… y dicho y hecho!!!!!

Me cogí el juego que quería hacer, NewPong (pero ahora en ensamblador) y gracias toda la información sobre ensamblador que hay disponible en la web de KAROSHI, que es de agradecer y con en ensamblador cruzado asMSX (ya hablé sobre este tema en el Blog en el artículo https://comunidadmsx.com/2013/04/12/iniciarnos-en-ensamblador-en-nuestro-msx/) y los ejemplos encontrados en ambos, pues me centré en el Pong de Eduardo Robsy Petrus y Jon Cortazar Abraido (agradecer a ambos su trabajo y esfuerzo y sobre todo por compartirlo con todos los amantes del MSX) y bueno con cambios por aquí y adaptaciones por allá al final estoy haciendo mi propio Pong con varios modos de juego añadidos y también quiero programar jugar contra el ordenador.

Lo que quiero decir es que la mejor forma de empezar a programar en ensamblador es vencer el momento inicial o momento cero y empezar a hacer cosas y sobre todo buscar un juego sencillo que os apetezca a hacer y empezar por él mirando todo el código y documentación que hay disponible en la red.

De momento he dibujado mi propio campo de juego, muevo las raquetas (tanto en sentido vertical , como otro modo de juego en el que la muevo por todo el campo de juego), muevo la pelota, la reboto contra las paredes y las raquetas… ahora estoy investigando en el sonido y después comprobaré cuándo es gol y actualizaré el marcador…. etc, etc..

Ya se que no parece mucho, pero para mi es un logro que vivo como el primer día hace casi treinta años cuando hacía esto en mi MSX y ¡¡¡ esto no tiene precio !!! Como veis estoy muy contento con el tema y os animo a muchos de vosotros que estáis pensando en ello a EMPEZAR CON EL ENSAMBLADOR de nuestro MSX, pues es la forma se seguir enriqueciendo la comunidad con nuevas creaciones que al principio serán muy sencillas pero que poco a poco irán siendo más complejas…

En breve, cuando tenga algo más “funcional” lo iré subiendo tanto el código como el .rom, para que lo vayáis probando y comentando y entre todos aprendamos más rápido.

Antes de finalizar el artículo quisiera dar las GRACIAS con mayúsculas y de forma sincera a todos los que apoyáis el MSX y sobre todo a nivel de programación en ensamblador compartiendo información y generando documentación  y código disponible para toda la comunidad de MSX. Gracias a vosotros nuestro sistema no sólo sigue vivo sino que además CRECE y EVOLUCIONA. ¡¡¡ GRACIAS !!!

Ala!!! que ya casi es fin de semana y no tenéis excusa para empezar con vuestro MSX y el ensamblador, claro está… entre partida y partida… jajajajajaja

Programando NewPong. Parte 1A

12 Mar

Como comenté en un artículo anterior vamos a ir programando y comentando el listado en MSX Basic de NewPong hasta conseguir el juego completo.

newpong1

De momento en la primera parte hemos dibujado el campo de juego, dos palas y una pelota. En esta primera versión solamente se pueden mover las palas por sus campos y la pelota va rebotando por el campo, pero todavía no se ha incorporado la detección de la pelota por parte de las palas (esto lo haremos en la parte 2).

Las palas se mueven con los mandos del cursor y/o joysticks. Las variables P1 y P2  de la línea 200  eligen entre los valores:

0 –> Cursor

1 –> Joystick 1

2 –> Joystick 2

que luego se pasan como parámetros de las órdenes STICK() en las líneas 380 y 470.

Iniciamos con la definición de las variables utilizadas:

X,Y –> Posición (x,y) de la pelota en pantalla.

AX,AY –> Posición (x,y) de la pala A (jugador 1).

BX,BY –> Posición (x,y) de la pala B (jugador 2).

PUNT1$,PUNT2$ –> Puntuación del jugador 1 y jugador 2.

VEL –> Velocidad del movimiento de la pelota.

VELP –> Velocidad de movimiento de las palas.

IX –> Movimiento positivo (1) o negativo (-1) en el eje X de la pelota.

IY –> Movimiento positivo (1) o negativo (-1) en el eje Y de la pelota.

A continuación se hace un salto a la línea 570 para anotar marcadores en pantalla, dibujar el campo de juego y definir los sprites de la pala y la pelota.

Finalmente en la línea 220 se inicia el Bucle del juego, que de momento consta del movimiento automático y de rebote de la pelota y las palas con los mandos del cursor/joystick en sus campos correspondientes.

Seguiremos con más en el siguiente artículo…

Listado NewPong1.bas

10 ‘################
20 ‘# NEWPONG #
30 ‘# JOSE DELGADO #
40 ‘# ENERO 2013 #
50 ‘################
60 CLEAR
70 SCREEN 2,2
80 OPEN”GRP:”AS#1
90 GOSUB 630
100 GOSUB 740
110 ‘=============
120 ‘ INICIALIZAR
130 ‘=============
140 X=10:Y=10
150 IX=1:IY=1
160 AX=40:AY=90
170 BX=200:BY=90
180 PUNT1$=”00″:PUNT2$=”00″
190 VEL=8:VELP=8
200 P1=0:P2=1
210 GOSUB 570
220 ‘=================
230 ‘ BUCLE DEL JUEGO
240 ‘=================
250 ‘——–
260 ‘ PELOTA
270 ‘——–
280 PUT SPRITE 0,(X,Y)
290 IF (IY=1 AND Y<185-8) THEN IY=1 ELSE IF IY=1 THEN IY=-1
300 IF (IY=-1 AND Y>7) THEN IY=-1 ELSE IF IY=-1 THEN IY=1
310 IF (IX=1 AND X<251-8) THEN IX=1 ELSE IF IX=1 THEN IX=-1
320 IF (IX=-1 AND X>7) THEN IX=-1 ELSE IF IX=-1 THEN IX=1
330 X=X+(IX*VEL)
340 Y=Y+(IY*VEL)
350 ‘———–
360 ‘ JUGADOR 1
370 ‘———–
380 D=STICK(P1)
390 IF (D=1 AND AY>7) THEN AY=AY-(1*VELP)
400 IF (D=5 AND AY<(185-16)) THEN AY=AY+(1*VELP)
410 IF (D=3 AND AX<(128-12-VELP)) THEN AX=AX+(1*VELP)
420 IF (D=7 AND AX>5) THEN AX=AX-(1*VELP)
430 PUT SPRITE 1,(AX,AY)
440 ‘———–
450 ‘ JUGADOR 2
460 ‘———–
470 D=STICK(P2)
480 IF (D=1 AND BY>7) THEN BY=BY-(1*VELP)
490 IF (D=5 AND BY<(185-16)) THEN BY=BY+(1*VELP)
500 IF (D=3 AND BX<(256-12-VELP)) THEN BX=BX+(1*VELP)
510 IF (D=7 AND BX>128) THEN BX=BX-(1*VELP)
520 PUT SPRITE 2,(BX,BY)
530 GOTO 220
540 ‘
550 ‘
560 ‘
570 ‘===================
580 ‘ ANOTAR MARCADORES
590 ‘===================
600 PSET(20,20),4:PRINT#1,PUNT1$
610 PSET(220,20),4:PRINT#1,PUNT2$
620 RETURN
630 ‘==================
640 ‘ DIBUJAR PANTALLA
650 ‘==================
660 LINE(0,0)-(256,7),15,BF
670 LINE(0,185)-(256,192),15,BF
680 LINE(0,0)-(5,50),15,BF
690 LINE(0,142)-(5,192),15,BF
700 LINE(251,0)-(256,50),15,BF
710 LINE(251,142)-(256,192),15,BF
720 LINE(128,8)-(128,185),15
730 RETURN
740 ‘=================
750 ‘ DEFINIR SPRITES
760 ‘=================
770 FOR I=1 TO 8
780 READ A$
790 B$=B$+CHR$(VAL(“&B”+A$))
800 NEXT I
810 SPRITE$(0)=B$
820 DATA 00000000
830 DATA 00011000
840 DATA 00111100
850 DATA 01111110
860 DATA 01111110
870 DATA 00111100
880 DATA 00011000
890 DATA 00000000
900 FOR I=1 TO 16
910 READ A$
920 C$=C$+CHR$(VAL(“&B”+LEFT$(A$,8)))
930 D$=D$+CHR$(VAL(“&B”+RIGHT$(A$,8)))
940 NEXT I
950 SPRITE$(1)=C$+D$
960 SPRITE$(2)=C$+D$
970 DATA 0000011111100000
980 DATA 0000011111100000
990 DATA 0000011111100000
1000 DATA 0000011111100000
1010 DATA 0000011111100000
1020 DATA 0000011111100000
1030 DATA 0000011111100000
1040 DATA 0000011111100000
1050 DATA 0000011111100000
1060 DATA 0000011111100000
1070 DATA 0000011111100000
1080 DATA 0000011111100000
1090 DATA 0000011111100000
1100 DATA 0000011111100000
1110 DATA 0000011111100000
1120 DATA 0000011111100000
1130 RETURN

Fin Listado NewPong1.bas

Descargar newpong1.bas

Descargar newpong1.dsk

Programando NewPong. Parte 1

4 Mar

Vamos a iniciar el apartado de programación en MSX-Basic diseñando y programando un clásico en los videojuegos… quizás el primero…

En 1972, Nolan Bushnell fundó una compañía llamada Atari y publicó el juego con el nombre de Pong. ¿Quién no conoce el famoso juego del cuadradito que pretende ser una pelota y de los dos palos que simulan ser raquetas? Bien, pues este es el primero de los primeros, el primerísimo Videojuego llamado Pong.

oldpong

En nuestro caso en la primera sesión de programación tenemos un apecto similar, pero más al estilo del MSX… al que he bautizado como NewPong…

newpong1

¿Qué os parece la idea?

Es un programa sencillo, adictivo (sobre todo para dos personas), nostálgico y que cumple ser el primer videojuego que programé cuando tuve mi primer MSX.

En el siguiente post pondré el listado Basic (de esta primera sesión) y comentaré las principales instrucciones para todos aquellos que quieran iniciarse en el mundo de la programación del MSX Basic y para los que como yo, después de tantos años, estemos un poco oxidados en este tema y así entre todos vamos dándole forma a nuestro programa de MSX Basic.