BASIC Tenliners Contest 2016 (NOMAM)

[vitoco]

Ya se están presentando los juegos para la edición de este año del concurso NOMAM de juegos de sólo 10 líneas de código BASIC en distintas categorías dependiendo del largo de las líneas: 80, 120 y 256 caracteres.

La información oficial está en BASIC TENLINERS 2016, y el plazo para presentar es al mediodía del 28 de marzo, ya que ahí serán evaluados durante la conferencia NOMAM. La premiación será el 2 de abril.

La diferencia con años anteriores es que ahora se permite programar en cualquier computador de 8-bits, por lo que además de juegos para Atari, Commodore y CPC, ya han llegado para Sinclair, Tandy, Vtech... (ver lista).

El año pasado, la categoría de 120 caracteres por línea la ganó el chileno Daniel Serpell con su Carrera-3D en Atari, y el antepasado él obtuvo un buen lugar con la versión 2D llamada simplemente Carrera.

Yo ya presenté un par de juegos para la competencia de este año, tengo otro casi listo y uno más en mi cabeza.

¿Alguien más se anima a participar?

Como ya lo mencioné, se puede utilizar cualquier dialecto de BASIC existente para cada sistema y además se permiten abreviaciones para meter más instruciones por línea, con un máximo de 10 líneas.

Algunos foros donde se comenta y publican ideas y los mismos juegos que competirán son:

Atari: AtariAge
Commodore: Lemon64
MSX: MSX.org

[vitoco]

Al momento:

10 games for C64
9 games for Atari 8 Bit
9 games for Vtech VZ-200/Laser 210
3 games for MSX 1
3 games for Tandy TRS-80 MC-10
2 games for ZX Spectrum
1 game for ZX81
1 game for C16/Plus4/C128

28 juegos!!!!

[AsCrNet]

mish obligado a participar en hacer algo, aunque aún nada se me ocurre que sea original.

Saludos

[vitoco]

mish obligado a participar en hacer algo, aunque aún nada se me ocurre que sea original.

Los 3 juegos que ya presenté no son originales, sino que implementaciones distintas o simplificadas y decoradas de cosas conocidas:

Fleas!

FLEAS.PNG (1.65 KiB) Visto 4650 veces

Invaders

INVADERS.PNG (1.58 KiB) Visto 4650 veces

Where's my cheese?

CHEESE.PNG (1.86 KiB) Visto 4650 veces

Los 2 primeros los hice el año pasado después de Toy'Swap y el tercero lo dejé a medias porque no me cupo en las 10 líneas estándares, pero lo retomé este año y agregué algunos decorados para aprovechar el espacio extra que obtenía al cambiarlo a la categoría EXTREM-256.

Si revisas la lista de lo ya presentado, verás lo mismo... Al menos sirve para sacar ideas y refrescarlas.

Ahora estoy trabajando en algo original (al menos para mí), pero en modo de texto... La prueba de concepto se ve bien, y la jugabilidad debe ser ajustada un poco. Y después a comprimir y acomodar código para calzar en 10 líneas. Y si sobra espacio, se agregarán los chiches.

A propósito de compresión, Daniel (el del Carrera 3D) está trabajando en un proyecto de compresión de código TurboBASIC XL. En realidad no se comprime el código, pero lo formatea y le modifica las variables para ocupar el menor espacio posible. Lo comenzó justamente para ser usado en este concurso, y tiene la gracia adicional que puedes editar libremente (sin números de línea) en cualquier editor de Windows, y luego generar el archivo tokenizado con el parser para cargar directamente en un emulador corriendo TurboBASIX XL. El proyecto es más ambicioso... la idea final es llegar a compilar y generar código ejecutable con alguna biblioteca incorporada.

El resultado en formato LST puede ser procesado por mi servicio ATASCIIprinter para obtener el listado mínimo final. Recientemente modifiqué mi servicio para permitir líneas de 120 caracteres (para la categoría PUR-120) y para saltarse las líneas en blanco que aparecen justo después de una línea de largo 120 exactos (sin incluir el fin de línea). Si se procesa la variante tokenizada, el listado será el mismo que se obtendría al hacer LIST en el intérprete de BASIC.

¡Animo!

[vitoco]

Esta semana apareció un aporte de un español: es un juego para Oric-1/Atmos. Yo no conocía esa arquitectura, pero pareciera tener muchas cosas en común con Atari: procesador de la familia 6502, 16K de ROM con S.O. en la parte alta de la memoria, color de fondo y del texto seleccionable, modo gráfico con algunas líneas de texto abajo, voces de sonidos con diferentes distorciones, set de caracteres redefinibles, BASIC, etc. ¿Será que los diseñadores de computadores de esa época venían de la misma escuela?

[renix]

De la escuela Motorola 6800 del que deriva la inteligencia humana detras del 6502... de hecho el 6501 fue un reemplazo directo del M6800 pin compatible a un precio bajísimo y que llevo a juicio entre motorola y MOS... de este juicio nació el 6502 que es lo mejor de su epoca y tenía las 3 B (y su supervariante: el 6510 )

[vitoco]

Para motivarlos a participar, voy a explicar un poco más en qué consiste esta competencia.

La idea es hacer un juego en sólo 10 líneas de código BASIC, lo cual no quiere decir que sean apenas 10 instrucciones, sino que en cada línea puede haber muchas sentencias separadas por ":" (dos puntos), lo que permite multiplicar por harto la cantidad de instrucciones para un programa.

Depende del computador utilizado la cantidad máxima de caracteres que pueden ingresarse en una línea lógica. Por ejemplo, en el Atari son 120 (3 líneas físicas de 40 caracteres mediante edición en pantalla) y en Commodore me parece que son 80 (que me corrijan en esto, plis), sin embargo se pueden ingresar líneas directamente de archivo en lugar del editor en pantalla, con lo que en general se puede llegar a 256, y por eso se dividieron en categorías: 80, 120 y 256.

En general hay varias versiones de BASIC por máquina y dependiendo de la versión del BASIC que se escoja se pueden abreviar las instrucciones para agilizar el ingreso de código. En el caso de AtariBASIC y TurboBASIC XL en Atari se puede utilizar un punto después de las primeras letras (ej: "G." o "GO." equivalen a "GOTO"), y en Commodore BASIC V2 se hace usando la letra que corresponde a la posición del punto pero con SHIFT, lo que hace que aparezca un caracter gráfico en pantalla. Además, es posible omitir los espacios entre instrucciones y parámetros, pudiendo aprovechar mejor el espacio disponible, aunque haciendo la lectura casi ilegible. Pero ésto se ve así sólo en el ingreso, ya que las instrucciones son convertidas en tokens de 1 byte, y al listar el programa ingresado, se expanden a la instrucción completa, por lo que la línea lógica tendrá un largo mayor al original y que lo permitido en la categoría respectiva, pero eso no importa... sólo es relevante el largo de línea al momento del ingreso. Si a eso le sumamos la posibilidad de usar variables con nombre de apenas 1 caracter, y de utilizar los números de línea de 0 al 9, vemos que contamos con mucho espacio para hacer verdaderas maravillas.

Pero BASIC tiene una restricción: el destino de los "GOTO" es un número de línea, y de esas tenemos pocas, por lo que lo conveniente es simplemente no utilizarlo y preferir la programación estructurada con "REPEAT-UNTIL", "WHILE-END" o incluso "FOR-NEXT" con "STEP 0" cuando no existan las primeras estructuras de control. Estos loops pueden anidarse o ponerse secuencialmente en una misma línea de código o distribuirse entre varias, transformando los números de línea en sólo un trámite, lo que permite ponerlos donde sea para ajustar las líneas al máximo largo posible.

Por lo tanto, para el desarrollo de un juego en esta competencia, hay que elegir entre varias estrategias o combinar algunas de éstas:


Procedimiento completamente manual:

- Programar libremente en el compuador real (Atari, Commodore, MSX o lo que sea), usando una instrucción por línea y evitando el uso de "GOTO", "GOSUB" o cualquier instrucción que requiera especificar un número de línea.

- Estando satisfecho con el resultado, el listado final se traspasa a un editor de texto común y se comienza a transformar el código, abreviando cada instrucción y eliminando los espacios innecesarios. Si el programa puede ser cargado con "ENTER" (en Atari en lugar de "LOAD" o sus equivalentes), excelente, pero si algo falla, hay que revisar si fue ingresada una abreviación inválida o que se interpretó como otra (ej: "STOP" en lugar de "STEP" en Commodore) hasta que el programa funcione como corresponde.

- Reducir de la cantidad de líneas eliminando todos los números de línea y concatenando todas instrucciones en una única línea separando con ":" (dos puntos) y poniendo el número de línea cero al inicio. Verificar que el largo final de esa única línea no sea superior a 10 veces el largo permitido de la categoría seleccionada. Luego se debe buscar qué instrucción se encuentra en el largo máximo de línea de la categoría y cortar en el ":" anterior, eliminando éste y poniendo el número de línea correlativo a la nueva línea. Si lograste que la última línea fuera la 9 o inferior, ¡listo!

- Si teniendo un largo de línea única inferior a 10 veces máximo no se logró dividir en sólo 10 líneas, eso se debió a que sobró mucho espacio al final de algunas líneas porque la instrucción que iba ahí no cabía y debió ser pasada a la siguiente línea. Eso se puede resolver en muchos casos cambiando el orden de algunas instrucciones o estructuras completas. Por ejemplo si una línea tiene 10 espacios al final, siendo la última instrucción de esa línea "A=1" (largo 3) y la primera de la siguiente "B(M)=X+200*Y" (largo 12), basta intercambiarlas ya que no se afectan mutuamente y 12 es menor 3+10. Si no se puede cambiar el orden de las instrucción, es posible dividir una instrucción larga en dos y dejar un trozo en cada línea, por ejemplo: "IF(X+Y)/2>10" puede ser separada como "Z=X+Y" al final de la primera (con Z una variable auxiliar) e "IF10<Z/2" en la segunda.

- Por otro lado, si la idea era participar en la categoría PUR-120 pero el largo de la línea única resultó ser 1300, hay 2 alternativas: ver si se puede optimizar el código para bajar de 1200, o definitivamente pasar a la categoría EXTREM-256 y aprovechar los 1200 caracteres adicionales para incluir más cosas en el juego (esto fue lo que sucedió con mi juego "Where's my cheese?", que no pude bajar de 12 líneas de largo 120, así que aproveché el saldo para incorporar más elementos y opciones).

- Sin entrar a la optimización de código para reducir el número de instrucciones porque dependerá de cada caso, puedo mencionar otras cosas simples a tener en cuenta:

. Cuando un valor se repite varias veces en el código, se puede reemplazar por una variable a la que se le asigna el valor una vez. Por ejemplo, si el valor 40 aparece 8 veces en el código, esos son 16 bytes en total del listado, pero si se asigna a la variable Z, se ganan 3 bytes: "Z=40:" ocupa 5 bytes y 8 son los reemplazos en el código, totalizando 13. Puede parecer poco, pero si el valor tenía más digitos, la ganancia es mayor, y 1 o 2 bytes ganados en una línea puede permitir acomodar mejor las instrucciones en ella, trayendo la primera de la linea siguiente.
. Utilizar DPEEK y DPOKE para leer y escribir words (2 bytes a la vez), y evitar tener que multiplicar por 256 uno de ellos y sumar el otro, o bien para modificar 2 registros consecutivos de memoria a la vez.
. Modificar directamente los registros del sistema en lugar usar de instrucciones BASIC para hacer lo mismo. Por ejemplo, en Atari, un "DPOKE709,15" (11 caracteres) hace lo mismo que "SE.1,0,15:SE.2,0,0" (18 caracteres).
. Aprovechar intrucciones avanzadas como "MOVE" en TurboBASIC XL para Atari en vez de ciclos "FOR-NEXT" para mover bloques de memoria. Esto es útil para la manipulación de P/M (sprites), redefinir el set de caracteres o incluso cambiar todos los registros de color de una vez.
. Usar "POKE" para modificar cosas en la pantalla en lugar de "POSITION" y "PRINT". Además de ocupar menos caracteres en el listado y ser más rápido de ejecutar, permite simplificar el código al no necesitar manipular estructuras de datos adicionales para almacenar información de los objetos en pantalla... ellos ya están ahí y se puede verificar fácilmente una colisión.


Procedimiento manual simplificado:

- Consiste en escribir directamente las 10 líneas de código en formato abreviado en un editor para ir viendo cómo va la cosa. Es más complejo de editar y mantener, por lo que lo recomiendo sólo cuando se usó el procedimiento anterior, y luego se quieren hacer mejoras al código ya reducido, pero tiene la ventaja que basta hacer un copy&paste entre el notepad y el emulador para ir probando durante el desarrollo.


Procedimiento semiautomático:

- Para algunas plataformas hay utilitarios que permiten escribir código en notepad y procesarlo para generar directamente el programa compactado. Es el caso del TurboBasic XL parser tool para Atari o el CBM .prg Studio para Commodore.

- Si aún así se obtienen más de 10 líneas, hay que hacer algunas de las cosas que mencioné en el 1er método, además de cualquier optimización de código que puedan realizar.


Lo interesante de esta competencia es el desafío de hacer más de lo que uno conoce como restricción natural. Yo mismo me sorprendí con lo que pude hacer en los 3 juegos que ya presenté. El del perrito y las pulgas era originalmente con caracteres simples, pero como sobró espacio, pude agregar la modificación del set de caracteres y darle vida al personaje. Como dato adicional, éste fue mi primer programa hecho en TurboBASIC XL, y ahí uso y abuso de los ciclos "WHILE-WEND" y de DPEEK y DPOKE.

Algo similar ocurrió con el de los invasores, pero tuve que optimizar harto código para poder incorporar la modificación al set de caracteres y lamentablemente sólo pude poner uno de los 2 que se necesitaban para que tuvieran el movimiento del juego original, y obviamente las barreras fueron omitidas completamente. También quedó fuera el UFO y sólo se puede jugar una ronda... no hay puntaje y la consigna es ¡ganar o morir! Probablemente son elementos que se pueden incorporar cambiando de categoría a EXTREM-256, pero no es algo que me caliente la cabeza por ahora. A diferencia del juego del perrito, en éste utilicé P/M (sprites) para el cañon y las municiones, y las características del hardware para posicionarlos y detectar colisiones, simplificando bastante mi código.

Ya... ¿nadie más se anima a participar? ¡Vamos! Inténtenlo y déjense sorprender con el resultado.

[vitoco]

Ahora estoy trabajando en algo original (al menos para mí), pero en modo de texto... La prueba de concepto se ve bien, y la jugabilidad debe ser ajustada un poco. Y después a comprimir y acomodar código para calzar en 10 líneas. Y si sobra espacio, se agregarán los chiches.

Más motivación... para que vean cómo funciona en forma práctica, les presentaré el juego para Atari en el cual estoy trabajando ahora para la categoría PUR-120.

Después de haber hecho juegos para ser usados con joystick, me puse a pensar en algunos que requirieran buena memoria y habilidad tecleando, y se me ocurrieron un par de ideas. La que me pareció más atractiva es la que aquí desarrollo, y se trata de lo siguiente:

Caracteres van apareciendo aleatoriamente por un costado de la pantalla y hay que irlos matando antes que alcancen el otro costado. Simple, ¿cierto? ¿Y si mejor enfrentamos letras apareciendo por un lado y números por el otro? Mucho mejor...

Nunca antes había programado en TurboBASIC XL, y con mis 3 programas anteriores descubrí que unas pocas cosas nuevas de las que incluye te abren un mundo de posibilidades. En particular, éstas son IF-ELSE-ENDIF, WHILE-WEND, REPEAT-UNTIL, MOVE, DPOKE y DPEEK. Las estructuras de ciclo y el nuevo formato de IF permiten utilizarlos en cualquier contexto, sin requerir números de línea como en un FOR-NEXT. Las otras instrucciones y funciones nos ahorran harto código y en el caso de MOVE (y -MOVE) nos entrega la velocidad de Assembler para mover trozos de memoria (y hacer animaciones).

Dicho esto, probemos cómo sería el código manejando la situación original (sólo letras por un lado) y cuánto espacio requiere... si es poco, bastaría duplicar para agregar los números. Veamos cómo quedó el código al primer intento:

Código: Seleccionar todo

graphics 18
p=dpeek(88)+40

dim a(9),x(9),b(9),y(9)

if j
for i=0 to 9
a(i)=1
x(i)=rand(26)
poke p+i*20,x(i)+33
next i
endif

s=0
t=250
g=1
w=t
c=0

while g

if peek(764)<>255
  get k
  if k>64 and k<91
    a=k-65
    f=0
    for i=0 to 9
      if a(i) and x(i)=a
        a(i)=a(i)-1
        q=p+i*20
        poke q+a(i),0
        if a(i)
          x(i)=peek(q+a(i)-1)&63-33
        endif
        f=f+1
        s=s+f
      endif
    next i
    if f=0
      w=0
      c=c+1
    else
      position 12,0
      ? #6;s
    endif
  endif
endif

w=w-1
if w<=0
  i=rand(10)
  z=rand(26)
  q=p+i*20
  if a(i)
    -move q,q+1,a(i)
  else
    x(i)=z
  endif
  a(i)=a(i)+1
  poke q,z+33+64*rand(4)

  if a(i)=20
  g=0
  endif
  
  w=t
endif

wend

Se pueden ver un montón de variables pensadas para manejar letras y números por separado, ademas de contadores que sólo incrementan su valor sin hacer nada más... eso es parte del proceso creativo

¿Pero cuánto espacio realmente ocupamos con eso? Usando alguna de las herramientas de compactación de código para este evento (como el basicParser), llegamos a lo siguiente:

a1.lst.png (3.35 KiB) Visto 4562 veces

Apenas 4 líneas y cuarto, es decir, podríamos duplicar código y lograr el enfrentamiento de ambos tipos de caracteres. Pero, ¿no será mejor usar algún tipo de fórmula para administrar ambos lados a la vez? Claro... usar una matriz en vez de 2 arreglos para cada variable a controlar.

Haciendo los cambios necesarios, ahora tenemos lo siguiente:

Código: Seleccionar todo

graphics 18
p=dpeek(88)+40
i=1
dim a(9,i),x(9,i),p(9,i),s(i),m(i),d(i)

s(o)=i
s(i)=-i
m(o)=26
m(i)=10
d(o)=33
d(i)=16

for j=o to 9
z=p+j*20
p(j,o)=z
p(j,i)=z+19
next j

s=o
t=250
g=i
w=t
c=o

while g

if peek(764)<>255
  get k
  if k>64 and k<91 or k>47 and k<58
    l=k<64
    x=k-65+17*l
    f=0
    for j=o to 9
      if a(j,l) and x(j,l)=x
        a(j,l)=a(j,l)-i
        q=p(j,l)+a(j,l)*s(l)
        poke q,o
        if a(j,l)
          x(j,l)=peek(q-s(l))&63-d(l)
        endif
        f=f+i
        s=s+f
      endif
    next j
    if f=o
      w=o
      c=c+i
    else
      position 12,o
      ? #6;s
    endif
  endif
endif

w=w-i
if w<=o
  l=rand(2)
  z=rand(m(l))
  j=rand(10)
  q=p(j,l)
  a=a(j,l)
  if a
    if l
      move q-a+i,q-a,a
    else
      -move q,q+i,a
    endif
  else
    x(j,l)=z
  endif
  a(j,l)=a+i
  poke q,z+d(l)+64*rand(4)

  if a(j,o)+a(j,i)>=20
  g=o
  endif
  
  w=t
endif

wend

Compactado se ve así:

a2.lst.png (4.2 KiB) Visto 4562 veces

Apenas 5 líneas y media, es decir, nos ahorramos 3 líneas y tenemos el esqueleto del juego funcionando. Ahora tenemos 4 líneas y media para poner chiches, es decir, agregar dificultad, premios y castigos, incorporar sonidos, etc...

Sin embargo se me pasó la mano... se me ocurrieron tantas cosas que ponerle, que me quedé sin espacio, y tuve que comenzar a optimizar aún más el código, por ejemplo, utilizar una misma instrucción de sonido para 2 cosas distintas variando los tonos dependiendo de para qué sea usando fórmulas. También cambié algunos IF-ENDIF por simples asignaciones con expresiones condicionales, lo cual me ayudó incluso a clarificar más el código y evitar condiciones de borde en la manipulación de contadores. Y en las condiciones de los ciclos e IF que quedaron, usé álgebra aritmética en lugar de expresiones booleanas: un simple asterisco para multiplicar en vez de la palabra AND me ahorra al menos 2 caracteres, lo que permite acomodar las instrucciones en las líneas.

Es relevante mencionar que el campo de batalla está en la pantalla, y los datos son manipulados directamente ahí; sólo se manejan en variables (arreglos) la cantidad de letras por fila en cada lado y el elemento que actualmente está como 1ro de línea. Los contadores y constantes como la posición inicial de cada fila en la pantalla por ejército y la dirección en que se mueve cada ejército son el resto de las cosas que se almacenan en variables. Si les llama la atención de por qué definí las constantes "o" (cero) e "i" (uno), eso se debe a que las variables ocupan menos espacio que los números en una línea lógica en el formato interno de TurboBASIC (token), y cada línea está restringida a sólo 256 bytes, por lo que así evito el error "14 - LINE TOO LONG".

No voy a poner aquí cada versión intermedia a medida que agregaba cosas, sino el resultado final, que es el siguiente:

Código: Seleccionar todo

. Alpha vs Numeric:
. "The Front Line"

. (c) 2016 Victor Parada G.
. 2016-02-18

graphics 18
p=dpeek(88)+20
i=1
dim a(9,i),x(9,i),p(9,i),s(i),m(i),d(i),t$(20)

s(o)=i
s(i)=-i
m(o)=26
m(i)=10
d(o)=33
d(i)=16

for j=0 to 9
  z=p+j*20+20
  p(j,o)=z
  p(j,i)=z+19
next j

u=5
position 3,u
? #6;"\C1\CC\D0\C8\C1\0F\EE\F5\ED\E5\F2\E9\E3";
dpoke 730,256

while i

  n=o
  g=i
  s=o
  r=o
  
  position 6,u+2
  ? #6;"[START]";
  while peek(53279)<>6
  wend
  
  ?#6;"\7D   S\3A0";
  
  while g
  
    r=r+i
    position 14,o:?#6;"B\3A";r
    poke p,o
    move p,p+i,219
    for k=0 to n
      for j =0 to 9
        for l=0 to i
          z=rand(m(l))
          poke p(j,l)+s(l)*k,z+d(l)+64*l+128
          x(j,l)=z
          a(j,l)=k+i
        next l
      next j
    next k
  
    t=70-5*n-3*r
    t=t*(t>o)+30
    w=t
    c=o
    n=n+(n<5)
    poke 764,255
    v=o
    e=200
    t$="completed"
   
    while g*e
  
      sound
      if peek(764)<>255
        get k
        if k>64 and k<91 or k>47 and k<58
          l=k<64
          f=o
          x=k+17*l-65
          for j=0 to 9
            a=a(j,l)
            if a and x(j,l)=x
              b=a-i
              a(j,l)=b
              q=p(j,l)+b*s(l)
              poke q,o
              f=f+i
              s=s+f
              e=e-(e>o)
              h=i
              if b
                x(j,l)=peek(q-s(l))&63-d(l)
              endif
            endif
          next j
          sound o,h*e+29,10*h,8
          if f
            position 5,o
            ? #6;s
            poke p+19 - e div 10,77
          else
            c=c+i
            v=c
          endif
          h=o
        endif
      endif
    
      w=w-(w>o)
      if (w=0 or v) * e
        v=v+(w=o)
        repeat
          l=rand(2)
          z=rand(m(l))
          j=rand(10)
          q=p(j,l)
          a=a(j,l)
          a(j,l)=a+i
          if a
            if l
              move q-a+i,q-a,a
            else
              -move q,q+i,a
            endif
          else
            x(j,l)=z
          endif
          poke q,z+d(l)+64*l+128
        
          if a(j,o)+a(j,i)=20
            t$="game over"
            g=o
          endif
          
          v=v-(v>0)
        until v*g=o
      endif
  
      if w*g*e=o
        sound o,31-16*g,6,8
        t=t-(t>20)
        w=t
      endif
    
    wend
  
    u=3+5*(j<5)
    position 5,u
    ?#6;t$
    pause 60
    sound
  
  wend

wend

El listado compactado se ve así:

a9.lst.png (7.92 KiB) Visto 4562 veces

Este juego lo llamé "Alpha vs Numeric: The Front Line" y lo pueden probar en el preview adjunto. Éste se ve así:

ALPHANUM-screenshot.png (4.22 KiB) Visto 4562 veces

Spoiler: MOSTRAR

Trivia: El nombre del juego tiene subtítulo porque el ya había escrito otro juego llamado "Alpha vs Numeric", pero que fue modificado gráficamente y presentado en NOMAM como "Fleas!". No le cuenten a nadie, pero el perrito originalmente era un escuadrón de letras que era atacado por números en vez de pulgas saltarinas. "Fleas!" fue el resultado de las optimizaciones y los chiches que le incorporé para dejarlo más atractivo.

ALPHANUM-fleas-screenshot.png (742 Bytes) Visto 4562 veces

[xt5]

PLW, justo estos meses necesitos dias de 30 horas, me encanta este tema de la entropia, tal vez para la proxima.

[AsCrNet]

wena vitoco, felicidades por tus pequeños juegos

Veo que está optimizando al máximo todo yo el año pasado participe pero no me puse tan detallista en la optimización, la idea era solo participar con algo que no había visto en la competencia. Y ahora tengo dos juegos en mente pero aun no hago la prueba de concepto para ver cómo queda.

Saludos

[vitoco]

Ayer presentaron un juego de 9 líneas en Tiny BASIC, escrito para la consola Atari 2600

Se está poniendo güena la cosa...

yo el año pasado participe pero no me puse tan detallista en la optimización, la idea era solo participar con algo que no había visto en la competencia.

¿Cuál fue tu juego/programa?

Y ahora tengo dos juegos en mente pero aun no hago la prueba de concepto para ver cómo queda.

Haz las pruebas y nos cuentas... y si quieres, acá podemos ir ayudando con pruebas, sugerencias, etc. para que tengas un producto terminado.

[AsCrNet]

Ayer presentaron un juego de 9 líneas en Tiny BASIC, escrito para la consola Atari 2600

Se está poniendo güena la cosa...

jajajaaj wena

¿Cuál fue tu juego/programa?

Magic Cards

Haz las pruebas y nos cuentas... y si quieres, acá podemos ir ayudando con pruebas, sugerencias, etc. para que tengas un producto terminado.

demás, espero tener un poco de tiempo para realizar pruebas de las ideas

Saludos

[vitoco]

¿Cuál fue tu juego/programa?

Magic Cards

¡Oh! Lo había mirado y encontré demasiado simple para ser verdad el código que hace la pega de descubrir el número... nunca supe cómo lo hacía, quedé pillo. Imagino que tiene que ver con una disposición especial de los números en la data.

Haz las pruebas y nos cuentas... y si quieres, acá podemos ir ayudando con pruebas, sugerencias, etc. para que tengas un producto terminado.

demás, espero tener un poco de tiempo para realizar pruebas de las ideas

Ánimo... yo ya quiero ponerme las pilas con otro juego simplecito, para la categoría PUR-80. A ver si me da el espacio. ¿Quieren saber cuál juego sería? Una variación del típico puzzle al que le falta una ficha.

[vitoco]

yo ya quiero ponerme las pilas con otro juego simplecito, para la categoría PUR-80. A ver si me da el espacio. ¿Quieren saber cuál juego sería? Una variación del típico puzzle al que le falta una ficha.

Después de haber pesado harto cómo hacer en forma simple este juego, me di cuenta que en realidad podía omitir algunas cosas y aprovechar las características del BASIC en combinación con la forma que el Atari maneja la pantalla, así que intenté un piloto, pero aprovechando la holgura, igual le metí código para que pregunte por las dimensiones del tablero, e incuso no cuadrado, es decir, desde 2x2 a 6x6. Las fichas serían el alfabeto y los números, con lo que tengo justo 36 fichas para el tamaño máximo (26 letras y 10 números), pero como falta una, decidí omitir el cero. En todo caso, si me falta espacio cuando termine, puedo eliminar las cosas como MxN y dejar sólo NxN o fijo en 4x4 por decir algo.

En menos de 5 minutos tuve el tablero de tamaño variable centrado en la pantalla, y un rato después podía desordenar las fichas al azar en vivo en la misma pantalla. Revisé cuántos bytes estaba ocupando en modo abreviado y eran menos de 400, es decir, apenas 5 líneas de a lo más 80 caracteres. Pero me di cuenta que la rutina para desordenar también servía para jugar, simplemente cambiando la función de random por la del joystick. Copié y pegué, modifiqué y listo. El juego completo en menos de 6 líneas y media:

p1.lst.png (3.47 KiB) Visto 4266 veces

El código en formato legible es:

Código: Seleccionar todo

graphics 2

dim a$(120),b$(120),d(3),j(15)

a$="."
a$(120)=a$
b$=a$

d(0)=-20
d(1)=1
d(2)=20
d(3)=-1
j(13)=-20
j(11)=1
j(14)=20
j(7)=-1

input "Alto (2-6) "; h
input "Ancho (2-6) "; w

p=dpeek(88) + 110 - 20*(h div 2) - w div 2
for i=0 to h*w-2
  x=p+i+(i div w)*(20-w)
  poke x, i+33-42*(i>25)
next i

move p,adr(a$),120

c=h*w*h*w
x=x+1
z=x+1

while c
  repeat
    d=rand(4)
    y=x+d(d)
    q=peek(y)
  until q and y<>z
  poke y,0
  poke x,q
  z=x
  x=y
  c=c-1
wend

while a$<>b$
  j=stick(0)
  y=x+j(j)
  q=peek(y)
  if q
    poke y,0
    poke x,q
    x=y
    c=c+1
    move p,adr(b$),120
  endif
wend
? c

En realidad no es tan jugable, porque al mover el joystick, prácticamente se mueve una fila o columna entera, es decir, falta poner pausas entre ficha y ficha que se mueve, pero tengo casi 3 líneas para afinar detalles, decorar y agregar sonidos. Pero ahora es tarde, seguiré el fin de semana.

[AsCrNet]

¡Oh! Lo había mirado y encontré demasiado simple para ser verdad el código que hace la pega de descubrir el número... nunca supe cómo lo hacía, quedé pillo. Imagino que tiene que ver con una disposición especial de los números en la data.

Efectivamente vitoco es como piensas, la data son tablas matemáticas diseñadas para calcular el número que pensaste solo con sumar el primer número de cada tabla donde aparece tu número. Ese es el secreto

yo ya quiero ponerme las pilas con otro juego simplecito, para la categoría PUR-80. A ver si me da el espacio. ¿Quieren saber cuál juego sería? Una variación del típico puzzle al que le falta una ficha.

wena tu prueba de concepto sobre este juego de puzzle, yo también tenía en mente otro juego de puzzle que es sudoku geométrico pero creo que necesitaría mas de 10 líneas

Saludos

[vitoco]

yo también tenía en mente otro juego de puzzle que es sudoku geométrico pero creo que necesitaría mas de 10 líneas

Yo creo que puede caber, pero no se me ocurre cómo sería la jugabilidad. ¿Con teclado? ¿Coordenadas? ¿Drag&Drop? Si fuera esto último, posiblemente requieraas más código... Mmmmm...

[vitoco]

En realidad no es tan jugable, porque al mover el joystick, prácticamente se mueve una fila o columna entera, es decir, falta poner pausas entre ficha y ficha que se mueve, pero tengo casi 3 líneas para afinar detalles, decorar y agregar sonidos. Pero ahora es tarde, seguiré el fin de semana.

Era tarde y no caché que se no puse la captura de pantalla. Así se veía después de revolver las fichas:

p1.png (1.77 KiB) Visto 4232 veces

Le dediqué un rato a la decoración, los sonidos y las pausas, y lo dejé así:

p2.png (1.98 KiB) Visto 4232 veces

Pero quise simplificar la selección de las dimensiones del puzzle, y entre otras formas, se me ocurrió hacerlo en forma interactiva usando el joystick, y comenzando con el botón de disparo. El resultado me gustó harto, y quedó espacio para poner el título, el contador de movimientos realizados mientras se juega y un mensaje al completar el puzzle. Claro que todo esto me tomó un par de horas, y ahora se ve así mientras se juega:

p3.png (1.78 KiB) Visto 4232 veces

El listado de esta 3ra versión es:

p3.lst.png (5.41 KiB) Visto 4232 veces

En formato editable, el listado se ve así:

Código: Seleccionar todo

graphics 18

? #6;"     m\AAn \F0\F5\FA\FA\EC\E5"

dim a$(120),b$(120),d(3),j(15)

a$="."
a$(120)=a$
b$=a$

for i=0 to 3
  read d,j
  d(i)=d
  j(j)=d
next i

s=dpeek(88)+40

m=4
n=4

repeat
  move s, s+1, 180
  p = s + 70 - 20*(n div 2) - m div 2
  for i=0 to n*m-2
    x=p+i+(i div m)*(20-m)
    poke x, (i+33-42*(i>25)+i*64) mod 256
  next i
  pause 9
  repeat
    j=15-stick(0)
    k=1-strig(0)
  until j+k
  m=m+(j&8>0)*(m<6)-(j&4>0)*(m>2)
  n=n+(j&2>0)*(n<6)-(j&1>0)*(n>2)
until k

move s,adr(a$),120

c=n*m*8
x=x+1
z=x+1

while c
  repeat
    d=rand(4)
    y=x+d(d)
    q=peek(y)
  until q and y<>z
  sound 0,20+d*3,8,8
  poke y,0
  poke x,q
  z=x
  x=y
  c=c-1
wend
sound

while a$<>b$
  j=stick(0)
  y=x+j(j)
  q=peek(y)
  if q
    sound 0,20+j,8,8
    poke y,0
    poke x,q
    pause 8
    sound
    c=c+1
    x=y
    move s,adr(b$),120
    position 9+(c<10),9
    ? #6;c
    repeat
    until stick(0)=15
  endif
wend

position 2,11
? #6; "congratulations\01"

while strig(0)
wend
run

data -20,13,1,11,20,14,-1,7

Como se me ocurrió ponerle el nombre "MxN Puzzle", le cambié el nombre a las variables que representan justo el alto y el ancho, M en vez de W y N en lugar de H. También le puse el mensaje de finalización al tiro en inglés... para la competencia.

Pueden probar el juego en el ZIP adjunto (contiene el ATR listo para usar en algún emulador o Atari XL/XE real). Antes de comenzar, al mover el joystick a la derecha se agranda el puzzle horizontalmente, y a la izquierda se achica. Si se mueve verticalmente, hacia abajo crece en altura y hacia arriba se achica. Con el botón comienza la acción.

El único problema es que me di cuenta después que no dejé ningún efecto de sonido para cuando se resuelve el puzzle, y espacio para eso casi no quedó. La horgura para mover instrucciones entre líneas es muy baja. Voy a tener que ver cómo resuelvo ésto. Creo que el listado no está críptico y quiero mantenerlo así.

EDIT: Eliminé el adjunto... resolví el problema.

[vitoco]

EDIT: Eliminé el adjunto... resolví el problema.

Ahora adjunto el juego, pero esta vez con un pequeño sonido de "por fin terminaste"...

p6.png (1.35 KiB) Visto 4222 veces

¿Cómo lo hice? Como se puede apreciar, tuve que acortar el mensaje de congratulaciones que estaba al final y como además olvidé que tenía que deshabilitar el ATRACT (attract mode) con "POKE 77,0" y necesitaba mucho espacio, además de acomodar algunas instrucciones para cambiarlas de línea, se me ocurrió repartir la DATA en todos los saldos de las líneas de código, ya que no importa que quede eso dentro de un loop o un IF mientras se lea secuencialmente, por lo que ahora el listado en 80 columnas se ve así:

p6.lst.png (5.58 KiB) Visto 4222 veces

El listado final es el siguiente:

Código: Seleccionar todo

. M*N PUZZLE
. (c) 2016 Victor Parada
. http://www.vitoco.cl/atari/

graphics 18
s=dpeek(88)+40

? #6;"     m\AAn \F0\F5\FA\FA\EC\E5"

dim a$(120),b$(120),d(3),j(15)

a$="."
a$(120)=a$
b$=a$

for i=0 to 3
  read d,j
  d(i)=d
  j(j)=d
next i

m=4
n=4

while 1

  data -20,13,1,11

  repeat
    move s, s+1, 199
    p = s + 70 - 20*(n div 2) - m div 2
    for i=0 to n*m-2
      x=p+i+(i div m)*(20-m)
      poke x, (i+33-42*(i>25)+i*64) mod 256
    next i
    pause 9
    repeat
      j=15-stick(0)
      k=1-strig(0)

      data 20

    until j+k
    m=m+(j&8>0)*(m<6)-(j&4>0)*(m>2)
    n=n+(j&2>0)*(n<6)-(j&1>0)*(n>2)
  until k
  
  data 14

  move s,adr(a$),120
  
  c=n*m*8
  x=x+1
  z=x+1
  
  while c
    repeat
      d=rand(4)
      y=x+d(d)
      q=peek(y)

      data -1

    until q and y<>z
    sound 0,20+d*3,8,8
    poke y,0
    poke x,q
    z=x
    x=y
    c=c-1
  wend
  sound
  
  while a$<>b$

    data 7

    j=stick(0)
    y=x+j(j)
    q=peek(y)
    if q
      sound 0,20+j,8,8
      poke y,0
      poke x,q
      pause 8
      sound
      c=c+1
      x=y
      move s,adr(b$),120
      position 9+(c<10),9
      ? #6;c
      repeat
      until stick(0)=15
    endif
    poke 77,0
  wend
  
  position 8,11
  ? #6; "done\01"
  
  for i=0 to 9
    sound 0,60-5*i,12,8
    pause 4
  next i
  sound
  
  while strig(0)
  wend

wend

Por favor, inténtenlo y me dan sus comentarios. Con un par de OK me conformo y lo envío al concurso...

EDIT: Nuevamente borré el adjunto, y puse uno actualizado en un post más adelante.

[Suppawer]

Lo acabo de ver y te quedó bueno ;sobre todo considerando las limitantes de cantidad de líneas y todo eso. Igual lo encuentro algo dificil (aunque motivante de resolver ). Mándalo no más y cruzaremos los dedos por un nuevo reconocimiento internacional

[AsCrNet]

Yo creo que puede caber, pero no se me ocurre cómo sería la jugabilidad. ¿Con teclado? ¿Coordenadas? ¿Drag&Drop? Si fuera esto último, posiblemente requieraas más código... Mmmmm...

ummm con joystick, mi idea que aparezca la pieza previa como el tetris, pero con un selector donde te puedas mover en el tablero para poner la pieza en cualquier lugar vacío. Ya con esto quedo fuera de concurso por pasar más de 10 líneas. Dejare la idea por si alguna vez me dan ganas de hacerla en tbxl con rutinas en asm o en action!.

Quedo muy bueno tu juego de puzzle, me dieron ánimos de hacer la prueba de concepto del otro juego que tenía en mente llamado equilibrio es algo mucho más simple pero no lo he visto en la competencia. La idea es seguir el camino moviéndose hacia arriba y abajo, el avance es automático según el nivel. Una fotito de la prueba.

Saludos