Informate tú

QIX

2012-01-23T14:04:00.004+01:00

Estaba tratando de recordar un juego de hace un porrón de años que jugué en el ordenador PC de unos vecinos.
Lo expuse gráficamente en StripGenerator y rápidamente llegó la respuesta, del juego base: QIX

El que yo recordaba sin duda estaba basado en QIX, pero era un clon diseñado para multijugador. De modo que entre 2 y 4 jugadores competían apiñados en torno al teclado, cada cual con su propio vector, cerrando sus áreas y tratando de no ser pillados por los rivales con un área sin cerrar.

O al menos esa es la idea que tengo y lo que estoy programando con Pygame. Lo más difícil ya lo tengo hecho, el relleno de las áreas, que me dió varios quebraderos de cabeza este domingo... hasta que dí con la maldita línea que estaba estropeando el invento, la pulga que hacía que la máquina cascase.

El resultado es éste:

Cuando se prevee el relleno de un área porque un jugador ha realizado un cierre, se ejecuta un rastreo en busca del contorno, o mejor dicho, de los dos contornos posibles.
Desde la cabeza del vector hasta el punto de despegue sólo hay un camino, pero una vez llegamos ahí...¿bordeamos el contorno en sentido horario o antihorario?
Tomamos ambos caminos, calculamos las áreas encerradas -aproximadamente mediante un algoritmo rápido que encontré googleando-, y elegimos el que encierre un área menor (de lo contrario la partida podría quedar decidida nada más empezar).
A continuación, rellenando una matriz con las coordenadas de los puntos recogidos a lo largo del contorno donde éste hace quiebro, se rellena el polígono resultante.
Si se superase el tamaño de la matriz definida el relleno quedaría incompleto. Le he puesto 250 (por ejemplo) coordenadas de límite, que creo que raramente se alcanzarán en un juego real por muchas revueltas que logre dar un jugador.

En el juego competirán hasta 4 jugadores, que parten de los 4 lados del campo de juego cuadrado.Ganará el que más halla rellenado de su color al final de la partida, debiendo para ello ir cerrando rastros de su propia cola con los bordes del campo o con los nuevos bordes creados que delimitan las zonas coloreadas por cualquier jugador (aquí líneas naranjas).

Hay tres formas de fipiarla:
1. Autoatrapamiento

2. Ser rellenado por otro jugador

3. Ser alcanzado en la cola por otro jugador antes de haber cerrado contorno.

Estas pifias te dejarán fuera de juego, pero no te quitarán los rellenos conseguidos, de modo que la partida no está necesariamente perdida.

Estaría bien poder jugar esto en red, pero al igual que ocurre el Armagetron, el lag es todo un problema, cuando tú ves que has cerrado a un rival... y luego resulta que a quien han cerrado es a tí.
Aunque el mayor problema es que ni si quiera sé hacer funcionar esto en red.

Enlaces:

Versión online del QIX original

Elige tu propia aventura con Caperucito

2011-08-20T23:01:00.003+02:00

Remake de El Genio

2011-08-13T19:25:00.001+02:00

Ayer lo empecé, y acabo de terminarlo: el remake de El Genio. Aquella aventura de 1999, tan difícil debido sobre todo a la cutrez de la programación.
Ahora los eventos de tiempo funcionan como debieron hacerlo, y además he incluído sonidos.

El Genio 2011

Tabla periódica de los elementos aventureros

2010-12-30T23:50:00.004+01:00

Pincha sobre la imagen para verla más grande

¿Qué hace la gente en las aventuras?

2010-12-27T16:17:00.001+01:00

Cuando programaba mis aventuras en DISAC (un parser propio en C), incluí un contador interno de forma que conjuntamente con la posición se guardara una estadística de uso de cada acción, así como el número de veces que el jugador habia probado un verbo no contemplado... lo que vendrían a ser los "No entiendo lo que dices" o "No conozco ese verbo".
A grandes rasgos el resultado que ví, en las posiciones que pude conseguir de la gente, es que EXAMINAR era la acción estrella, y ésta conjuntamente con las acciones de movimiento (N,S,E,O) constituían más del 50% de las acciones de cualquier aventura.

Lo que por otra parte es bastante obvio ¿no? Antes de actuar hay que mirar, y después también, por si algo ha cambiado.
Desde otro punto de vista, también podríamos considerar a EXAMINAR como la acción más cansina. La abreviatura, por tanto, es fundamental, ex o x.

Parser para inútiles totales

2010-10-27T16:09:00.003+02:00

-¡Quiero un parser para inútiles totales! en el que no haya que aprender a programar.
-Disculpe, si no me equivoco usted habla cinco idiomas (por lo menos).
-Así es.
-Manda narices que haya hecho el esfuerzo para aprender cinco lenguajes humanos con sus complejas gramáticas, sus declinaciones, sus irregularidades, su léxico infinito, sus construcciones caprichosas, sus modismos... y no esté dispuesto a hacer el pequeño esfuerzo de aprender un lenguaje de programación cuya sintaxis viene a ser ridícula en comparación con la de cualquier lenguaje humano, y cuya lógica cabe en el cerebro de una hormiga.
¿Qué tiene que decir a esto?
...
-Bueno... es que con los lenguajes humanos se puede ligar...

Formas de conversación

2010-10-20T12:23:00.014+02:00

1. Conversación automática.
La conversación se desarrolla siguiendo un guión al margen de lo que pretendiera decir el jugador, detonada por una acción de hablar o cualquier otra.

2. Conversación por menús.
Al iniciarse una conversación se despliegan una serie de opciones con temas entre los que el jugador puede elegir, cada uno de los cuales generará una respuesta/reacción en el interlocutor que a su vez modificará (o no) el repertorio de opciones para el siguiente turno de habla del jugador.
En los modelos más simples las opciones simplemente van desapareciendo a medida que son escogidas y respondidas, de modo que el jugador sólo está eligiendo el orden en el que quiere que le cuenten las cuatro cosas que tiene que decir el PSI. No habría mucha diferencia entre esto y mostrar el diálogo entero de una tacada, a modo de conversación automática.
Los modelos más elaborados se asemejarían a un librojuego, donde la elección de una opción u otra abre y cierra caminos futuros.

3. Conversación por detección de palabras clave.
Este es el sistema más conversacional, y quizá el más usado. En teoría es el más difícil pues supone un parser dentro del parser, y una aproximación a la programación de inteligencias artificiales; pero en la práctica nadie llega hasta tal punto y el programador se conforma con preveer un pequeño lexicón con lo importante.
Sus formas suelen ser del tipo DECIR A PERSONAJE "MENSAJE" o PERSONAJE, MENSAJE
Puede subdividirse en:
3.1. Reconocimiento de palabras clave estricto: Se buscará una o varias cadenas de texto, produciéndose error (mensaje tipo "no entiendo lo que dices") caso de que el jugador haya escrito algo que el parser no entienda. Da lugar a conversaciones muy pobres y básicas, del tipo:
DI A PERSONAJE "HOLA"
PREGUNTA A PERSONAJE POR LLAVE

3.2. Reconocimiento de palabras clave no estricto: Se buscará una o varias cadenas de texto, pudiendo generarse múltiples respuestas en función de las combinaciones de cadenas encontradas. El texto no reconocido se ignora. Mal visto tiene un gran margen de error, bien visto tiene un gran beneficio de la duda.

Nos permite diferenciar por ejemplo "Dónde está la espada" de "dame la espada" buscando las palabras que deben de aparecer fijo:

"donde" "espada" "dame" "entregame" "quiero"...
e ignorando las menos seguras y prescindibles, como:
"está", "(se) encuentra","(se) halla"...

3.3. Reconocimiento gramatical: es sencillo para órdenes (imperativas) simples usando el mismo motor que el analizador sintáctico del parser (que a fin de cuentas es lo que hace: reconocer un microlenguaje de órdenes imperativas VERBO+CD/CI/CC). Para otro tipo de enunciados sería más práctico recurrir al reconocimiento de palabras clave múltiples no estricto.

4. Conversación no lingüistica.
Acciones que provocan reacciones en los PSIS, como si fueran órdenes habladas. Mostrar objetos para obtener información sobre ellos, señalar una puerta, comunicarte por pitidos, golpes, claves...

Las conversaciones no dirigidas, es decir, aquellas en las que se detectan palabras clave, tendrán numerosas lagunas ante la inviabilidad de programar una inteligencia artificial que lo entienda todo. Podemos intentar disminuir, justificar o disimular el exceso de frases del tipo "No entiendo lo que dices" de diversas formas:

1. El PSI activo (no pasivo).
Si es el jugador quien tiene que abordar al PSI, quedarán más patentes sus defectos y sus fallas de programación, pero si es el PSI el que toma la iniciativa y dirige/orienta al jugador en todo momento sobre lo que se puede esperar de él, qué se le puede preguntar, qué le interesa... habrá menos margen de "Filomeno no parece haber entendido lo que dices".
Se trata de que el PSI hable al jugador sin necesidad de que éste le pregunte primero, y realice actividades por su cuenta en lugar de permanecer en una localidad a la espera.

2. El PSI sueco.
La lengua nativa del PSI es otra, y sus conocimientos sobre la lengua del jugador son escasos. Esto justificará que no reconozca la mayor parte de las cosas que se le digan.
El PSI también puede ser medio sordo o existir cualquier factor distorsionador que sea la causa del mal entendimiento.
El caso extremo es que el PSI no entienda abosultamente nada y por tanto responda inútilmente en su desconocido idioma. En este caso tan sólo se obtendrán reacciones útiles mediante comunicación no lingüística, al pronunciar nombres propios reconocibles al margen de la lengua (por ejemplo el nombre de alguien o de un lugar), o al hablar con el limitado léxico que el jugador aprenda del idioma de los PSIS.

3. El PSI autista.
No es más que sustituir las respuestas de error que informan que el PSI no nos ha entendido por otro tipo de respuestas que no digan expresamente que lo que hemos dicho no va a misa. "Filomeno espera a que acabes de hablar, y te da la espalda para asomarse por la ventana", "Filomeno medita unos segundos tras escucharte, y acto seguido vuelve a sus quehaceres.", "Por el gesto de aburrimiento, adivinas que a Filomeno no le ha interesado mucho lo que acabas de decir.". Da igual que las reacciones no concuerden con lo que se esperaría, el PSI te ha escuchado pero no has dicho nada que le interese o le motive a tener una reacción más propia.
Otra técnica en la misma línea son las respuestas evasivas, muy utilizadas en los programas de conversación con una IA, con frases como: "Muy interesante", "Cuénteme más sobre eso de 'quiero la llave'", "Estoy de acuerdo con lo que acaba de decir", "¡Eso es evidente!", "Cuando usted dice cosas como 'ayudame a abrir la puerta' yo cierro los ojos y escucho el mar"...

Enlaces:

Post original sobre sistemas de conversación en el foro del CAAD

Saboteur

2010-09-11T18:54:00.004+02:00

Ya puede considerarse terminada SABOTEUR, a falta de que decida hacer alguna ampliación.
Finalmente es una aventura 2D con interfaz conversacional, y no puede jugarse sin gráficos.

Las descripciones de las localidades no existen, salvo algunas impresiones del PJ en lugares relevantes. Las localidades se muestran gráficamente en 2D y tanto el PJ como los PNJ actúan en ellas conforme a los sucesos.
El resto de los textos usuales en una aventura conversacional sí que están incluídos.

Me ha costado horrores escoger el título, todos los que se me ocurrían me sonaban ridículos, demasiado largos, o pretenciosos, de modo que por pura desesperación he optado por "Saboteur", mismamente, como los juegos que inspiraron a éste.

[Actualización 14 de Septiembre]

La aventura puede descargarse AQUÍ. Ocupa 7 megas.

Desastre

2010-08-18T21:35:00.000+02:00

Blogger acaba de incorporar hace unos días una nueva funcionalidad para revisar el SPAM en los comentarios.
Entonces, de pronto aparecieron todos los comentarios del blog y me dió por pensar, así a las buenas, que sólo se trataba de una lista de revisión. Seleccioné todo y borré, pues no había nada que revisar.
Por hacer las cosas rápido y sin pensar resulta que se han borrado no sólo de la lista sino del blog.

Me he cargado sin pretenderlo los que cabían en la primera página de la lista de revisión, que son unos cuantos. Lo siento...

Los saboteurs

2010-08-09T20:44:00.011+02:00

En los 80 estaban de moda los karatekas y los ninjas, y de esto trataba la saga Saboteur.
En la primera parte, que no jugué, pero pude ver en casa de un chaval con un CPC monocromo tomábamos el papel de un ninja. En la segunda parte, que sí que tuve en mi CPC, encarnábamos a la hermana del anteriormente citado que debía ¿vengarse? infiltrándose en un complejo de unas 500 pantallas para desactivar el lanzamiento de un misil.
Los movimientos eran un petardo, propio de los juegos de la época, pero aun así la acción era trepidante, echándole imaginación y, en el caso de la segunda parte, gracias a la banda sonora, compuesta por Rob Hubbard (aunque mola más esta versión mejorada made in Spain).

El caso es que pretendo hacer algo parecido pero en plan conversacional.
Un ninja (o agente de negro) que se infiltra en una base enemiga compuesta por localidades bidimensionales, aunque en este caso con la posibilidad de traspasar puertas hacia terceras dimensiones.

No habrá animaciones, pero sí representaciones del personaje en las distintas acciones y posiciones.
Así, cada parte del decorado tiene sus coordenadas, y los objetos que dejamos también memorizan el lugar donde quedaron.
Al igual que en Randolph Dwight, el personaje se desplazará (aparecerá gráficamente desplazado) por la pantalla hasta el lugar donde se encuentre el objeto a manipular y en la pose adecuada para dar el pego de que está realizando dicha acción.
Es una mezcla de animación por turnos y por eventos de tiempo.
Así, si escribimos "coger pistola", el personaje aparecerá agachado unos segundos en el lugar donde yace la pistola (que también aparecerá representada en el suelo, aunque sean 4 pixels) y posteriormente se reincorporará.
Si saltamos tanto de lo mismo, el personaje no va a permanecer en el aire hasta que nos dé por escribir la siguiente orden y pulsar return.

Se diferencia de Barbarian Quest en que el personaje no se mueve, sino que aparece desplazado, y en que el interfaz es 100% conversacional.
Hasta ahora sólo había estado haciendo gráficos, pero hoy he programado la interfaz con unas pocas acciones y funciona bastante bien.

Las pantallas son de 800 por 200 pixels.
Primeramente dibujé las piezas para componer escenarios, los "ingredientes", pero en lugar de dibujar las pantallas a la antigua - -, lo cual sería una tortura china y consumiría mucho tiempo de proceso, grabé varios modelos básicos de escenarios ya compuestos a los que sólo habrá que añadir algunas partes externas para personalizarlos.
Por ejemplo, a un pasillo le puedo añadir puertas, muebles, muros laterales, y configurar así la decoración y las salidas de la localidad.
Glulx no tiene las capacidades de un lenguaje de programación de videojuegos: redibujado selectivo o volcado de buffer, por tanto dibujar muchos gráficos significa un lapso que se acaba notando, más si son PNG que si son JPG. Por tanto pego de base un JPG, e intento que los añadidos sean también JPG, salvo cuando no hay tu tía y necesito las transparencias de los PNG.

Tambien estuve barajando si usar una malla definiendo el mapa cómodamente en una matriz, y por ahora lo he descartado, ya que lo que me ahorro en mapeado me lo como luego configurando decorados con numeritos.
Serán localidades donde el decorado base se define en una propiedad, y los complementos en propiedades especiales acompañadas de las coordenadas del añadido, que sirven tanto para saber dónde se dibujan, como para tener la referencia de dónde tiene que ir el personaje si esa parte añadida es interactuable.
Así:

localidad lugar1 "lugar"

with

el_grafico pasillo1,

muroizquierdo 0,

escalerabaja 340,

;

Sólo con esto puedo automatizar desde la clase localidad que hay salida hacia el oeste, pero no hacia el este (pues existe la propiedad muroizquierdo); y que además se puede bajar por una escalera y el personaje cuando vaya a bajar o acabe de subir por ella se dibujará en la coordenada x=340.

Las puertas las meteré desde fuera, ya que como pueden estar abiertas o cerradas, y haber más de una por localidad (les pondré distintos colores), deben constituír cada una un objeto.

En Regreso al Edén ya hice una escena aislada así, donde el personaje era representado como en un arcade 2D localizado en la pantalla en función de su posición (la escena de cruzar el puente). Ésta vez será la base de la aventura.

Aunque no haya animaciones, creo que la acción va a ser igual de trepidante. Los resultados de las órdenes son instantáneos, y no hay que esperar cansinamente a que el personaje eche a correr y desaparezca por un extremo de la pantalla.

En Saboteur 1 el ninja llega a la base en una barca, en Saboteur 2 en un ala delta; y escapan respectivamente el helicóptero y en moto.
¿cómo puedo superar tal espectacularidad ochentera?

Aquí el ninja llegará a la base escondido en el camión de reparto de Mahou y escapará en una superbicicleta con cuadro de carbono y tubeless... por un carril bici, que ahora están de moda XD (Es broma, en parte)

Actualizo:
El juego sí que tendrá algunas animaciones de desplazamiento, pero parciales. No será el movimiento completo desde un punto hasta el destino sino los primeros pasos a modo de insinuación.

No tendrá descripciones, salvo particularidades, todo habrá que verlo en la pantalla, aunque los resultados de las acciones sí se describirán en texto escuetamente.
Lo que sí que se listan son los objetos pequeños, ya que debido a su tamaño, aunque aparezcan representados, son imposibles de reconocer (por ejemplo, una moneda serían dos píxels, podría ser cualquier cosa, incluso una textura de la pared)
También, incluiré algún comando de rastreo que liste los objetos de escenario de cada localidad, que se podrá configurar como permanente, para que los jugadores invidentes no tengan que estar tecleándolo constantemente.
Aun así, el resultado sin gráficos será muy pobre. La gracia de la aventura está en el feedback visual, aunque la alimentación sea textual. Será como "leer un cómic" :P

[Actualizo]
Parece que existe desde hace tiempo un remake un tanto libre de los Saboteur con el remix de Saboteur 2 Marcel Donné como banda sonora. Ver aquí.
El resultado no me gusta mucho, usa gráficos fusilados de otros juegos y con animaciones bastante chuscas.

Desambiguando en Inform6 (II)

2010-08-04T02:04:00.008+02:00

Vamos con el segundo ejemplo de desambiguación.
Esta vez vamos a hacer una caja de cerillas que contendrá cerillas de dos tipos:
1. Cerillas (esto no tiene ningún misterio)
2. Cerillas de la caja. (son las mismas cerillas de antes, sólo que están circunstancialmente dentro de la caja de cerillas, por si no quedaba claro).

Por tanto, tenemos que distinguir primeramente "cerillas de caja" de "caja de cerillas".
Esto ya lo hicimos en el ejemplo anterior con la leche y las jarras, pero con un mal resultado en cuanto intentamos interactuar con los dos objetos problemáticos a la vez en la misma orden. Ahora no ocurrirá así.

También debemos distinguir, como se anticipó, entre "cerillas" y "cerillas de la caja": las cerillas que tenemos en nuestra posesión o hemos sacado, de las que en esos momentos se encuentran en la caja.

El código, para InfSP, es el siguiente:

Constant Story "Desambiguación con Caja de Cerillas";
Constant ADMITIR_COMANDO_SALIDAS;
#Include "Parser";
#Include "Verblib";
[ Initialise;
location=habitacion;
rtrue;
];

!###########################################
object limbo "limbo";

object habitacion "habitacion"
with
description "...",
has light;

object jarron "jarrón" habitacion
with name 'jarron',
has container open;

object caja_de_cerillas "caja de cerillas" habitacion
with parse_name [ i j j2 j3 j4;
        j=NextWord();
          if (j=='caja'){!ee
                          i++;
                          j2=NextWord();
                          j3=NextWord();
                          j4=NextWord();
                          if(j2=='de'){if(j3=='las' && j4=='cerillas')i=i+3;
                                      if (j3=='cerillas')i=i+2;}
                          }!ee
          return i;
],

has female container openable ~open;

class cerillas
with short_name "cerilla",
plural "cerillas",
description [;
        if(self in caja_de_cerillas)"Una cerilla que está dentro de la caja de cerillas.";
        "Una cerilla normal y corriente.";
        ],

parse_name [ i j j2 j3 j4;
        j=NextWord();
          if (j=='cerilla')i++;
          if (j=='cerillas'){i++; parser_action=##PluralFound;}
          if (i>0 && action_to_be~=##Take or ##Remove){
                          j2=NextWord();
                          j3=NextWord();
                          j4=NextWord();
                    if(self in caja_de_cerillas){!¿está dentro de la caja?
                          if(j2=='de'){if(j3=='la' && j4=='caja')i=i+3;
                                      if (j3=='caja')i=i+2;}
                    }!¿está dentro de la caja?
                  }
          return i;
],
has female;

cerillas c1 "" caja_de_cerillas;
cerillas c2 "" caja_de_cerillas;
cerillas c3 "" caja_de_cerillas;
cerillas c4 "" caja_de_cerillas;
cerillas c5 "" caja_de_cerillas;
cerillas c6 "" caja_de_cerillas;
cerillas c7 "" caja_de_cerillas;
cerillas c8 "" caja_de_cerillas;
!###########################################
! Procedemos a reemplazar el Parsenoun de la librería por el código de la
! librería Intnombre que hemos descargado. Con esto conseguimos que los
! adjetivos puntúen previa detección de un nombre.
Replace ParseNoun;
Include "IntnombreINFSP.h";
#Include "SpanishG";

Vamos a analizar este trozito de código del objeto caja_de_cerillas para ver lo que estamos haciendo:
with parse_name [ i j j2 j3 j4;
        j=NextWord();
          if (j=='caja'){!ee
                          i++;
                          j2=NextWord();
                          j3=NextWord();
                          j4=NextWord();
                          if(j2=='de'){if(j3=='las' && j4=='cerillas')i=i+2;
                                      if (j3=='cerillas')i=i+2;}
                          }!ee
          return i;
],

En lugar de definir los nombres y los adjetivos definiéndolos previamente como de costumbre, vamos a mirarlos paso a paso con la función parse_name.

Nextword(); devuelve el valor de la siguiente palabra escrita, consecutivamente. Como la primera es el verbo (o cualquier texto conector de la gramática; o cualquier palabra supérflua que el parser decarte, como un artículo), el primer Nextword() leerá la segunda palabra.
Para que se entienda mejor, si de buenas a primeras escribiéramos:
Nextword(); Nextword(); j=Nextword();
la variable j leería la cuarta palabra que hemos escrito.

Bien, según el código de arriba, si la segunda palabra escrita es 'caja', le damos un punto y procedemos a comprobar las demás para aumentar la puntuación del objeto, utilizando las variables j2, j3 y j4 para almacenar la tercera, cuarta y quinta.
Y es que podemos referirnos a la caja (normalmente) con una cadena de hasta cuatro palabras:
caja
caja de cerillas
caja de las cerillas

De modo que si escribimos simplemente "caja", este objeto recibirá un punto; y si escribimos "caja de las cerillas" o "caja de cerillas" recibirá 1+2=3 puntos.
No conviene darle más puntos escribiendo sólo "caja", pues podría haber otra caja de otra cosa en la aventura, y nos cargaríamos la desambiguación. Así que sólo le subiremos la nota cuando detrás de caja hayamos escrito "de cerillas" o "de las cerillas".

Con el objeto cerillas:
parse_name [ i j j2 j3 j4;
        j=NextWord();
          if (j=='cerilla')i++;
          if (j=='cerillas'){i++; parser_action=##PluralFound;}
          if (i>0 && action_to_be~=##Take or ##Remove){
                          j2=NextWord();
                          j3=NextWord();
                          j4=NextWord();
                    if(self in caja_de_cerillas){!¿está dentro de la caja?
                          if(j2=='de'){if(j3=='la' && j4=='caja')i=i+3;
                                      if (j3=='caja')i=i+2;}
                    }!¿está dentro de la caja?
                  }
          return i;
],

hacemos tanto de lo mismo, sólo que la palabra de vocabulario a detectar como inicio es 'cerilla' o 'cerillas'.
En cuanto detectamos la coincidencia le damos un punto y procedemos a rastrear el resto de las palabras que van detrás, de la misma forma. En este caso sólo les vamos a dar puntuación a las cerillas que además de haber sido descritas como "cerillas de la caja..." estén efectivamente dentro de la caja de cerillas.
De este modo, EX CERILLA y EX CERILLA DE LA CAJA nos dará dos descripciones distintas, tal como lo hemos programado.

¿Qué ocurriría si otorgáramos la puntución por igual a las cerillas dentro de la caja que a las de fuera?
Pues que por defecto, al examinar, el parser tomaría al azar una cerilla... pero priorizando las que están fuera de la caja (Ya hemos visto en el capítulo anterior que para el parser, ante la duda, la más salida, es decir, el objeto que no esté dentro de otro).
Por lo demás, meter y sacar cerillas funcionaría perfectamente.

Bien, vamos a compilar el código y a probar:

Puedes ver un jarrón (que está vacío) y una caja de cerillas (que está cerrada).
>x cerillas
No veo eso que dices.
Que no cunda el pánico. La caja está cerrada, y al no ser transparente no puedes ver las cerillas. De hecho no puedes saber si dentro hay cerillas, monedas o una araña famélica.

>abre caja
Abres la caja de cerillas, descubriendo ocho cerillas.
Ahora ya podemos verlas.

>x caja de cerillas
En la caja de cerillas ves ocho cerillas.
Correcto.

>x cerillas de caja
No puedes especificar objetos múltiples con ese verbo.
También es correcto, el parser ha detectado correctamente que nos referimos a las cerillas, sólo que no se pueden examinar en plural, y por eso lanza ese mensaje.

>x cerilla de caja
Una cerilla que está dentro de la caja de cerillas.
Probamos en singular, aunque esto no demuestra nada aún, ya que "cerilla de la caja" con cerilla en singular no entra en conflicto con "caja de cerillas" con cerillas en plural. Por tanto vamos a probar con una acción que a diferencia de examinar sí que admita plurales u objetos múltiples:

>sacar caja de cerillas
¡Pero si no está ahí ahora!
Primeramente hemos intentado el absurdo. El mensaje, aunque no muy claro, es correcto. Es el que lanza el parser por defecto cuando intentas sacar algo que no está metido en ningún sitio, y tal es el caso de la caja de cerillas.

>sacar cerillas de caja
cerilla: Sacada. cerilla: Sacada. cerilla: Sacada. cerilla: Sacada. cerilla: Sacada. cerilla: Sacada. cerilla: Sacada. cerilla: Sacada.
Como vemos, hemos sacado las 8 cerillas de la caja. Pero vamos a volver a meterlas para probar mejor la desambiguación:

>meter cerillas en caja
cerilla: Hecho. cerilla: Hecho. cerilla: Hecho. cerilla: Hecho. cerilla: Hecho. cerilla: Hecho. cerilla: Hecho. cerilla: Hecho.
>sacar cerillas de caja de cerillas / sacar cerillas de la caja de cerillas
cerilla: Sacada. cerilla: Sacada. cerilla: Sacada. cerilla: Sacada. cerilla: Sacada. cerilla: Sacada. cerilla: Sacada. cerilla: Sacada.
Ya, por fín, hemos enfrentado a las "cerillas de la caja" contra la "caja de cerillas" en la misma frase. Y como vemos el parser detecta correctamente a qué objeto nos referimos en cada una de las partes.

Alguien se podrá preguntar ahora... ¿Y qué pinta un jarrón ahí? Pues es para demostrar que no hay trampa ni cartón.
El jarrón es otro contenedor donde se pueden meter las cerillas. Si la caja de cerillas fuera el único contenedor presente, el parser no necesitaría detectar que nos referimos a ese objeto, y con escribir "sacar cerillas" o "meter cerillas" actuaría directamente sobre él. Por tanto no podríamos comprobar que efectivamente se está enterando de que nos referimos a ese objeto.
Es una más de esas características de Inform donde el parser se hace el listillo...

Pero aún no han terminado las comprobaciones. Vamos a volver a meter todas las cerillas en la caja y empezamos de nuevo:
>coge cerilla
Cogida.
(Aunque el mensaje por defecto -que podemos mejorar- no lo muestre, la cerilla cogida procede del interior de la caja, que es donde están todas.

>coge cerilla
Ya tienes la cerilla.
Obviamente ya tenemos la cerilla... aunque haya más dentro de la caja. Pese a que resulte pesado, vuelvo a recordar que en caso de empate Inform prioriza los objetos que no están dentro de otros, de modo que habiendo alguna cerilla fuera de la caja, ésta tendrá prioridad.
¿Qué ocurriría si hubiera más de una cerilla fuera de la caja? ¿Nos lanzaría el parser un mensaje de desambiguación para determinar a cuál de ellas nos referimos? No. Las cerillas están definidas como una clase, con las mismas propiedades de nombre (en este caso con la rutina parse_name), por tanto son equivalentes y se escoge una al azar, sin preguntar al usuario. No ocurriría así si hubiéramos definido alguna diferencia de vocabulario entre ellas, por ejemplo distintos colores. En ese caso el pasers nos preguntaría ¿A cuál te refieres, a la cerilla roja, a la cerilla azul, o a la cerilla verde?

Pero volvamos al tema:
>coge cerilla de caja / saca cerilla de caja
Sacada.
Si queremos coger las cerillas que están dentro de la caja, lo especificamos y listo.

>x cerilla
Una cerilla normal y corriente.
Ésta es la descripción de una cerilla que está fuera de la caja.

>x cerilla de caja
Una cerilla que está dentro de la caja de cerillas.
Ésta es la descripción de una cerilla que está dentro de la caja.

>coge dos cerillas de la caja
cerilla: Sacada. cerilla: Sacada.
Esto también funciona.

¿Queréis ver algo que no funcione?...
>mete en la caja de cerillas una cerilla
No entendí esa frase.
Pero esto no es un problema de desambiguación, sino de definición de gramática. Podemos ver cómo está definida la acción "meter" (siempre que hayamos compilado en modo debug) de la siguiente forma:

>xverbo mete
Verb 'coloca' 'echa' 'inserta' 'mete' 'pon'
     * multiexcept 'en' container -> Insert
     * multiexcept 'en' noun -> PutOn
     * multiexcept 'dentro' 'de' noun -> Insert
     * multiexcept 'sobre' noun -> PutOn
     * noun 'a' topic -> SetTo
     * 'a' creature 'en' container -> Insert
     * 'a' creature 'en' noun -> PutOn
     * 'a' creature 'dentro' 'de' noun -> Insert
     * 'a' creature 'sobre' noun -> PutOn
     * multiexcept 'encima' 'de' noun -> PutOn
     * 'a' creature 'encima' 'de' noun -> PutOn
     * 'cerrojo' / 'pestillo' / 'cierre' 'a' noun -> Lock
     * 'el' 'cerrojo' / 'pestillo' / 'cierre' 'a' noun -> Lock
     * 'cerrojo' / 'pestillo' / 'cierre' 'a' noun 'con' held -> Lock
     * 'el' 'cerrojo' / 'pestillo' / 'cierre' 'a' noun 'con' held -> Lock

Como vemos, no aparece por ningún sitio ninguna plantilla tal que 'en' container multiexcept.
Por tanto, si queremos que el parser entienda una orden con el complemento circunstancial por delante del complemento directo, debemos editar o ampliar esa gramática añadiendo las siguientes líneas:
* 'en' container multiexcept -> Insert reverse
* 'dentro' 'de' container multiexcept -> Insert reverse

Pero esto ya se sale del tema de la desambiguación y de la caja de cerillas.
Puedes descargar el código compilado para Glulx aquí:
http://www.caad.es/jarel/trastos/cajadecerillas.zip

Desambiguando en Inform6 (I)

2010-07-29T21:38:00.019+02:00

A raíz de este post de Mastodon sobre la ambigüedad, voy a escribir dos artículos sobre cómo tratarla en Inform6.
Aviso que el güeno güeno es el segundo, en éste sólo voy a marear un poco la perdiz y a hacer pruebas. Pero también explicar dos modificaciones muy útiles que hacer a la librería por defecto para facilitar la desambiguación.

Si vamos a programar con InformATE debemos descargar esta librería:
http://www.caad.es/informate/informate/IntNombre.zip

Si en cambio programamos con InfSP6, puedes descargarla desde aquí:
http://www.caad.es/jarel/trastos/IntNombre.h
O en este paquete de librerías y extensiones, donde viene incluída:
http://www.caad.es/informate/infsp/downloads/extensiones.rar

Y vamos con el código base de ejemplo, es para InfSP6, aunque al final explicaré las modificaciones no obvias que hay que hacer para InformATE.

global variable1 =0; !esta variable la usaremos más adelante
Constant Story "desambiguación";
Constant ADMITIR_COMANDO_SALIDAS;
Replace ChooseObjects;
#Include "Parser";
!! ATENCIÓN. USAR VALORES DE prioritario entre 1 y 7
[ChooseObjects obj code;
   if(code==2){
        if(obj has nombreusado){

                if(obj provides prioritario){
                    return (obj.prioritario+2);
                    }

                    return 1;
                        }
            return 0;
        }
if (code<2) { if (obj has scenery || obj has static) return 2; rfalse; } !
if (action_to_be==##Eat && obj has edible) return 3;
if (obj hasnt scenery || obj hasnt static) return 2;
return 1;
];

#Include "Verblib";
[ Initialise;
location=habitacion;

rtrue;
];
!###########################################
object limbo "limbo"
with
! Esto no sirve para nada, es para evitar un error si no declaramos
! al menos una vez la propiedad prioritario
prioritario 0,
;

object habitacion "habitacion"
with
description "...",

has light;

object jarradeleche "jarra con leche" habitacion
with name 'jarra',
adjectives 'leche' 'con' 'que' 'contiene',
description "Es una jarra que contiene leche",
has female transparent;

object jarradeagua "jarra con agua" habitacion
with name 'jarra',
adjectives 'agua' 'con' 'que' 'contiene',
description "Es una jarra que contiene agua",
has female transparent;

object lechedelajarra "leche de la jarra" habitacion
with name 'leche',
adjectives 'jarra' 'blanca',

!prioritario 3,
description "Leche blanca, la jarra está llena de leche.",
has female;

!###########################################
! Procedemos a reemplazar el Parsenoun de la librería por el código de la
! librería Intnombre que hemos descargado. Con esto conseguimos que los
! adjetivos puntúen previa detección de un nombre.
!Replace ParseNoun;
!Include "IntnombreINFSP.h";
#Include "SpanishG";

Destacar que vamos a reemplazar dos funciones de la librería estandar, Parsenoun y ChooseObjects, para crear la infraestructura que nos permita desambiguar correctamente. Aunque de momento dejaremos desactivado el reemplazo de Parsenoun y no utilizaremos aún la propiedad "prioritario", para ver cómo parsea Inform6 por defecto... sí... POR DEFECTO (soy totalmente subjetivo).

Si compilamos el código de arriba, y procedemos a examinar los tres objetos presentes, la jarra con leche, la jarra con agua y la leche que está dentro de la jarra (oculta dentro de la jarra), ocurrirá lo siguiente:

Puedes ver una jarra con leche y una jarra con agua.
>x jarra
¿Cuál concretamente, la jarra con leche o la jarra con agua?
Vamos bien, hay dos objetos con nombre jarra, y nos pide concretar como no podía ser de otra manera.

>leche
Es una jarra que contiene leche
Al responder acto seguido "leche", el parser entiende que nos referimos a la jarra de leche. Una pena que no entienda también "a la de la leche".

>x jarra de leche
Es una jarra que contiene leche
De esta forma el parser no nos pide desambiguación, ya le hemos aportado el dato de que es la jarra de leche y no la de agua.

>x leche de jarra
Es una jarra que contiene leche
Primer problema, el parser no diferencia la "jarra de leche" de la "leche de la jarra", ya que ambos objetos tienen la misma puntuación, pero elige el objeto "jarra de leche" debido a que la "leche" está dentro de la jarra (En caso de empate el parser considera más importantes los objetos que no están dentro de otro, y toma su propia decisión).
Si moviéramos el objeto "leche" a la localidad, obtendríamos una pregunta de desambiguación, al existir empate: ¿Cuál concretamente, la jarra con leche o la leche de la jarra?

>x leche
Leche, la jarra está llena de leche.
Correcto

>x blanca
Leche blanca, la jarra está llena de leche.
Nuevo problema: el sistema de puntuación por defecto valora los adjetivos aun ante la ausencia de un nombre, dando lugar a extrañezas como ésta. O incluso cosas peores, como que al escribir "EXAMINAR CONTIENE", el parser detecte que nos referimos a alguna de las jarras:
>x contiene
¿Cuál concretamente, la jarra con leche o la jarra con agua?

Ahora vamos a modificar el código del ejemplo de arriba, descomentando las siguientes líneas:

Replace ParseNoun;
Include "IntnombreINFSP.h";

Compilamos de nuevo, y algo ha cambiado en el parseado, vamos a ver:
Puedes ver una jarra con leche y una jarra con agua.
>x blanca
No veo eso que dices.
Hemos arreglado lo de los adjetivos que querían tener demasiado protagonismo.

>x leche blanca
Leche blanca, la jarra está llena de leche.
Como vemos, los adjetivos funcionan sólo acompañados de alguno de sus nombres.

>x jarra
¿Cuál concretamente, la jarra con leche o la jarra con agua?
>agua
Es una jarra que contiene agua
La pregunta de desambiguación del parser ante objetos con nombre idéntico sigue funcionando correctamente.

>x jarra de leche
Es una jarra que contiene leche
Y si desambiguamos nosotros directamente en la orden, nos ahorramos la pregunta del parser.

>x leche de jarra
Es una jarra que contiene leche
Seguimos con el mismo problema de antes. Ambos objetos tienen la misma puntuación, pero la leche está contenida dentro de la jarra y sale perdiendo.
En cualquier caso, el sacar la leche de la jarra no arreglaría el problema, entraríamos en un bucle de preguntas "leche de jarra" versus "jarra de leche" del que sólo saldríamos aportando una palabra que esté contenida en el campo name o adjectives de uno de los objetos y no en el otro, por ejemplo:
Con "x leche BLANCA de la jarra" ganaría la leche.
Con "x jarra QUE CONTIENE leche" ganaría la jarra.

Pero de todos modos, de la misma forma:
Con "x jarra de la leche BLANCA" seguiría ganando la leche.
Y con "x leche QUE CONTIENE la jarra" seguiría ganando la jarra.

De modo que nuestro problema sigue ahí.
Pero vamos a solucionarlo en seguida:
Para empezar descomentamos la línea que le otorga prioritario al objeto lechedelajarra:

object lechedelajarra "leche de la jarra" habitacion
with name 'leche',
adjectives 'jarra' 'blanca',

prioritario 3,
description "Leche blanca, la jarra está llena de leche.",
has female;

De modo que a partir de ahora en caso de empate siempre ganará la leche sobre la jarra.
Si el objeto tiene la propiedad prioritario, al elegir el objeto ganador, en caso de empate éste recibirá unos puntos extra, por enchufe.
Según vemos en el código, en lugar de un punto por coincidencia, recibiría el valor de su propiedad prioritario más otros dos, un total de 5 puntos.
La función ChooseObjects se encarga de eso: de adjudicar puntos entre todos los objetos en base a las coincidencias de su vocabulario con lo que ha escrito el jugador para determinar cuál de ellos es el ganador.

Sólo con esto, la leche ganaría siempre con sólo cumplir que el jugador haya escrito "leche", y tampoco es lo que queremos, pues sería elegida al escribir "jarra de leche".

Vamos a plantear una regla sencilla tal que, si el jugador escribe jarra antes que leche, significará que se refiere a la jarra de leche; y si en cambio escribe leche antes que jarra, se referirá a la leche de la jarra.

Añadiremos este código detrás de la función Initialise de nuestro listado (ojo, sólo funciona para compilar en Glulx, al final incluiré las pequeñas modificaciones para que compile en Máquina-Z):

[BeforeParsing i j thisword thislength x exceso; !
    variable1=0;
    for (i=parse-->0,j=1:j<=i:j++) !ATENCIÓN; en Zcode es "parse->1", en Glulx es "parse-->0"
           !!!parse-->0 devuelve el número de palabras escritas,num_words = parse-->0;
    {!mnfo
        thisword = WordAddress(j);
        thislength = WordLength(j);
        if ( thisword -> 0 >= 'a' && thisword -> 0 <= 'z' )
            { !bucle
                if(thisword->0=='j' && thisword->1=='a' && thisword->2=='r' && thisword->3=='r' && thisword->4=='a'){if(variable1==0)variable1=1;}
if(thisword->0=='l' && thisword->1=='e' && thisword->2=='c' && thisword->3=='h' && thisword->4=='e'){if(variable1==1)variable1=2;else variable1=3;}

            } !blucle
    }!mnfo
!Resumen:
!Si el jugador ha escrito jarra antes que leche, variable1 valdrá 2
!Si el jugador ha escrito leche antes que jarra, variable1 valdrá 3
!Si el jugador ha escrito jarra, pero no leche, variable1 valdrá 1
];

Ahora nos vamos a la función Chooseobjects, y añadimos una línea extra dejándola así:

[ChooseObjects obj code;
   if(code==2){
        if(obj has nombreusado){
                if(obj==jarradeleche && variable1==2)return (20); !
                if(obj provides prioritario){
                    return (obj.prioritario+2);
                    }

                    return 1;
                        }
            return 0;
        }
if (code<2) { if (obj has scenery || obj has static) return 2; rfalse; } !
if (action_to_be==##Eat && obj has edible) return 3;
if (obj hasnt scenery || obj hasnt static) return 2;
return 1;
];

Hemos introducido esta línea:

if(obj==jarradeleche && variable1==2)return (20);

Y lo que estamos haciendo, es decirle a la función que otorga puntuaciones que si el jugador ha escrito "jarra" y "leche", y además ha escrito "jarra" antes que "leche", que le dé 20 puntazos a la jarra ¡toma ya! ¡A ver qué otro objeto puede ganar ahora a la jarra por mucho prioritario que tenga!
No hace falta hacer lo mismo con la leche, pues recordemos que al haberle dado la propiedad prioritario, la leche ya recibirá una puntuación extra (menor, pero suficiente para ganar a la jarra) caso de que la premisa anterior no se cumpla.
A continuación compilamos y crucemos los dedos (aún no sé si funcionará):

>x jarra de leche
Es una jarra que contiene leche
>x leche de jarra
Leche blanca, la jarra está llena de leche.

¡¡¡Toma, toma y toma!!!

Por si acaso, comprobamos que la jarra no recibe los 20 puntacos cuando no especificamos que es la jarra de leche:
>x jarra
¿Cuál concretamente, la jarra con leche o la jarra con agua?
Y funciona correctamente.

A todo esto, igual alguien se está preguntando quién diablos va a utilizar "leche de la jarra" para referirse a la leche. Como esto es un ejercicio de desambiguación, vamos a imaginar que, además de la jarra con leche y la jarra con agua, existe un vaso con leche. Entonces, al escribir simplemente "leche", recibiríamos la pregunta ¿Cuál concretamente, la leche de la jarra o la leche del vaso? y de ahí que pueda ser importante que el parser diferencie la leche de la jarra de la leche del vaso, de la jarra de leche, y del vaso de leche.

Éste es el código definitivo:

global variable1 =0;
Constant Story "desambiguación";
Constant ADMITIR_COMANDO_SALIDAS;
Replace ChooseObjects;
#Include "Parser";
!! ATENCIÓN. USAR VALORES DE prioritario entre 1 y 7
[ChooseObjects obj code;
   if(code==2){
        if(obj has nombreusado){
                if(obj==jarradeleche && variable1==2)return (20); !
                if(obj provides prioritario){
                    return (obj.prioritario+2);
                    }

                    return 1;
                        }
            return 0;
        }
if (code<2) { if (obj has scenery || obj has static) return 2; rfalse; } !
if (action_to_be==##Eat && obj has edible) return 3;
if (obj hasnt scenery || obj hasnt static) return 2;
return 1;
];

#Include "Verblib";
[ Initialise;
location=habitacion;

rtrue;
];

[BeforeParsing i j thisword thislength x exceso; !
    variable1=0;
    for (i=parse-->0,j=1:j<=i:j++) !ATENCIÓN; en Zcode es "parse->1", en Glulx es "parse-->0"
           !!!parse-->0 devuelve el número de palabras escritas,num_words = parse-->0;
    {!mnfo
        thisword = WordAddress(j);
        thislength = WordLength(j);
        if ( thisword -> 0 >= 'a' && thisword -> 0 <= 'z' )
            { !bucle
                if(thisword->0=='j' && thisword->1=='a' && thisword->2=='r' && thisword->3=='r' && thisword->4=='a'){if(variable1==0)variable1=1;}
if(thisword->0=='l' && thisword->1=='e' && thisword->2=='c' && thisword->3=='h' && thisword->4=='e'){if(variable1==1)variable1=2;else variable1=3;}

            } !blucle
    }!mnfo
!Resumen:
!Si el jugador ha escrito jarra antes que leche, variable1 valdrá 2
!Si el jugador ha escrito leche antes que jarra, variable1 valdrá 3
!Si el jugador ha escrito jarra, pero no leche, variable1 valdrá 1
];

!###########################################
object limbo "limbo"
with
! Esto no sirve para nada, es para evitar un error si no declaramos
! al menos una vez la propiedad prioritario
prioritario 0,
;

object habitacion "habitacion"
with
description "...",

has light;

object jarradeleche "jarra con leche" habitacion
with name 'jarra',
adjectives 'leche' 'con' 'que' 'contiene',
description "Es una jarra que contiene leche",
!prioritario 2,
has female transparent;

object jarradeagua "jarra con agua" habitacion
with name 'jarra',
adjectives 'agua' 'con' 'que' 'contiene',
description "Es una jarra que contiene agua",
!prioritario 2,
has female transparent;

object lechedelajarra "leche de la jarra" jarradeleche
with name 'leche',
adjectives 'jarra' 'blanca',
prioritario 3,
description "Leche blanca, la jarra está llena de leche.",
has female;

!###########################################
! Procedemos a reemplazar el Parsenoun de la librería por el código de la
! librería Intnombre que hemos descargado. Con esto conseguimos que los
! adjetivos puntúen previa detección de un nombre.
Replace ParseNoun;
Include "IntnombreINFSP.h";
#Include "SpanishG";

Pero no cantemos victoria. Este método, además de ser un tanto chusco, no es el correcto para este caso, ya que en cuanto intentemos "sacar la leche de la jarra de la leche" veremos cómo se nos cae todo el tinglao.
Por tanto no es correcto para objetos que puedan aparecer combinados dentro de la misma orden.
Ya avisé que iba a marear la perdiz.

Pero sí que existe una solución que funciona y realizada de forma más limpia, que explicaré en el segundo capítulo de desambiguación, con un ejemplo que apareció en los foros del CAAD:

¡¡¡¡LA CAJA DE CERILLAS!!!!

Por último pondré una par de ejemplos donde el uso de la propiedad prioritario es bastante interesante:
Tenemos dos PSIS, uno se llama Jose, y el otro Jose Luís.

object jose "Jose"
with name 'jose',
prioritario 2,
has animate proper;

object joseluis "Jose Luís"
with name 'jose' 'luis',
has animate proper;

De esta forma, cuando se encuentren ambos presentes, al escribir "Jose" detectaremos a Jose, pues al tener prioritario, es el "enchufado" por encima de Jose Luís. Y para Jose Luís deberemos escribir "Jose Luís", o "Luís".
Por otro lado, cuando sólo esté presente Jose Luís, podremos llamarle "Jose" a secas tranquilamente.

Otro ejemplo menos rebuscado es un objeto "rama suelta" con name 'rama', y un objeto "rama del árbol" con name 'rama' 'ramas' y adjectives 'arbol', que a diferencia de la primera es una rama que aún permanece unida a su árbol de origen.
Le ponemos la propiedad prioritario a la rama suelta, y cuando estén ambas presentes, al escribir ex rama, examinaremos la rama suelta. ¿Que queremos examinar la rama que pertenece al árbol? pues escribimos ex rama del árbol.
Si la rama suelta no está presente podemos escribir ex rama y el parser detectará la del árbol, pues no hay más.
También sería interesante que la rama del árbol dispusiera en su propiedad adjectives de vocabulario como 'otra' 'otras' y 'mas', por si el jugador quiere arrancar otra rama, o arrancar más ramas.

Si no deseamos intervenir y que sea el parser el que lance la pregunta de desambiguación, entonces no usaremos la propiedad prioritario, pero nos aseguraremos de que la rama suelta tenga en adjectives 'suelta' 'cortada' o 'arrancada', para disponer de vocabulario exclusivo que la diferencie de la otra.

Habiendo parcheado el modo de parseado por defecto que daba puntuación a los adjetivos al margen de los nombres, con la librería Intnombre.h, la propiedad adjectives se abre para usos más allá de los adjetivos. Así podemos incluir palabras variopintas en la propiedad adjectives:

object corona "corona del Rey Cucufato"

with name 'corona',

adjectives 'que' 'fue' 'pertenecio' 'al' 'rey' 'cucufato' 'vieja' 'antigua' 'propiedad',

description "Vieja corona que perteneció al rey Cucufato.",

has female;

Notas importantes:
* Para que el BeforeParsing funcione en Máquina-Z hay que cambiar esto:

for (i=parse-->0,j=1:j<=i:j++) !ATENCIÓN; en Zcode es "parse->1", en Glulx es "parse-->0"

por esto otro:

for (i=parse->1,j=1:j<=i:j++) !ATENCIÓN; en Zcode es "parse->1", en Glulx es "parse-->0"

* Si estamos programando con InformATE en lugar de con InfSP6, la función Chooseobjects cambia, porque para empezar, se llama EligeObjetos, quedando así:

[ EligeObjetos obj codigo prio;
    prio=ElegirObjetos(obj,codigo);
    if (codigo>=2)
    {
        if (obj has nombreusado){
         if (bandera_todo_vale==0) prio=prio+10;
    if(obj==jarradeleche && variable1==2)return (20); !!!!!
    if(obj provides prioritario)prio=prio+obj.prioritario;
    }
    if ((obj == jugador)||((obj has escenario)&&(obj notin brujula)))
    prio=prio-10;
    }
    return prio;
];

Legend of Djel

2010-06-16T23:53:00.012+02:00

Legend of Djel es una aventura francesa de "click & point" de 1987, donde encarnamos el papel de Djel, el brujo del aire.

La presentación del juego nos deleita con una horrible banda sonora que no distaría mucho de las primeras composiciones que hicimos cuando nos regalaron el órgano CASIO por nuestra primera comunión, acompañada de unos gritos estúpidos. Son gritos sin vehemencia ni credibilidad, bien podían haber gritado ¡repollo!, ¡bonobús!, y sonaría igual de ridículo.
Estoy hablando de la versión de Amiga, en la de PC a través de DOSBOX no suena nada, salvo pitidos.
En cualquier caso, cuando nos enfrascamos en el juego acabamos conciliándonos con la banda sonora: es ideal para ambientar este disparate.
Tras el título nos aparece el gráfico de una especie de dragón que la verdad es que no pinta nada en la historia. Doy por hecho que alguien había hecho el gráfico de un dragón y, pues vamos a meterlo.

La presentación es muy muy lenta para lo poco que aporta, y no se puede saltar pues a continuación viene la pregunta de seguridad antipiratería. Aún recuerdo que un pirata me dijo en su tiempo que por probabilidad había que seleccionar siempre el color rojo. Será potra pero en las cuatro cargas que he hecho hoy tanto en PC como en Amiga he acertado a la primera.

En la carátula del juego aparecen un par de pantallas a todo color, pero lo cierto es que en la versión de Amiga se emplearon sólamente 8 colores para los gráficos, y en la de PC tanto de lo mismo, a pesar de seleccionar VGA 256 colores. Y es que el juego cabe en un disquete. En aquella época no había JPGs ni cosas por el estilo, serían gráficos tipo TIFF, sin compresión: un gráfico con 8 colores ocupa 3 bits por pixel, uno de 16 son 4 bits por pixel. Para una pantalla de 320x200, tenemos 24 Kb contra 32 Kb, y en un disquette cabían si no recuerdo mal 1,44 Mb. El caso es que pasar a una paleta más rica disparaba el consumo de memoria.

Los preámbulos son escuetos, Azeulisse (Joseluís para los amigos), señora de los 100 reinos, nos informa que ha desaparecido su hija, y que si no nacen niños en nuestras tierras es a causa de la tristeza que ello le causa. De modo que ya sabemos...
Nada más colgar Azeulisse por la bola de cristal (el teléfono móvil de la época), aparece KAL, que nos pide todo el oro que podamos fabricar para paliar el hambre del pueblo y evitar una revuelta.

Y empieza el juego. En el típico estudio de un brujo, con una mesa llena de papeles y cachivaches, entre ellos una estatuilla y un jarrón que nos teletransportarán a los mundos de Azeulisse y Kal respectivamente, y una pantalla al fondo sobre la que la estatua de un grifo escupe planetas a los que podemos viajar.

Para los que no hayan estado nunca en el estudio de un brujo, son así.

Por la puerta del fondo accedemos al alambique, donde podemos fabricar oro alquímicamente con los ingredientes correctos, que son: murciélagos y flores de plomo.

Viajamos al primer y único planeta que aparece inicialmente en la pantalla y nos encontramos con un paraje volcánico.
La interacción consiste únicamente en mover el puntero por la pantalla y pinchar aquí y allá, para ver qué pasa. En este mundo conseguimos una cosa rara que no sé lo que es, y el poder del volcán, para lanzar bolas de fuego o algo así, lo que nos vendrá muy bien para cazar murciélagos o matar abejas.

De regreso a nuestro estudio, dos nuevos mundos han aparecido en la pantalla.
El primero de ellos tiene un puzzle bastante interesante. El mago dueño de ese mundo nos informa de que no está demasiado contento con él, y nos pide que se lo redecoremos. Entonces, pinchando sobre las diversas secciones del paisaje vamos moviendo las cosas: esta planta aquí, esta cosa rara allá.
Son cinco piezas y seis espacios, de modo que cada vez que pinchamos en una sección de paisaje ésta se mueve al hueco dejado tras el último cambio. Es bastante fácil la resolución, pues cada vez que una pieza cae en el lugar correcto el mago nos avisa con un ridículo grito (como los de la banda sonora de presentación).

"Me has dejao el planeta muy cuco, pero ahora quiero un joyita antes de decirte lo que sé"

El juego está lleno de decisiones trampa. Así, una vez ordenado el mundo, en lugar de un mago aparecerán dos magos ¿cuál elegimos? Uno nos dará la información a cambio de una joya (que no debemos entregar) y el otro a cambio de un combate.

Al regresar a nuestro estudio, en la sala del alambique aparece una horrenda mujer diciendo que es la hija de Azeulisse, presa de un encantamiento. ¿Debemos aceptarla? En verdad es una falsa hija, debemos rechazarla y luchar inexorablemente contra ella tras su rebote.

"Noble Djel, soy la hija de Azeulisse, aunque no me puedas

reconocer porque me acabo de levantar y aún no me he maquillado"

Y podríamos seguir. Vas pinchando por las pantallas con el ratón para que ocurran cosas porque sí, sin demasiada lógica, y de vez en cuando tienes que tomar una decisión: ¿confías en esta criatura? ¿por cuánto oro compras esto? ¿robas este objeto o esperas a que más adelante surja otra vía para conseguirlo? ¿aceptamos cambiarle a esa criatura la Daga de Demonio por el Atlas?
Vete a saber. Igual la estás cagando...

"Estoy tan desesperado que te vendo una diadema de diamantes por diez pesetas, ¿aceptas?"

La caza de murciélagos es un auténtico ful de Estambul. Van saliendo de uno a uno y tienes que acertarles lanzando bolas de fuego. El problema es que los murciélagos se mueven por la pantalla a su aire, cambiando de trayectoria y velocidad sin previoaviso, y las bolas las lanzas desde abajo y van lentísimas, luego sólo hay que disparar en los escasos momentos en que la trayectoria de un murciélago parece predecible, y rezar para que no le dé por cambiarla.

En cambio, los combates, si seleccionamos la lucha psíquica, no están del todo mal. Luchamos jugando a un juego de tablero de estrategia, donde en cada turno movemos nuestra ficha y a la vez coloreamos una casilla. El adversario hará lo mismo. Gana el primero que bloquee al contrincante, sepultándole entre casillas coloreadas. El único problemilla es que si no mueves rápidamente se te pasa el turno, y en la versión PC, a través de DOSBOX, que no admite ratón y has de mover el puntero con los cursores, es fácil que esto ocurra varias veces.

En cuanto a jugabilidad esta aventura es una patata podrida, pero tiene el atractivo -al menos para mí- de ser rara de narices.

"Me has caído bien, y por hacer click aquí te voy a regalar un poco de oro"

la interfaz conversacional

2010-04-17T18:15:00.007+02:00

Descubrí las aventuras conversacionales a través de un compañero del colegio que me habló de un nuevo juego de "hablar con el ordenador", lo cual despertó mi curiosidad y quizá determinó el rasgo distintivo que para mí diferenciaría este género de otros: la interfaz conversacional.

El prompt que esconde tras de sí una base de datos de léxico, más o menos amplio, tiene un potencial que no siempre se aprovecha. Por ejemplo, cuando una aventura sólo responde a acciones simples como: Norte, Sur, coger, dejar, empujar, hablar con...; y objetos básicos, el sistema conversacional está desperdiciado. No es más que una lista escueta de acciones o íconos escondida.

El potencial de la interfaz conversacional está en permitirnos/obligarnos a expresarnos más específicamente en nuestro idioma, yendo más allá de un lenguaje pobre y multifuncional.
Bien es cierto que para comunicarse de forma básica hace falta muy poco vocabulario. La mayor parte de las conversaciones se resuelven con una pequeña parte del léxico total de un idioma, limando el contexto las imprecisiones de las palabras multisignificado que comunmente usamos. Y las usamos porque por el precio de tener en la punta de la lengua una palabra de esas, nos ahorramos tener cinco más concretas y normalmente más largas. A éstas últimas más bien recurrimos cuando nos expresamos por escrito, pues no contamos necesariamente con ese gran aliado que es contexto, que convierte una palabra imprecisa y genérica en inequívoca, y cuando tenemos que rellenar una hoja o un tiempo de exposición, o quedar como cultos y formados.

Por ejemplo, la palabra "pillar" nos vale para expresar: coger, agarrar, atrapar, robar, comprar, sorprender, sostener, atropellar, reservar, tomar un vehículo o ruta, contraer una enfermedad o estado de ánimo, alcanzar, ligar, recibir algún golpe en una pelea...
A grandes rasgos podríamos sacar una consecuencia común de todos los significados: hacerse con el dominio de un ente, situación o lugar... o un moratón.

En las aventuras gráficas tenemos interfaces basadas en un idioma simplificado, en diversos grados. Desde las aventuras con unas pocas acciones: coger, examinar, accionar y usar; a otras como las de Lucasfilms con una lista más amplia.
Pero a fín de cuentas es una simplificación, una selección que se traduce en una comunicación pobre que se perdona aceptando las reglas del juego.

Así, "reventar la puerta con el pico" se traduciría en este microlenguaje como "usar pico con puerta"; "engrasar las bisagras de la puerta" como "usar aceite con puerta"; "pintar la puerta de rojo" como "usar bote de pintura roja con puerta"; y "pintar un círculo rojo con un puntito en medio en la puerta" como... "usar bote de pintura con puerta", curiosamente exactamente igual que "pintar una equis en la puerta".

El sistema conversacional, además de la posibilidad de obligarnos a usar un lenguaje más rico, ofrece este potencial de especificidad y de ir más allá de forma inequívoca.

Por supuesto, aquí existe un conflicto entre el ideal y la práctica.
Volvemos al ejemplo de engrasar las bisagras de la puerta.
Si admitimos "echar aceite en puerta" como acción sinónima de "engrasar las bisagras", abrimos la puerta (nunca mejor dicho) al microlenguaje genérico y pobre de la aventura gráfica. En cambio, si somos estrictos-puñeteros, nuestra aventura será muy poco interactiva, se convertirá en un "adivina la palabra exacta".

Personalmente creo que lo mejor es admitirlo todo (excepto "usar"). Al menos en este ejemplo, no cabe duda de que el jugador que escribe "echar aceite en puerta" no tiene otro fin que engrasar las bisagras... ya sería raro que hubiera alguno que tuviera en mente barnizar la madera de la puerta con esa acción.
En otros casos la aceptación sería más discutible.

Aventuras online

2010-04-15T19:02:00.008+02:00

Re-cayendo en la posibilidad de ofrecer las aventuras online, como hace Incanus en su página o Literactiva, he colocado la única que tenía en Máquina Z: "El caso del misterioso asesinato del domador de pulgas del circo de Montmartre", así como "Venenarius Verborum", que he tenido que convertir previamente eliminando toda la morralla de GLK. Y también resolver un pequeño quebradero de cabeza por exceso de anidaciones (branches), ya que por lo visto la Máquina Z tiene unas limitaciones a ese respecto inferiores a GLULX.

En la citada página de Incanus se exponen dos formas de colocar una aventura online:

Mediante un applet java, ZPlet, para lo que necesitas tener instalado un Java Runtime.
Mediante, Parchment, que ha sido la opción que he escogido, ya que mi intención era que el potencial jugador no tuviera que descargar ni instalar absolutamente nada, simplemente hacer click y empezar a jugar.

Usar Parchment es tan sencillo como añadir el siguiente enlace en tu web:
http://parchment.googlecode.com/svn/trunk/parchment.html?story=http://misitioweb.com/aventura.z5

Más fácil imposible.
Por ahora este intérprete online sólo admite aventuras compiladas para Máquina-Z, y ralentiza un poco.
Desde luego que es mucho más cómodo descargarse la aventura al ordenador y jugar con un intérprete en condiciones como Winglulxe, Frotz, o Gargoyle.

Pero pongámonos en la piel de un visitante extraño, o imaginemos que somos nosotros ese extraño. Llegamos a la página de un fulano que no conocemos de nada, y que nos dice que tenemos que descargar nosequé programa extraño para jugar a sus juegos.
Tanto por pereza como por la sospecha de que nos intenten colar un troyano, es posible que valoremos que no merece la pena . A fín de cuentas, ¿quiénes son esos tipos? ¿qué garantías ofrecen?
Incluso si ya sabemos de qué va la cosa y nos fiamos de esta gente, igual queremos probar antes el juego, a ver si nos atrae la temática.

Otra opción online es programar una aventura directamente en Kenshira, que al estar orientado a la publicación web ofrece una excelente puesta en escena.

El tema se ha comentado en este posteo del foro.

Actualizaciones:
Presi ha habilitado un redirector para Parchment dentro de CAAD, que se actualizaría en el caso de que la url de Parchment cambiase.
De modo que podemos poner el siguiente enlace para meter una aventura de Máquina-Z online en nuestro sitio web:
http://www.caad.es/jugar?aventura=http://sitioweb.com/aventura.z5

Uto acaba de crear un lanzador GLULXE para ZAG.
El lanzador, a diferencia del intérprete web, lo que hace es automatizar el proceso de descarga y ejecución de la aventura y el intérprete ZAG en una ventana JAVA dentro de nuestro ordenador, por lo que tendremos que tener instalado JAVA.
Para meter una aventura GLULXE en nuestro sitio web auto-lanzable, colocaremos el siguiente enlace:
http://www.caad.es/superglus/online/jugarglulx.php?aventura=http://sitioweb.com/aventura.blb

O mejor lo cargaremos especificando además un fichero de configuración .cfg, que básicamente contendrá esto:
WindowBorders=no
Para que no aparezcan los poco estéticos bordes entre ventanas.
Así:
http://www.caad.es/superglus/online/jugarglulx.php?aventura=http://sitioweb.com/aventura.blb&config=http://sitioweb.com/aventura.cfg

El problema es que estamos hablando de ZAG. ¡¡ZAG!! Sí, un intérprete Glulxe que no admite sonidos OGG y sólo AIFF y MOD de 4 canales, además de ofrecer una visualización horrorosa con parpadeos en algunos refrescos.
Así era en el 2005, y así es, pues no ha habido nueva versión desde entonces.

El nuevo blog de Melitón

2010-03-21T17:17:00.004+01:00

Golpéalo!, Hit it!. Así se llama el nuevo blog de Mel, que sin abandonar del todo su Guarida, dedica este nuevo espacio a "golpear" y hablar sin pelos en la lengua. Haciendo crítica de aventuras y de tendencias.

Hace tiempo tuve un capítulo con Mel en el foro del CAAD que fue algo así como que él hizo una crítica de una aventura mía achacándole ciertas carencias, a lo que yo le respondí que no es que la aventura careciera de aquello, sino que él no lo había visto. Recuerdo que se lo tomó como si hubiera herido mi susceptibilidad, demostrando una vez más, que no se podía hacer crítica libre dentro del CAAD, e hizo mutis por el foro creando una entrada en su blog para expresar su decepción. Yo me lo tomé como que la susceptibilidad herida fue la de Mel, que no aceptaba la contracrítica o las puntualizaciones.

Pensando sobre eso, creo que metí un poco la pata. Es mejor callarse (aunque cueste) y dejar que la crítica fluya sin obstáculos, que buena falta hace. Es preferible crítica demasiado subjetiva (y quizá injusta desde el punto de vista del autor) que el "buenapintismo". (Además, releyendo, mi respuesta fue bastante pendenciera)
Es decir, ¿que alguien dice que le falta tal a la aventura? Perfecto, aunque uno crea que es incorrecto, esa persona no lo ha visto, y lo que está relatando es su experiencia ante esa aventura. Y en su experiencia personal eso no apareció.

Prefiero leer críticas de lengua larga (no necesariamente de mis aventuras, sino de las demás) que comentarios vagos y diplomáticos. Dicen mucho más, aunque sean poco científicas.
Por ejemplo, la crítica negativa que ha escrito Mel sobre "A veces ", de Jenesis, da muchas más ganas de rejugarla que un comentario sospechosamente moderado.

Trofeo Orcoscomp

2010-03-20T12:53:00.000+01:00

Esta mañana Planseldon me ha hecho entrega de mi trofeo de la Orcoscomp, por El Cristal Rojo:

Videos musicales con Pyhton

2009-12-26T14:23:00.010+01:00

A falta de un editor de vídeo que permita mezclar animaciones sobre fondos y moverlas, me puse con pyhton-pygame a crear un vídeo musical.
Es todo parecido a crear un juego, con la diferencia de que no hay control externo.

Como ha de sincronizarse con una pista musical, tengo una serie de variables que me van diciendo en qué punto de la canción estoy, de acuerdo con la base musical en MIDI.

Así hay una variable tiempo que va corriendo hacia adelante en décimas de segundo.
Cada 16 tiempos sube un valor la variable tiempo_cuarto, que sería aproximadamente el tiempo transcurrido entre un bombo y una caja en ritmo simple,
y cada dos tiempo_cuarto sube un valor la variable tiempo_measure.

El "measure" es la unidad de medida de mi secuenciador, y podría asimilarse a hojas de partitura. Cuando termina un measure aparece otro con nuevas notas.
Normalmente relleno los measures con 4 bombos y cajas a ritmo simple, aunque este es de los pocos casos en los que el measure contiene la mitad de información (y lógicamente tocado al doble de velocidad): bombo-caja-bombo-caja, fín del measure.

Con estas variables, empiezo a lanzar las animaciones:
En la segunda mitad del octavo measure empieza a cantar, entonces:
if tiempo_measure==8 and tiempo_cuarta==2:
Player.accion_cabeza=1
Player.accion=2
Player.escala=2
Player.x=200
Player.vx=4

La cabeza está separada del cuerpo, y tiene cuatro tipos de acciones:
0. callao
1. mueve la boca abriéndola bastante, prononciando aes, o como gritando.
2. mueve la boca con proliferación de dientes apretados, como pronunciando eses.
3. mueve la boca con proliferación de "morritos", oes o plosivas.

El cuerpo tiene 8 tipos de animaciones, depende del que seleccione se pone a bailar de una forma o de otra, o bate una espada, se pone a saltar... así sin parar hasta que le de otra orden con otro tipo de movimiento

Vx es el desplazamiento horizontal en pixels que hará el personaje cada fracción de tiempo, hasta que le mande otro valor o le pare, con Vx=0.

La escala determina el factor de escala, valga la redundancia, por el que se multiplicará el tamaño del cuerpo y la cabeza, recalculando la posición. Para hacer primeros planos.

En fín, que con la partitura MIDI de la canción, es como si le dieses un guión al protagonista de lo que tiene que hacer en cada momento... y hasta nueva orden.
Ponte a saltar... ahora mueve la boca... ahora cállate, ahora por el fondo de la cueva. Ahora colócate a la derecha y avanza hacia la izquierda levantando las piernas, ahora acércate, ahora aléjate y pon el fondo del bosque...

Con la canción sonando al lado hay que ajustar el metrónomo de Pygame para que vaya acompasado.. y aquí está el único problema.
El tiempo de python no es exacto, cada vez que cargas el programa su velocidad de ejecución varía ligeramente, sin importancia para un juego, pero un desastre cuando todo tiene que ir sincronizado. Si antes te iba más o menos bien ese metrónomo, ahora descubres que el video adelanta a la música...o que se queda atrás.
Por lo que al final habrá que reajustar el tiempo de todo el vídeo, con algún programa que te permita algo del tipo "convertir la duración de 2 minutos a 1:58:32"

Si el vídeo corriera al tiempo con la música, se podría meter un control de la boca mediante teclado, de forma que mientras canta le vas indicando al muñeco por golpes de teclado cómo ha de abrir la boca, clavándolo con la letra. Y grabando el vídeo en vivo... sería como un directo XD

La canción del vídeo es ésta, una parodia de David el gnomo, David el orco, con un orco como protagonista. Aunque para el vídeo sonará en versión revolucionada, a más velocidad y con el pitch agudo cuatro tonos subido, que queda más hilarante, sin llegar a sonar a "pitufos maquineros".

Aún no la he terminado porque me falta meterle a los orcos coristas.

Rectificación: Hoy lo he probado varias veces y va clavado con la música, de modo que no necesitaré ningún programa externo para mezclarlo. Igual tiene que ver con la librería time que le metí a última hora para dejar un lapso antes de que empezara el vídeo.

Aquí está:

Elige tu propia orcoaventura

2009-12-03T16:26:00.003+01:00

Quizá haga algo para la orcoscomp. Estoy planeando un mix entre aventura conversacional y librojuego con combates. Gracias a Eliuk ya tengo el código funcional para lo que es el motor, formado con extractos de la librería Fhablao.h, un parche de Datoki y sustituyendo los "Quips" por flags, usando la librería NewFlags.h

Ahora se me plantea la dificultad de crear las escenas librojuego. El concepto de puzzles es completamente diferente aquí que en modo conversacional. De hecho es complicado implementar algo parecido a un puzzle con un sistema de opciones, casi estás dando la solución.
Por tanto, por un lado los textos, el relato, cobran más importancia. Por otro, cuando el jugador debe decidir, las opciones deben de tener algún sentido e interés, el cual estará fuertemente ligado al interés que despierte el propio relato.

Lo cual no ocurre en la conversacional, donde tenemos multitud de opciones invisibles, y de entre ellas muy pocas que sean realmente prácticas.

Al principio pensé en esto con la idea de que sería más rápido y sencillo hacer un librojuego que una aventura conversacional corta, pero me estoy temiendo que no va a ser así, aun con el motor listo.
Podría "fusilar" algún libro de Lobo Solitario... XD
A parte de tener que pensar todas las subtramas, esto va a ser como volver a programar por tablas, haciéndote un mapita en árbol de localidades y comunicaciones entre ellas (opciones).
Claro, que todo se puede simplificar:

En cuanto al sistema de combate, se basará en turnos alternativos de atacar-defenderse, entrando en juego la Destreza en el Combate, la Energía, la ruleta, bonificaciones o penalizaciones en función del tipo de ataque, y penalizaciones por luchar contra más de un enemigo.

La energía mide tanto la vida como el cansancio, cuanto más fuerte estés mejor peleas.
Cuando la energía llega a cero mueres, incapaz de defenderte más.
.
Atacar a más de un enemigo supone que tienes que dividir tus puntos de destreza a la hora de defenderte entre el número de amenazas.

Las tiradas de la ruleta son de 0 a 9, siendo 1 pifia (fallo seguro) y 0 (10) acierto seguro. Además, sacar un 0 atacando a un enemigo que anteriormente obtuvo pifia supone un crítico: daño x 3.

Las tácticas de combate son 4:
1. defensiva.
2. equilibrada.
3. ofensiva.
4. sucida (berserker).
La defensiva es la única que no consume energía, se basa esquivar y buscar buenas posiciones para atacar sólo ante oportunidades claras. Como compensación, en el turno siguiente tendremos una bonificación de defensa.
La sucida es la que más aumenta la probabilidad de acierto en el enemigo, a costa de que en el turno siguiente, cuando seamos atacados, sufriremos una penalización en nuestra defensa, y además consume más energía.
El resto de las opciones tienes sus bonificaciones y penalizaciones igualmente.

Lor rivales mayormente serán orcos, lo que se traduce en una destreza en el combate inferior a la del protagonista, pero una fuerza mayor. Es decir: tienen menos probabilidad de acertar, pero cuando aciertan, su daño base será mayor. En la característica de Fuerza están incluídas tanto la potencia del atacante como la del arma con la que golpea.

Todas las reglas son ambivalentes, se aplican por igual al protagonista y a los enemigos, que también decidirán individualmente la táctica de combate que más les conviene en cada turno.

Orcoscomp

2009-11-30T22:18:00.010+01:00

OrcosComp
Fecha límite de recepción de obras 31 de Diciembre de 2009.

20 aniversario del CAAD

2009-06-24T22:23:00.001+02:00

Fín de Semana 3-5 de Julio

La Venganza de Yan, release 0

2009-05-21T23:56:00.006+02:00

Acabo de subir al CAAD La Venganza de Yan.

Yan, ausente durante años labrándose un futuro en el ejército, regresa unos días a su isla natal.
Y en ella descubre que de la aldea sólo quedan ruinas y brasas aún calientes y humeantes.
¿Quién ha podido hacer esto?
¡Quien haya sido lo pagará!

Ocupa unos 10 megas, de los cuales la mitad son gráficos, luego sonido, y por último el código en sí, que son 500 Kb.

Para más información podéis leer el comentario de Urbatain en SPAC, tras testear la aventura, o entradas anteriores de este mismo blog para detalles técnicos.

me paso a Damusix

2009-05-20T18:11:00.005+02:00

El sistema de sonido que venía usando hasta ahora, basado en Efectos.h, tenía un fallito relacionado con el volumen de los canales de sonido, que a veces sonaban más bajo como si arrastrasen una configuarción anterior sin actualizarse correctamente.
Pero ayer Urba me reportó un nuevo bug gordísimo: al guardar una posición con el sonido desactivado, y volver a cargarla, el sonido reaparecía y no había forma ya de quitarlo.

Como en el tema de la restauración GLK mis conocimientos se reducen al COPYPASTE y se me estaba inchando la cabeza, opté por la mejor solución. Damusix funciona bien... pues me paso a DAMUSIX.

El manual parece un tocho, pero está escrito con letras grandes y tampoco es para tanto. Es una librería bastante sencilla de usar, con funciones minimalistas -como las llama el autor- que me han venido de miedo para realizar la sustitución a nivel de funciones de sonido sin tener que reescribir un código que ya estaba hecho. A parte que me servirá para parchear otras aventuras antiguas.
Por ejemplo, la instrucción musica (sonido, volumen); la mantengo en el código, pero el contenido de la función en lugar de llamar a instrucciones de Efectos.h, ahora llama a instrucciones de DAMUSIX.

[musica que_sonido quevolumen;
Damusix.AsignarCanal(que_sonido,0,quevolumen,-1);
Damusix.Tocar(que_sonido);
cancionquesuena=que_sonido;
bajandovolumen=0;
cancionquesonara=0;
rtrue;
];

Y así con todas. Algunas variables son ya innecesarias, pero las mantengo porque se usan en los códigos, y se trata de que estos tengan que modificarse lo mínimo.

Es una librería muy fácil de utilizar. No hay que quebrarse la cabeza ni planificar nada. Sólo mandarle instrucciones al kernel de la librería, y éste ya se ocupa de lanzar un sonido, apagar otro anterior que ocupara el mismo canal; o de cosas más peliagudas como las restauraciones y los UNDO.

El único tropezón lo he tenido por las interferencias de los HandleGlkEvent e IdentifyGlkObject de la librería DAMUSIX con los míos propios. Culpa mía por lanzarme a compilar sin terminar de leer el manual, donde se explicaba la resolución de estos puntos.

interferencias de la librería Inform

2009-05-02T02:02:00.003+02:00

Pues resulta que el código para analizar las cadenas de texto introducidas en el prompt (en el BeforeParsing) falla con "dame", no lo detecta, y sólo me queda pensar que la librería transforma los "dame" en otra cosa distinta antes si quiera de que el programador pueda intervenir.

En efecto, he probado a detectar "da" (es decir "d"+"a"+longitud de la cadena=2), y cuando escribo "dame", me lo da por bueno. Comprobado entonces que cada vez que escribes "dame", se descompone en "da" + personaje_jugador.

Un pelín fastidio, ya que te imposibilita la intervención desde el código cuando, como en este caso, pretendes hacer un parseado alternativo.

Ahora me toca revisar todas las formas reflexivas y eliminarlas.

Gráficos con Inkscape

2009-04-29T09:47:00.005+02:00

Llevo cosa de un mes usando Inkscape, a la par que Urbatain (lo cual habrán notado por su serie de pruebas de concepto de El Anillo).

Haciendo los gráficos para "La venganza de Yan", empecé con un estilo sencillo para poder ir rápido. El caso es que cuando vas cogiendo destreza, puedes hacerlo menos sencillo sin perder velocidad.
He usado mucho del reciclaje de siluetas para abarcar las diferentes localidades de una misma zona.
Por ejemplo, para dibujar un bosque pinto unos pocos modelos de follaje, ramas y troncos, y lo que sigue es un copy-paste a lo bestia. Una vez compuesta la escena, se copia y se reordena todo para hacer otra localidad.

Y no todo es Inkscape. Aunque es ideal para dibujar las siluetas y calcar de imágenes... para los retoques finales o para dibujar las sombras de los personajes es preferible usar un programa de retoque fotográfico, a base de máscaras.
Así lo estoy haciendo finalmente, tras una fase incial de intentar obtener el acabado definitivo con el propio Inkscape.

El nivel de calidad ha ido in-cresccendo, y eso se nota comparando los primeros dibujos con los últimos. Las primeras localidades voy a tener que redibujarlas porque se han quedado muy atrás.

El tamaño de los gráficos es de 720 x 195 px

La Venganza de Yan

2009-04-06T22:01:00.007+02:00

Estos días estoy programando una historia que se me ocurrió el jueves. La programación va a buen ritmo, sólo que me falta por planear las secuencias finales (que no el final). Realmente ha ido saliendo todo improvisado a partir de la idea general.
La ambientación está inspirada en un antiguo largometraje animado chino llamado "Taro el niño Dragón (Tatsunoko Taro)"... aunque de la inspiración a la expiración hay un trecho ;D

Por fín voy a implementar para algo más que para juegos de palabras lo que aprendí del código de "Ad Verbum": para conversaciones con PSIS y como apoyo a otros objetos del juego, para poder especificar detalles sin necesidad de crear nuevos objetos ligados.

Se trata de un parseado en paralelo, que no suplanta sino que complementa, un parseado de reconocimiento de cadenas o de trozos de texto.
Inform funciona igual que siempre, sólo que cuando quiero le consulto al otro parseado qué ha encontrado, y así puedo dar mejores respuestas a las cosas que me interesen.

He dispuesto 5 variables que recolectan los valores coincidentes del parseado en paralelo, y son estas variables las que se consultan luego desde el código de los objetos y las funciones.

Es un sistema a la vieja usanza. Te tienes que haces una tabla y apuntar qué número está representando a qué concepto (uso "concepto" para describir un grupo de palabras o cadenas que vienen a ser sinónimas en el contexto del juego). Y a la vez escoger bien cómo haces las listas, en qué orden pones las cadenas en el código y cuál de las 5 variables será la encargada de almacenar cada tipo de concepto. En principio una variable cazará conceptos referidos a pronombres, otra cazará partículas interrogativas, otra acciones, otra nombres y otra adjetivos, en principio, porque en la práctica se mezcla todo un poco para aprovechar donde no se necesita y no se prevee que haya conflicto.

La detección de cadenas se realiza por barrido secuencial, no por el orden en que ha sido escrito, sino por el orden en el que cada cadena está escrita en el código. Cada variable adquiere el valor del último concepto coincidente de su lista personal. De modo que si dos cadenas vitales están en la misma lista, la variable sólo almacenará la que esté más abajo en el código.

Así he empezado a programar y ya es tarde para cambiarlo, pero explicaré un sistema mejor:
En lugar de unas pocas variables para muchos conceptos...
Una variable para cada concepto, y claro, no usaremos variables sino Flags (banderas), que apenas usan memoria. Puedes crear 5000 flag y el parser ni pestañea.

De esta forma, antes de cada input ponemos todos los Flags encargados de pescar conceptos en false, y procedemos a hacer el barrido.

En nuestro código del PSI, tendremos cosas como éstas:

react_before[;
hablar:
print "Pepito dice:^";
if(FlagOn(100) && FlagOn(156)) "Me llamo Jhames.";
if(FlagOn(101) && FlagOn(157)) "El pescador se llama Josema.";
if(FlagOn(111) && FlagOn(157)) "¡¿Cómo que quieres matar al pescador?!.";
],

Como decía, hay que tener la chuleta al lado, y veremos las cadenas que activan cada flag:

Flag 100: llama*, nombre
Flag 111: mata*, asesina*, liquid*
Flag 156: tu, usted, te
Flag 157: pesc*d*r

(*) Como esto va por fragmentos, los asteriscos los he puesto a modo representativo para que se vean las partes que se pueden omitir sin problemas. Para palabras largas, para preveer varias flexiones... simplemente detectas las letras de la palabra que son fijas y que son imprescindibles para distinguirla de otra similar.
También se puede fijar la longitud.
Podemos detectar de un plumazo "amigo" y "amiga", programando la detección de "a"+"m"+"i"+"g+"+longitud=5.
Aunque para este ejemplo, lo dejaríamos en "a"+"m"+"i"+"g". Ya que la secuencia "amig" no presenta demasiado riesgo de confundirsem (o estar fundida dentro) con otra palabra. Sin determinar la longitud, el Flag saltaría a la que el jugador escribiera "amigo", "amiga", "amigos", "amigas", "amigable", "amigablemente"... etc

Y así funciona. Que el parser detecte que quieres que "Fulano te acompañe hasta el rio cantando una canción, con las manos en la cabeza y dando saltitos" es posible técnicamente, aunque aviso que no pienso implementar chorradas de ese estilo XD.

La máxima utilidad es distinguir intenciones y preguntas respecto a sujetos.
Puedes decir "Fulano"... ¿Fulano qué?
Dónde vive Fulano.
Quién es Fulano el de la derecha.
Quién es Fulano el de la izquierda.
...
La espada de Fulano... ¿qué pasa con la espada de fulano?
Dame la espada de Fulano
Encuentra la espada de Fulano
Fulano no tiene espada
...
Quiero matar a Fulano.
Hoygan nesesito un krak para Fulano es urjente.

Fuera de las conversaciones, esto sigue siendo muy útil. Por ejemplo, para un combate:
Tenemos un objeto "troll" y queremos poder elegir a dónde le atizamos con la espada.
Normalmente habría que crear un objeto "mano", un objeto "brazo", un objeto "pestaña"...

Con este sistema simplemente creamos el objeto "troll", así:

object Troll "Troll" limbo
with name 'troll' 'planseldon',
adjectives 'mano' 'manos' 'brazo' 'brazos' 'pierna' 'piernas' 'derecha' 'izquierda' 'pestaña',
before[;
Attack: print "Golpeas al troll en ";
if(FlagOn (50))"una mano.";
if(FlagOn (51))"un brazo.";
if(FlagOn (52))"una pierna";
!etc
"una parte al azar de su cuerpo.";
],
has animate scenery talkable;

Nuevamente tendríamos que mirar la lista para ver qué activa cada flag. Pero en este caso, del propio código se deduce:

Flag 50: mano*, dedo*
Flag 51: brazo*, codo*
Flag 52: pie/, pies/, pierna*
!etc

Resúmen de lo que hemos hecho:

Un único objeto
Introducimos los nombres de todos los blancos o subelementos en la propiedad 'adjectives' para que el parser trague con ellos (recordemos cómo funciona Inform, el parseado en paralelo "detectacascajos" actúa de apoyo, pero no sustituye) (*** ver NOTA1 al final)
En el código del objeto consultamos las pesquisas que ha realizado el parseado en paralelo de detección de cadenas, a ver si "ha pescado algo". De ser así, podemos programar fácimente una respuesta personalizada, y si no, dejamos que salte la respuesta estandar.

*** NOTA1:
El código del Troll arriba expuesto sólo es viable-razonable en un modo de parseado tal que la propiedad adjectives no tenga la misma jerarquía que la propiedad 'name' sino que sea dependiente. ('adjectives' sólo se consulta si antes ha habido coincidencia en la propiedad 'name')
En caso contrario, el código expuesto es inviable, pues estaría abierto a disparates tales como escribir "ex pestaña" y recibir la descripción del troll".

***NOTA2:
El código para realizar este parseado "bruto" tipo PAWS en paralelo está expuesto AQUÍ, aunque en la versión "poco óptima", usando unas pocas variables en lugar de millones y millones de Flags.

Nearco 3

2009-04-02T23:19:00.004+02:00

Nearco 3 me ha gustado por su sentido del humor, consigue unos puntos muy buenos sobre todo con el uso de sonidos.
El problema de esta aventura es la rigidez de su parseado. Peor que algo programado en BASIC por reconocimiento de cadenas, ya que aquí, además de reconocer unas pocas cadenas, tu comando se va al traste si introduces algo de más que el parser no entiende o intentas expresarte de otra forma. La lista de acciones es muy pobre.
Si bien esto al principio no es gran impedimento para la jugabilidad. Tomas consciencia de las limitaciones y te atienes a ellas.
El problema gordo vino casi al final del juego, con un puzzle para el que había con interaccionar con algo que ni si quiera aparecía mencionado en la descripción de la localidad.
Eso por un lado. Por otro, el objetivo de ese puzzle era conseguir un material que estaba presente en otros puntos del juego.
Entonces, por un lado te encuentras con que no puedes obtener ese material de las otras fuentes lógicas porque el autor no ha programado esa posibilidad. Y el lugar de donde lo tienes que obtener es invisible, tienes que suponer que existe eso en esa localidad o recordar un texto de transición de una escena que no vuelve a repetirse y donde se menciona que eso existe.

Posteriormente, Jhames, el autor, defiende la interactividad de su aventura poniendo unos ejemplos que ya hacen caer rayos al nubarrón que tenía en la cabeza a raíz de lo citado anteriormente.

La interactividad no es poder examinar una gaviota, ni tener prevista una respuesta por defecto para "cantar" o para intentar coger el sol.
La interactividad implica que el jugador tiene información suficiente para interactuar y los objetos responden a los intentos de interactuación en base a sus posibilidades y cualidades.

Una red no es interactiva aunque se pueda examinar, máxime cuando necesitas un trozo de cuerda y ni se ha contemplado la posibilidad de obtenerla de ese objeto. ¿Y eso por qué? Porque el autor ha previsto que la cuerda se obtiene de otro sitio, porque sí.
También podrías necesitar un palo y, pese a estar rodeado de árboles, ramas y palos, la única solución posible sea darle un objeto a alguien para que éste te dé el palo. Perfectamente comprensible...

Tampoco es muy interactivo al día de hoy que el parser no entienda formas alternativas (nada rebuscadas) de expresar una orden, o no entienda nada en absoluto si te da por añadir un adjetivo, un complemento genitivo de más, una palabra de más (de más para la estrechez del parser).

Eso sí, reconozco que me he pasado un pelo...

ranking de mejores aventuras en la wiki

2009-03-26T02:16:00.005+01:00

Planseldon anuncia en el foro del CAAD su intención de abrir un ranking de "las mejores aventuras de todos los tiempos"...
... y aparece hasta Jhames para quejarse de que nadie juega sus aventuras.

adaptaciones conversacionales de otros géneros

2009-03-23T23:09:00.004+01:00

En un foro del CAAD sobre la Retrocomp-09, salió el tema de la adaptación al formato conversacional de otro tipo de juegos, aventuras gráficas, videoaventuras...
Cualquier juego podría adaptarse... pero no todos los juegos ofrecerían un resultado interesante. Unos pocos quizá podrían ganar con el cambio.

Estaba pensando en "The Trap Door", un viejo juego de 8 bits que cuenta con dos partes, aunque me atendré a la primera.

El juego está basado en una serie de dibujos animados con muñecos de plastilina... horrible y cataléptica. El juego en cambio estaba bastante bien.
El protagonista se llama Berk, un bicho azul, fofo y achuchable, que habita en un lóbrego sótano trabajando como sirviente de "La cosa de arriba". La Cosa se comunica a gritos con Berk, desde las dependencias de lo alto del castillo: "¡¡ Berk tráeme el desayuno!!" "¡¡Qué demonios esperas!!".
Junto con Berk, viven en el sótano del castillo Boni la calavera sabionda -que da consejos- y Drutt, un arácnido saltarín -que da saltos y se zampa cuanto gusano pilla. También hay una trampilla "The Trap Door", que en teoría Berk no debe abrir, ya que a través de ella pueden escapar todo tipo de monstruos de las mazmorras más profundas.

En cualquier caso, en el juego tendremos que abrirla pues algunos de esos seres de la oscuridad no ayudarán o servirán para preparar los menús que La Cosa de Arriba solicita a Berk.

Berk puede moverse a dercha, izquierda, alante y atrás, subir y bajar escaleras, coger y soltar cosas, meter cosas en contenedores, volcar contenedores para desparramar su contenido, empujar objetos, y accionar palancas.

La misión del juego es preparar a La Cosa de Arriba todos los deliciosos platos que nos encargue antes de que su paciencia se agote. Esto son: un bote de gusanos, zumo de ojos, unos huevos fritos, y una olla de babosas hervidas.

El problema del juego es que era terriblemente lento de movimiento, con sus grandes sprites. En modo conversacional ganaría velocidad y ampliaría el rango de acciones posibles.

portadas estilo años 80

2009-02-16T21:26:00.007+01:00

En este post del foro del CAAD se habla de las portadas, y sale el tema de las pechugas como reclamo publicitario en numerosos juegos de los 80.
Y me he permitido la licencia de hacer este pequeño fake para un juego actual de Jhames:

La portada original es del Barbarian.

Falta de jugadores

2009-02-16T17:49:00.003+01:00

Esta serie es la secuela de este artículo de Planseldon sobre el déficit de jugadores:

Fuentes TTF

2009-01-18T02:31:00.005+01:00

Me bajé el otro día el Font Creator de High-Logic y una maravilla. Teniendo en cuenta que nunca había usado un programa de estos para hacer fuentes, resultó ser bastante intuitivo y funcional.

Tenemos un mapa general de caracteres, desde el que podemos copiar y editar, pasando a la ventana de diseño vectorial. Aquí dibujamos las fuentes usando el botón izquierdo para marcar puntos y el izquierdo para marcar puntos de tangencialidad (para trazos curvos). Podemos igualemnet copiar y pegar trozos de polígono.

En resúmen, que tiene todas las herramientas para diseñar bien y rápido, y gratis, aunque el programa cuente con una versión "pro" con más funciones.

La fuente se graba en formato TTF, se copia en la carpeta de Windows de fuentes, y ya la tenemos disponible para usarla.

Adjunto unas capturas del proyecto "Nagalok", que no he tocado desde finales del verano, cuando volvía cambiarle los gráficos por enésima vez aprovechando las numerosas fotos de casas de entramado de madera "timber frame" que hice en las vacaciones. Le he aplicado un alfabeto inventado bastante inextricable, pero que ambienta mejor que el estándar. Ya que se desarrolla en otro mundo, pues otro alfabeto, otro lenguaje... queda más exótico y misterioso.

El mismo alfabeto, en su versión de letras no ligadas:

estadísticas

2008-12-27T20:21:00.005+01:00

Contando el número de aventuras que he realizado cada año, me sale el siguiente gráfico:

De todas formas aquí han puntuado igual las aventuras grandes que las nanos. De modo que no es muy significativo respecto al trabajo.
Si contáramos tiempo creo que se llevarían la palma 2000, 2002, 2007 y 2008.

2005 quedaría casi tan inactivo como 2004 ya que "La Caja de Sarimek", aunque salió ese año digamos que ya estaba programada en su grueso desde 2002-2003, al igual que "222 contra el Cangrejo".
De modo que le quitamos un punto a 2005 y otro a 2008. No obstante, 2008 se rellena por lo que está detenido, y el tiempo que "perdí" en el verano enfrascándome en Python (aunque no fuese destinado a aventuras conversacionales).

Rapidocomp

2008-12-09T12:00:00.002+01:00

¡¡¡ LA RAPIDOCOMP 2008 HA COMENZRMINADO !!!

Como hacer

2008-11-27T00:56:00.004+01:00

Eximeno cuelga en el foro este interesante link (http://www.paraquenoseolviden.com) que recupera varios libros con los que muchos aprendimos a experimentar, crear e imaginar en nuestra niñez.
Destancando la colección "Cómo Hacer", a la cual añado este nuevo número:

Otros Temas

2008-11-18T23:13:00.008+01:00

Se armó la gorda en el foro del CAAD, no es la primera vez que pasa, y como prueba esta imagen de archivo:

Hay gente que quería la sección "Otros temas" en el foro, gente que no la quería, gente que ni se ha enterado de que se estaba barajando esa posibilidad, y gente a la que le da lo mismo porque el foro que les mola es el de "Gran Hermano".

La sección se hizo finalmente, y una persona (vaya, esto no tiene iconito para subrayar) lo llenó de basura para demostrar su oposición. A partir de esta acción surje el debate y las bajas.

Un administrador que se echa para atrás tras haber dado via libre a la nueva sección aunque no fuera partidario, otro que también se retira para evitar malos rollos inesquivables...
Total, que sólo queda un admin del foro... y el dueño del dominio.

Pero... ¿¡qué es esto!? ¡parece que ya tenemos nuevos candidados para administrar el foro! Veamos en qué se basan sus campañas:

Actualización:
Ha empezado la votación para decidir la inclusión de la sección "otros temas".

Preview Palabra Exacta

2008-11-06T17:25:00.003+01:00

"Palabra Exacta" no será el título definitivo, pero lo es provisionalmente, para la aventura basada en Ad Verbum.
Es una aventura breve en tono de humor, dentro de una torre encantada. Repleta de retos basados en juegos de palabras: "wordplay" que dicen los guiris.

Una pequeña presentación:

(La aventura será sólo texto, sin gráficos ni sonido ¡Oh!)

Un sistema de conversación decente

2008-10-30T00:32:00.007+01:00

De rebote, gracias al código de Ad Verbum, al fín he encontrado -casi, pero me vale- lo que estaba buscando de una forma más sencilla a como lo tenía planteado meses atrás: una forma de leer muchos trocitos dentro de una cadena de texto, y con todos los "objetos-texto reconocido" que quiera. Y lo mejor de todo es que esos trocitos ni siquiera son objetos, luego no interfieren con nada, sólo pueden interferir entre ellos, y aquí entra la buena estrategia para diseñar las raíces de vocabulario de conversación.

Para empezar unifico todos los dispares y poco útiles -a mi juicio- modos de comunicarse que hay en inform:

Extend only 'grita' replace
* -> chillar
* noun -> chillar
* 'a//' creature -> chillar
* 'a//' creature topic -> hablar
* topic -> chillar;
verb 'chilla' = 'grita';

extend 'habla' replace
* ->hablar
* noun->hablar
* topic ->hablar;

extend 'pregunta' replace
* ->hablar
* noun->hablar
* topic ->hablar;

extend 'dile' replace
* ->hablar
* noun->hablar
* topic ->hablar;

extend 'pide' replace
* ->hablar
* noun->hablar
* topic ->hablar;

[hablarSub;
"Hablas, pero nadie te responde.";
];

[comohablarsub;
"Para hablar utiliza la fórmula: DECIR TAL";
];

A continuación viene el detector de cadenas, con la pequeña pega de que hay que escribir los caracteres uno a uno, y que no puedes detectar concatenación con espacios... salvo enrevesando la fórmula con más loops.

[BeforeParsing i j thisword thislength x;
bla1=0; !marca de texto detectado
bla2=0; !marca de texto detectado
bla3=0; !marca de texto detectado
bla4=0; !marca de texto detectado
for (i=parse-->0,j=1:j<=i:j++)
{
thisword = WordAddress(j);
thislength = WordLength(j);
if ( thisword -> 0 >= 'a' && thisword -> 0 <= 'z' ){ if(hablador in location){ if(thisword->0=='v' && thisword->1=='e'
&& thisword->2=='t' && thisword->3=='e') bla1=10;

if(thisword->0=='r' && thisword->1=='i'
&& thisword->1=='o') bla2=1;

if(thisword->0=='t' && thisword->1=='o' && thisword->2=='r'
&& thisword->3=='r' && thisword->4=='e') bla2=2;
!...etc

Y por fín, el personaje hablador. El nuevo sistema de hablar se detectará en el reaccionar_antes (react_before) del personaje, ya que de momento no necesito múltiples interlocutores, y todo lo que hables te lo replicará el único PSI presente, que traga con todo, hasta con su propio nombre si lo pones. Y de paso, me fusilo el Order y el Answer, que también forman parte del club de los modos de hablar múltiples:

object hablador "PSI hablador"
with name 'psi',
react_before[;

answer, order: <ComoHablar>;rtrue;

hablar:
if (bla1==10)print "Has dicho vete";
if(bla2==1)print "Has dicho río";
if(bla2==2)print "Has dicho torre, torreón, o torrecita";
],
!...etc

Por ahora, mucho mejor que lo que tenía, y... hecho y funcional.
(El código es para compilar en Glulx, para Z-code cambian ciertas cosas)

Ad Verbum

2008-10-27T15:33:00.009+01:00

L'otro día Urba me convenció (tras no conseguir que le dibujara unos elfos) para hacer una versión en castellano de Ad Verbum, la premiada aventura de Nick Montfort que tiene como particularidad estar basada en juegos de palabras.

Nuestra misión consiste en recoger todos los objetos de la mansión de un brujo, estando estos objetos en habitaciones encantadas, de tal forma que tendremos que vérnoslas con el léxico inglés para hallar los comandos que podemos escribir. Y es que, por ejemplo, en la sala Norte, todos los textos están escritos con palabras que empiezan por N, y nosotros, mismamente, sólo podremos indroducir órdenes con palabras con una N delante. Luego olvidémonos de comandos como TAKE o EXIT.

En castellano quedaría algo así:

S
Salón sombrío. Sientes seis simios sarnosos sentados sobre sendos sofás silbando soporíferas saetas sevillanas. Seguidamente, sobre sólido soporte saliente, se sitúan sobrias sandalias sarracenas.
>>COGER SANDALIAS
¡Shhhhh! ¡Silencio! Sacrilegio sugerir semejantes sandeces.
>>EX SIMIOS
¡Shhhhh! ¡Silencio! Sacrilegio sugerir semejantes sandeces.
>>SENTIR SIMIOS
Son seres selváticos, salvajes, sentados sobre sus sofás. Silban sin saber solfeo, sin salero.
>>SABOREA SIMIOS
Simios sin salsa saben sosos.
>>SENTARSE SOFA
Sobre sofa se sitúa simio salvaje. Se sulfurará si sobre su sayo se sientan.

M
Muros manchados, mazmorra macabra. Momios malvados me miran mal, meditando macarrónicas monsergas, meneando maracas musicales. Mobiliario: mesa marrón, mampara moteada.
>>MANGAR MARACAS
Mala manera. Momios manifiestan: "mangantes merecen morir".
>>MATAR MOMIOS
Momios muy mortíferos, mejor me mantengo manso, menos macarra.
>>MANOSEAR MESA
Momios malhumorados me manotean manifestando: "¡manchas muebles, manos mugrientas, maldito maleducado! ¡multa millonaria!"

Lógicamente no es una traducción, ni es mi intención. Se trata de, sobre la misma idea, hacer historias distintas, y es que ya sería casualidad que se pudieran hacer los mismos juegos de palabras que en inglés. No, por tanto las salas son diferentes.

Habrá salas con más letras, y me ahorraré otros puzzles con palabras que incluye Ad Verbum que encuentro demasiado rebuscados para centrarme en sacarle el máximo jugo a los juegos de letras iniciales o palabras con una sola vocal.

Todo esto una vez hallada la forma de procesar esto con el párser, que ya veremos ya veremos... Supongo que un pawslike vendría mejor al caso, o quizá programarlo directamente en Python a pelo, sin parser.

El barco del CAAD

2008-10-20T18:56:00.005+02:00

Mi primera Kedada

2008-09-16T22:54:00.003+02:00

¿Reconocéis a alguien?
Están por ahí JSJ, Cárdenas, J. Basilio, Salazar, Manowar, Jarel...

viejos programas en AMOS

2008-08-13T11:15:00.011+02:00

Como ayer tuve que ir a la sierra, aproveché para montar el Amiga y cargar unos cuantos programas que había hecho en AMOS, un lenguaje parecido al BASIC, pero especializado en la creción de videojuegos, con funciones para "pegar" sprites, detectar el joystick...etc

En los diquetes que cargué había:
-Proyectos de aventuras conversacionales:
Uno con gráficos concluído... hasta que se me agotó la memoria, dos bocetos, y otro sólo texto que no sé si termina, porque desde luego que son injugables.
El código es algo así como unas definiciones de DATAs con los verbos y el vocabulario, todos recortados "mira" "exam" "coge" "da"... y luego un input y a buscar coincidencias.
En la primera localidad de la que está terminada no logré hacer nada, y eso que más o menos recuerdo por dónde van los tiros, más que nada porque ese comienzo más tarde lo reciclé para "La Guarida Valshar".

-La aventura del Orco:
Quizá es lo más jugable que programé, es una aventura 2D de un orco que tiene que recuperar la piedra Il que cura una enfermedad que afecta a su horda. Con el joystick nos movemos, podemos recoger objetos, y con disparo accedemos a un menú para hablar (escribiendo tal cual) o utilizar objetos, entre ellos un libro de hechizos (también deberemos escribirlos tecleando).

-Proyectos de juego de rol en primera persona
Tipo Eye of the Beholder, sin monstruos ni menús, sólamente los laberintos y los dibujos de los muros. Curiosamente los laberintos estaban definidos en una matriz de DATA con "1" y "0", indicando los huecos y los muros, lo mismo que he hecho recientemente para la automatización en una malla 2D de los laberintos de PUJ.

-Varios:
*El Tron, llamado "Destellos", para uno o dos jugadores y con varios niveles, algunos de los cuales tienen "passing-points" que irán rellenando un marcador al pasar sobre ellos.
*El ahorcado con un monigote dibujado a un lado, con la cabeza metida en una guillotina, que gesticula en función de nuestros aciertos, y acabará gullotinado si fallamos.
*El buscaparejas: un damero de casillas ocultas que revelaremos por parejas mostrando las imágens que esconden. Se trata de ir recordando donde estaba cada una, para levantar a la vez las que son iguales.
*La barra y la pelotita, un machacaladrillos pero sin ladrillos, un frontón en solitario.
*El Lingo, el juego del programa de la tele.
*Proyectos de aventuras gráficas con menús tipo Delphine pero sin personajes, que no pasan del menú o de una pantalla sin mucho que hacer.
*Proyectos de plataformas 2D con muñegotes saltarines.
*Proyectos de isométricos (sólo el movimiento del personaje)

Los gráficos dibujados a golpe de Deluxe Paint

Las fotos de las pantallas han salido fatal, el refresco de pantalla era muy lento al hacer correr los juegos (cosas de ser un lenguaje interpretado), incluso se podía apreciar a simple vista el barrido

Ventana principal de edición de AMOS. Lo que más me llamó la atención son lo diminutos que son los códigos en comparación con los fuentes que manejo ahora.

La aventura del Orco. te puedes mover de derecha a izquierda o entrar por las puertas hacia habitaciones paralelas. Las pantallas están dibujadas a base de "tiles".
El objetivo era encontrar la piedra mágina Il, pero como el juego no tenía instrucciones, eso sólo lo sé yo... bueno, ni yo, porque hasta que no terminé le juego no me acordé de cuál era el objetivo.

Empezabas en una serie de salas por las que deambulaba otro como tú llamado Blongo. En general, por todo el juego hay placas en la pared que te dan pistas en plan "las mejores cosechas crecen bajo las estrellas" "en la marca roja..." y algunas otras con simples tonterías inservibles como "la intuición radica en el rabillo del ojo".
Los hechizos que usas son 5:
-El de disminución, para convertir a un monstruo verde que no te deja pasar en un enanito que huye despavorido.
-El de crecimiento, para hacer brotar setas, sólo posible por la noche, como te dice la pista. Para que sea de noche, si resulta que es de día, hay que darse una vuelta pasando pantallas, o entrar y salir entre dos, ya que a cada paso de pantalla progresa el cielo exterior.
-El de miedo, para apartar a un tipo que te dispara con una cervatana, trás descubrir aquello a lo que teme: a las setas.
-El de descubrir, para ver cual de los toneles de "lom" de la bodega está marcado con una X. Aquel que beba de él se convertirá en una seta (hay que aprovechar los sprites). Llenas una copa, se la llevas a Blongo y se convierte en una seta al beberla, una seta que repite una palabra mágica, un hechizo para teletransportarte... (ingenioso ¿verdad? XD)
-El de convertir en oro... al revés. Al final del juego nos encontramos con la situación de que el que tenía la piedra Il ha convertido todo lo que tenía en oro, incluída la piedra. Entonces tenemos que escribir el hechizo de convertir en oro al revés para desfacer la pifia.

Las aventuras conversacionales. La que se ve en la parte superior es la que está terminada. Básicamente empezabas en una celda, como en La Guarida Valshar, luego aparecía por ahí una rata parlanchina, le pedías comida al carcelero, y se la dabas a la rata, que te mostraba una salida secreta. Llegabas a otra sala a través de una máquina de Cocacola, o algo así. Luego había un bosque con un gnomo que hacías salir de su casa tapándole la chimenea, una taberna, y un precipicio con un tronco en medio del cual te esperaba un diablo. A éste le hacías caer metiendo una vara en un hueco del tronco y haciendo palanca para que girase.

La de la parte inferior es sólo un modelo, no hay nada más que hacer, que ver que funciona coger cosas y los verbos.
Destacar la parafernalia del marco, muy propio de cuando la memoria era un problema, para meter gráficos lo más pequeñitos posibles sin que cantase mucho que eran ridículamente pequeñitos.

Arriba el juego del Lingo, que trata de adivinar palabras. Primeramente te aparecen una pocas letras y espacios en blanco, por ejemplo: -R--A-
A continuación pruebas una palabra que case con el modelo, por ejemplo TRIGAS, si no era esa la palabra, al menos se te marcarán las letras que coincidan en posición con el de la palabra secreta (si esta fuera BRIDAS, en el siguiente turno se quedaría la palabra así: -RI-AS)

Abajo, un "dungeon" con el menú de movimiento (sin los gráficos de las flechitas) típico de este género: Avanza, gira, atrás, y moverte en paralelo.
Los muros están realizados gracias a la opción de deformacion en perspectiva del Deluxe Paint. De todas formas, recuerdo que fue llevadero recortar cada trocito de muro para todas las posibles posiciones en 3 o 4 niveles de profundidad (afortunadamente los dungeons son muy oscuros, y puedes justificarte así de no dibujar más planos hasta que no quepan los pixels :D)
Éste se mueve un poco lento por el tamaño descomunal de la ventana gráfica (le llevaba demasiado tiempo a la máquina montar todos los srpites, y más teniendo en cuenta que esto es un lenguaje interpretado, y parte de la memoria la está consumiendo el propio AMOS); de modo que hice otro con la ventana más pequeñita, y así corría más ligero.

IA en el juego de mesa-estrategia

2008-08-12T01:39:00.003+02:00

Técnicas de estrategia.
Por ahora la IA de los emperadores rivales manejados por el ordenador funciona así, en base a un sistema de puntuación:
1. Valorar movimiento de tropas.
-Busca territorios propios
-Busca territorios accesibles desde los propios
-Comprueba que hay tropas que mover
*Valora el número de tropas enemigas en esos territorios.
-Comprueba que nuestras tropas son suficientes para ganar. ++ o --
*Valora riqueza de ese territorio. ++
*Valora si es capital de otro reino. ++
-Si no hay tropas para mover desde el territorio que da acceso al movimiento de máxima puntuación, valorar un posible paso de tropas desde otro territorio colindante, para en el siguiente turno...

2. Valorar lo expuesta que está nuestra capital
-Busca el territorio donde está nuestra capital
-Busca territorios accesibles desde/hacia
-Comprueba si son nuestros o enemigos
-Si son enemigos valora el número de tropas y nuestra fuerza defensiva.
-Si la capital está en peligro:
A-Busca territorios colindantes con aquel que supone la mayor amenaza
-Busca tropas propias en esos territorios
-Valora si alguna de esas tropas es suficiente para acabar con la amenaza
->Ataca
B-Comprueba cuantas tropas podemos reclutar en la capital
-Valora si son suficientes para resistir el posible ataque.
-> Arma las tropas necesarias en la capital
C-Busca territorios colindantes con nuestra capital
-Busca tropas propias en ellos
-Valora si con su regreso a la capital, ésta estará suficientemente defendida
-> Mueve tropas hacia la capital
(no valora la posibilidad de múltiples amenazas sino que busca la mayor de entre ellas; en el caso de múltiples, las dos últimas opciones, B y C, serían preferibles a la primera, A)

3. Valora reclutamientos.

De momento lo he puesto a funcionar saltando el turno del jugador para ver a toda velocidad el transcurso de la guerra, y la cosa funciona poco inteligentemente; se crean circuitos repetitivos que tardan mucho en deshacerse. Lo cual es normal, si todos los emperadores tienen el mismo criterio de ataque y defensa, parece que juegan al gato y al ratón mordiéndose las colas, y sólo tras mucho tiempo alguna capital es tomada y cambian los ciclos por unos momentos para volver a hacerse regulares.

Hay que ampliar la IA con variaciones personalizadas para valoraciones secundarias. Por ejemplo, entre varios posibles territorios de avance, tender a elegir el más rico, el que posea más enemigos, el que pertenezca al emperador que más nos ha atacado...

También con objetivos a largo plazo: La estrategia principal del juego será tomar las capitales, que son el punto flaco de los demás imperios, pero también conquistar pro el camino el mayor número de territorios para obtener más rentas y más soldados. Por tanto, buscar recorridos óptimos hacia las capitales más cercanas y débiles pasando de camino por los territorios más fáciles de conquistar.

Y con autocorreciones: si tras varios turnos, el promedio de territorios, riqueza y tropas sale negativo en comparación con la media de los demás emperadores, algo está haciendo mal, luego debe cambiar sus criterios de valoración secundarios (los que no tienen que ver con la defensa de la capital, que son prioritarios)

El Wargame y la Aventura 2D en acción

2008-08-09T19:11:00.001+02:00

Unas capturas subidas a Youtube:

Toi CAAD

2008-08-08T10:20:00.002+02:00

pythoneando

2008-08-02T05:04:00.010+02:00

Empecé a primeros de Julio a investigar Python+Pygame, y la verdad es que ha cundido la cosa. Este blog que al principio pretendía ser de programación de Inform, y luego pasó a ser de programación y chismorreos caadianos, va a terminar por ampliarse a blog de videoaventuras en general. Esto es: videoaventuras conversacionales, videoaventuras de plataformas, videoaventuras de mesa...

Empecé realizando el proyecto que tantos años deseaba hacer y no pude por mi falta de conocimientos de programación: una aventura 2D tipo Another World, que cumpla ciertos aspectos que considero importantes:
-Gravedad e inercias reales, velocidad, nada de saltos fantasma en plasma líquido. Puedes controlar los saltos mientras en la animación el personaje tenga algún pie en el suelo; una vez en el aire, éste sigue una trayectoria invariable salvo que se estampe con alguna masa.
-Transiciones entre acciones: no puedes pasar de correr a andar así sin más, ni cambiar de dirección sin amortiguar la inercia. Mismamente, si vas corriendo y pulsas para salto de longitud, el comando no se ejecutará instantáneamente sino en el momento en el que termines la zancada, para tomar impulso, como lo antes dicho.

Para esto las acciones van por pilas: accion_actual y accion_siguiente, la cual salta cuando el frame de transición sea el correcto.

Más o menos he conseguido el motor, más o menos porque se podría mejorar con más fidelidad, pero es un coñazo dibujar tantos frames.
Grabación en video->volcado->selección de fotogramas->calco en vectorial->conversión en bitmap->edición->"amontonamiento" en capas->grabación en PNG

...

Como me estaba saturando de este proyecto, y no estaba inspirado para un buen guión, carpetazo y quise hacer un juego de mesa tipo risk.
31 territorios y 8 emperadores rivales por conquistarlos.

El sistema de lucha será sencillo: 2 contra 3 = mueren dos de cada ejército y gana el segundo con una tropa viva; con algunos modificadores: los que atacan tienen un porcentaje de desventaja; también se acumula un portentaje negativo si atacan una ciudad fortificada (hasta tres niveles de fortificación); o si atacan un reino montañoso, donde mismamente los que ya están ahí esperando tienen ventaja posicional sobre los que llegan.
El sistema se irá calibrando cuando funcione.

También barajo -utópicamente- hacer los combates jugables, de forma que el 2 contra 3 ganan los segundos sea más relativo (aunque 2 contra 4 ni de coña), adquiriendo la piel del general que da las órdenes, las cuales son transmitidas por los músicos con códigos de trompetiles, y con muchas animaciones "jolgoriosas" de fondo (si no, no mola):
¡arqueros!, ¡primera línea avance!, ¡atrás!... tipo Patapón-pon-pata-pon.

El proyecto 1: Las criaturas humanoides, llamadas naar, tienen cada una un rostro diferente y personal, aunque no se aprecie mucho. Superpongo una máscara translúcida con los matices... y, anden, corran o salten, la cabeza siempre horizontal :D La máscara es de boca para arriba, para hacer comunes los frames de cuando muevan la boca para hablar.

El war-game, en el que de momento no se puede hacer nada más que pasear el ratón por el mapa y curiosear.
El menú de la derecha son las acciones básicas (sin implantar):
-Mover tropas
-Fortificar un sitio
-Reclutar hombres.
Faltan:
-Trasladar la capital del Imperio ( si cae una capital el conquistador se queda con todo, aunque para conquistar una capital, además de enfrentarse a las fortificaciones y tropas que allí se hallen, hay una guardia pretoriana fija, y de regalo, que vale como 3 o 4 tropas)
-Enviar órdenes (las acciones no se ejecutarán hasta que envíes las palomas mensajeras a tus generales repartidos por el imperio). Una vez enviadas, correrá el turno (el mes), se verán los resultados, y los movimientos que han hecho los emperadores rivales.

En fin, lo más importante de Python es esto:

# -*- coding: iso-8859-1 -*-

¡¡¡Sin esta línea mágica no se pueden escribir acentos ni eñññññññes!!!

CAADmóbil

2008-07-04T22:08:00.001+02:00

Atención a la matrícula...

(la foto la tomé hace años en Collado Mediano)

Brodmann Area 15

2008-06-29T16:51:00.005+02:00

Haciendo un meme chorra de esos que purulan por los blogs, consistente en coger una imagen al azar de una página que muestra imágenes al azar, un nombre al azar de una wiki y las cuatro últimas palabras de una página de citas, estas últimas también generadas al azar, y hacer la portada de un disco, me salió esto:

Y más que para un disco, es una portada buenísima para una aventura basada en el mundo de "1984", de Orwell.

Brodmann te vigila, somos tus amigos, siempre estamos a tu lado, vigilamos que seas correcto, por tu propio bien, queremos tu felicidad...

actualizando la WikiCAAD

2008-06-02T21:20:00.001+02:00

la procrastinación del Cangrejo

2008-06-02T16:47:00.006+02:00

Este fin de semana me decidí a terminar fuera como fuese un viejo proyecto en InformATE que inicié en el 2002 y que tenía abandonado.

Últimamente llueve todos los días y hace tiempo que no salgo a la montaña, por tanto los fines de semana no hago nada productivo, de modo que me autoimpuse cerrar ese proyecto sí o sí durante el finde.
Empecé el Viernes por la tarde, me pasé la madrugada sin dormir, y el domingo a las 23:00 lo tenía terminado... con algunos bugs fatales que tuve que corregir el lunes.

El mismo domingo, de madrugada, soltaron en Redes un palabro muy significativo:
Procrastinación, la acción de procrastinar (del latín procrastinare) es decir, de postergar actividades o situaciones que uno debe atender, por otras situaciones más irrelevantes y agradables. Este término proviene del latín pro- (adelante) y crastinus (relacionado con el mañana).

En el mismo programa, un profesor comentaba una experiencia de todos conocida - seamos alumnos o profesores, jefes o mandaos - relacionada con la fecha de entrega de trabajos.
Este profesor mandó sus alumnos presentar tres trabajos a lo largo del curso. Al primer grupo le puso como fecha límite el último día de clase; al segundo grupo le puso tres fechas, un trabajo por trimestre.
Ni que decir tiene que los trabajos del primer grupo se hicieron los tres en el último momento y mal. En general, empezamos a funcionar cuando la fecha límite está cercana, no antes.

Parece que ponerse fecha y límites es importante. A veces nos ponen fecha desde fuera, otras veces no, y es entonces cuando nos la tenemos que poner nosotros, o esperaremos eternamente hasta un último momento que nunca llegará, porque nadie nos va a decir ¡mañana lo quiero!

En este caso, la postergación no es comparable a la de una tarea obligada, ya que esto es un hobby, sino debida a pretensiones excesivas que arrojan unas perspectivas de programación eternas y costosas en tiempo que terminan por hacerme desechar todo el trabajo anterior para pasar a una tarea más liviana y ágil.

Aquí está la aventura, y la solución.

fotografías para ilustraciones

2008-05-21T20:29:00.006+02:00

**ADVERTENCIA**
**AMANTES DEL SÓLO-TEXTO NO LEER**

Cuando hago una foto, tengo un dilema: si se hace con ojo artístico normalmente no vale para ilustrar una aventura conversacional, tal como yo pretendo hacerlo con cierta uniformidad de perspectiva (ni tampoco como foto documental de esa zona)
Si buscas el contraluz, el escorzo, el detalle, la parte sin su contexto... esa imagen no sirve luego para describir una localidad o un lugar globalmente, sino una particularidad de él, un efecto... la anécdota y no el conjunto.
El atardecer puede quedar precioso, pero o toda la aventura se desarrolla en un perpétuo atardecer, o cada vez que pasas por esa localidad casualmente está atardeciendo aunque en la siguiente el sol esté a las 12, o te preparas todas las localidades para las distintas luces del día.

Las que suelen cuadrar son las tomadas desde la altura de la cabeza y de frente, ni hacia arriba ni hacia abajo, y con el sol arriba, sin excesivas sombras hacia poniente o naciente. De este modo las fotos son más fácilmente editables para darles la luz adecuada o las sombras que queramos llegado el caso. Más fácil es emborronar lo que sobra que sacar a la luz lo que no existe.
De hecho lo ideal es un día nublado, sin sombras fuertes y con luz uniforme. Estas fotos son la mejor base para componer decorados.

Es un criterio sólamente, todo vale si queremos, podemos entrar en un salón y poner como ilustración principal su maravilloso techo pintado por Michelángelo Buonarotti; o usar la foto de una botella de vino para ilustrar una bodega; o usar éstas cuando miramos al techo o miramos una botella. Pero para la entrada en la localidad queda extraña la focalización directa en uno de sus elementos, o un punto de vista retorcido como si el protagonista si hubiera tirado al suelo o apretado contra una pared.
No obstante, a base de partes también se puede componer un buen conjunto global.

Lo' pogramas d'oy en día hacen de tó.

Mazmorror

2008-05-16T17:56:00.007+02:00

¡¡¡Regístralo!!! el nombre es la hostia, y no lo ha usado nadie ¡corre corre! ¡que se te puede adelantar alguien! (por ejemplo yo)
Se pueden sacar cómics, dibujos animados, camisetas, muñecos, juegos de ordenador, politonos, películas. El nombre es contundente.

Mazmorror es una serie de minirelatos de coña parodiando los juegos de rol, de Fran Kapilla, que debería estar aquí... pero no funciona el enlace.

Tomo prestada la marca de la saga, cumpliendo mi amenaza al autor, para la próxima nano, cuyo título provisional es:

Crónicas de Mazmorror - capítulo X
2001 Puj y un brebaje de gazpacho

Por supuesto, una parodia en un mundo fantástico de alevosas incoherencias y absurdos.

Sí, se parecen mucho... es que son de la misma camada

espeleoaventura

2008-05-15T13:55:00.004+02:00

Hace unos meses me metí en un grupo de espeleología federado, tras un año yendo por mi cuenta, de "espeleo-loco", o espeleo-pirata.
El caso es que repasando las aventuras que he hecho hasta la fecha, especialmente las largas, la mayor parte tienen cueva. Está claro que era una pasión que tenía que materializarse tarde o temprano, y afloró cuando se me puso delante de las narices, igual que tantas otras cosas.

Igual que alguien puede tener predisposición para amar la navegación, pero no le da rienda suelta hasta que tiene la oportunidad de "conducir" un barco o se da de narices con uno de verdad.

Aventuras que se desarrollan principalmente en cavidades naturales:

La Guarida Valshar
En la Sima del Búho Maldito
Subterránea

Aventuras en las que una parte de la historia se desarrolla en cavidades naturales:

Rimblendén
Las Llaves del Tiempo
La Caja de Sarimek
Regreso al Edén
Antes

Aventuras en las que una parte de la historia se desarrolla en cavidades artificiales

Del Otro Lado
El Octavo Pasajero
Zerogrados
El Edificio 25

mi aventura me la robaron estando de romería

2008-04-29T00:22:00.002+02:00

sistema de conversación por adivinación

2008-04-26T18:46:00.003+02:00

Para mi próxima aventura, he determinado utilizar como sistema de conversación aquel que ya esbocé hace años y he ido ultimando gracias a los avances de la tecnología. No es otra cosa que el
Sistema de adivinación pulsométrico.

Las sinapsis neuronales del jugador generan unas imperceptibles interferencias con los campos energéticos del ordenador. Con el algoritmo adecuado, desarrollado gracias a una red neuronal bien entrenada para interpretar esas interferencias y traducirlas, podemos adivinar las intenciones del jugador.

De modo que la conversación se reduce al comando "HABLAR CON", sin necesidad de especificar más.
...
Lamentablemente no es así... quiero decir afortunadamente. No creo que a nadie le hiciera gracia que apareciera una tecnología capaz de leerle el pensamiento (lo que no quita que nos gustase leer el de los demás, en exclusiva).

carátulas (fake)

2008-04-18T17:15:00.003+02:00

De la unión de ésta y ésta, sale esta otra:

carátulas 4

2008-04-16T23:26:00.011+02:00

carátulas 3

2008-04-14T16:18:00.007+02:00

carátulas 2

2008-04-14T13:55:00.002+02:00

repositorio

2008-04-14T01:53:00.003+02:00

Eliuk está preparando un "Repositorio de Cover-Art"...

¡¡¡qué puñetas es eso!!!

Una galería de carátulas.

¡Ahhh!

Actualización:
La galería se traslada aquí.

Aventuras conversacionales, Ficciones interactivas y emparedados

2008-04-08T18:14:00.003+02:00

Respecto al uso de uno u otro término para denominar a los juegos de texto, ocurre lo mismo que con el sandwich.

Sandwich en "guiri" es un bocadillo. Hemos heredado la palabra pero para nosotros es sólamente un tipo de bocadillo, no cualquiera, en concreto un emparedado con pan de molde.

El mismo caso ocurre con la palabra francesa baguette, exclusiva para nosotros de un cierto tipo de barra de pan fina y alargada, no de cualquiera.

Algunos consideran ficción interactiva sinónimo de aventura conversacional y otros no. Quizá la mayoría no, hay muchas connotaciones. A raíz del nombre que se les dé parece que puede haber dos tipos diferentes de "juegos de texto", o de enfoques: aventuras conversacionales huele a puzzle, y ficciones interactivas huele a texto.

Es curioso cómo el vocabulario va cambiando de significado, derivándose o especializándose.

CAAD conserva la denominación "aventuras conversacionales" por tradición, pero por ejemplo en los blogs y nuevas páginas de parsers cada vez veo más neologismos como "relatos interactivos", "ficciones interactivas"... y parece que el binomio palábrico "aventura conversacional" va a quedar relegado a juegos clásicos apolillados de tipos barbudos.

carátulas

2008-04-08T15:15:00.012+02:00

Vistas las carátulas que ha hecho Planseldon en su blog.
Se me ha antojado hacer lo mismo :D

Los disquettes ya los tenía hechos, también inspirados, por las simulaciones de cajas de Sarganar en este caso. El segundo sale en las curiosidades del final.
Los screenshots del fake de Las Llaves del Tiempo son imágenes descartadas de Regreso al Edén.

jugar solo

2008-04-04T00:08:00.001+02:00

tengo una idea para una aventura cachonda
resulta que estás jugando tan tranquilo...
y de pronto se abre una ventana gráfica estrecha arriba
y se asoma un viejo
y luego llegan más mirones
que observan cómo juegas
y te gritan cosas
venga ahí ahí, examina la mesa!!!
graba la posición, que te van a matar!!
cosa así
jajajajaja!
:D
como en los años 80 con las máquinas recreativas
"presión sicológica".
cuando había uno jugando y 10 mirando
sería como jugar acompañado
ahora jugamos solos en nuestras casas, delante de nuestros ordenadores
sería recuperar el espíritu juvenil y de la escasez
cuando no todo el mundo tenía ordenador, y el que lo tenía, se le llenaba la casa de amigos del cole
no jugabas solo

PSIS en mallas

2008-04-02T11:38:00.008+02:00

Tengo dos proyectos abiertos donde juego con el movimiento masivo de PSIS. Cada uno tiene una peculiaridad distinta.

El proyecto A, para la Xcomp seguramente, es una malla bastante regular, con un cuello de botella cuyo paso se regula un poco a lo bruto, redirigiendo a los PSIS cuando su meta requiere atravesarlo.
Los límites de la malla se detectan de la misma forma bruta: a mano.
Los PSIS se mueven por objetivos. Una vez definidos los límites del mapa y la redirección por el cuello de botella, basta con asignar a cada PSI un valor en su propiedades objetivox y objetivoy, y éste realizará el trayecto automáticamente.
Cuando se cumple un objetivo se reasigna otro, y así mismo existen acontecimientos masivos que afectan a bastantes PSIS: relevos de guardias, reuniones, accesos a edificios...

Los PSIS están contínuamente moviéndose por la malla de la ciudad, deteniéndose de vez en cuando unos turnos, con bastante autonomía.

(Pulsa aquí para ver el movimiento en vídeo)

Los PSIS cuentan con un generador pseudoaleatorio de rostros (con varios tipos de ojos, cejas, narices, rostros, pelos, complexiones, distancias entre los rasgos...) y nombres.
Antes de comenzar cada partida se define aleatoriamente una "semilla del kaos", y en base a ese valor se determinarán las cosas que son diferentes en cada partida, pero que permanecerán constantes en el transcurso de la misma. Incluso el jugador será diferente: su rostro, su nombre y su género.

En el proyecto B los movimientos son más burdos, se basan en detectar como objetivo al jugador (cosa factible también en el proyecto A, aunque no vaya a cuento con la historia), olfateándole para converger hasta él y atacarle. El típico movimiento del Minotauro en su laberinto.
Su punto fuerte es la automatización de los límites. En este caso la malla no es regular, sino que es un laberinto de libre diseño.
Usando la librería Newflags.h, reservo 10x10=100 flags para crear una máscara con la forma del minilaberinto: 0=vacío, 1=sólido.
De este modo, tanto en los movimientos del jugador como en los de los PSIS se puede saber automáticamente las salidas disponibles en cada casilla, hacia dónde se puede pasar y hacia dónde hay pared.

Cada PSI es una unidad-horda de enemigos compuesta por un número de ellos. Debido a la anchura de los túneles del laberinto, no cabe más de una horda en cada casilla, o en cada frente (cuatro frentes posibles) desde el que se aborde al jugador, por lo que unas hordas así mismo hacen de obstáculo a otras hordas, que aguardarán detrás para atacar. No obstante, según liquidemos enemigos y a medida que quede espacio, se producirán transvases de indivíduos de las hordas que esperan detrás hacia las hordas en primera fila.
Aunque tengo que reconocer que desde el punto de vista conversacional este proyecto es un coñazo de jugar, por lo que está orientado a una parodia.
Los mapas son para testeo, no salen en la perspectiva del juego. Aunque en el primer proyecto incluiré un acceso al mapa, porque merece la pena poder observar el deambular de los ciudadanos.

brújula

2008-02-10T18:20:00.001+01:00

Voy a poner una brújula gráfica que indique las salidas de cada localidad. Para aligerar en la medida de lo posible la aparición de vocabulario repetitivo en las descripciones: cosas como "puedes ir hacia el Norte..." o un listado de salidas no requerido por el jugador con el comando pertinente.

Aunque en muchos casos será inevitable que aparezcan puntos cardinales en la descripción. De otro modo, si por ejemplo a lo lejos vemos un molino, sin más, podríamos tener que pasar por otros sitios antes de -por descarte- saber que la dirección que conduce a él es noroeste.

Para lugares sin referencias lejanas ni caminos, como un bosque cerrado, funcionará bien.
-Ahorra texto repetitivo en la descripción.
-Ahorra tener que escribir el comando salidas.
-Ahorra jugar a los coches de choque para buscar salidas.

Primero hice un par de diseños que se basaban en dibujar un centro y en torno a él las diversas ramas de las direcciones, una a una en función de que existieran esas salidas.

Pero finalmente he optado por poner un gráfico con la brújula entera, con todos los puntos cardinales, arriba y abajo, y entrar y salir; y oscurecer con PNG transparentes las salidas no disponibles. Es más sencillo y me permite cambiar los colores de la brújula editando un único gráfico.

Para ello creo una ventana gráfica nueva en un lateral: gg_ventana2, y aprovecho la librería NewFlags.h, que por otro lado voy a utilizar para más cosas.
La función que dibuja la brújula será llamada cada vez que se repinten los gráficos, al cambiar de localidad, o manualmente cuando un evento modifique las salidas.

[dibujabrujula i loc;
loc = location;

!dibujo la brújula entera:
glk_image_draw(gg_ventana2,GRAF_brujula_base,5,15);

!pongo a 0 los flags que almacenarán las salidas viables:
for(i=10:i<22:i++)ClearFlag(i);

!busco direcciones viables... y VISIBLES,
!parte de código copiado de la rutina de listado de salidas de la librería en español:
if(location~=TheDark)
objectloop (i in compass)
{
if (loc provides (i.door_dir) && metaclass (loc.(i.door_dir)) ~= nothing or string)
{
switch(i){!sw
nw_obj: setflag(15);
ne_obj: setflag(14);
sw_obj: setflag(17);
se_obj: setflag(16);

n_obj: setflag(10);
s_obj: setflag(11);
e_obj: setflag(12);
w_obj: setflag(13);

in_obj: setflag(18);
out_obj: setflag(19);
u_obj: setflag(20);
d_obj: setflag(21);
}!sw
}
}

!sombreo las direcciones no disponibles con diversos PNG trasnparentes
!ajustados a las formas de cada parte de la brújula:
for(i=10:i<22:i++){
if(Flagoff(i))switch (i){!sww
10: glk_image_draw(gg_ventana2,GRAF_brujula_sombra0,65,14);
11: glk_image_draw(gg_ventana2,GRAF_brujula_sombra0,65,94);
12: glk_image_draw(gg_ventana2,GRAF_brujula_sombra90,4,75);
13: glk_image_draw(gg_ventana2,GRAF_brujula_sombra90,84,75);

14: glk_image_draw(gg_ventana2,GRAF_brujula_sombra45,83,34);
15: glk_image_draw(gg_ventana2,GRAF_brujula_sombra135,25,34);
16: glk_image_draw(gg_ventana2,GRAF_brujula_sombra135,83,93);
17: glk_image_draw(gg_ventana2,GRAF_brujula_sombra45,25,91);

18: glk_image_draw(gg_ventana2,GRAF_brujula_sombracuad,162,95);
19: glk_image_draw(gg_ventana2,GRAF_brujula_sombracuad,162,132);
20: glk_image_draw(gg_ventana2,GRAF_brujula_sombracuad,162,16);
21: glk_image_draw(gg_ventana2,GRAF_brujula_sombracuad,162,55);
}!sww
}
rtrue;
];

conversaciones con PSIs

2008-02-05T15:34:00.001+01:00

Intento sacar un buen sistema de conversación con PSIs, para lo cual el sistema de lectura de objetos de Inform me resulta fatal. Lo suyo sería implementar un modo de parseado alternativo dentro del propio parser, un sistema PAWSlike de reconocimiento de cadenas de texto, de chorizos de texto no acotados necesariamente por espacios ni por palabras completas.

Mi antiguo parser en C, DISAC funcionaba así:
Tenía 4 tablas de vocabulario: Verbos, Nombres, Objetos y Adjetivos, teniendo Verbos la obligación de ser la primera cadena de la orden, y Objetos estando en principio reservada para objetos cogibles.
El parser buscaba coincidencias letra a letra sin importarle los caracteres que sobraran: signos de puntuación, espacios, sufijos, declinaciones, palabras extra... Cuando los espacios fueran importantes, sobre todo en palabras cortas que pudieran estar contenidas en otras, el espacio iba en la propia definición de vocabulario de esa palabra, con un cuadradito, tal que '#asi#'
De modo que era vocabulario válido cosas como:
'bebe', 'di#', 'por#que', 'te#llama', 'destruy', 'llave#roja', '#con#', '#en#'...

No hacía falta ni introducir las palabras completas ni una a una: las "palabras" eran a veces cachos o trozos de frase.

A la hora de buscar coincidencias, se jugaba con cuatro posibles valores de cada tabla:

1- Vocabulario concreto encontrado.
2- Indiferente de si ha habido coincidencia.
3- No debe haber habido coincidencia.
4- Debe haber habido alguna palabra de esa lista detectada, da igual la que sea.

De cara a las conversaciones, esto permitía jugar con términos y trozos de frase por los que existiera una alta probabilidad de que el jugador tuviera que pasar para formular una pregunta concreta.
Por ejemplo, para detectar una pregunta de ¿cómo te llamas?, la mayor parte de los casos con tuteo se podrían cazar definiendo dos cadenas:

'te#llama' -> Cómo te llamas, cómo te llaman.
'tu#nombre' -> cúal es tu nombre, dime tu nombre, quiero saber tu nombre.

Teniendo en cuenta los posibles errores:
-te llaman para cenar, no quiero saber cómo te llamas, tu nombre es muy feo.

Pero prefiero que se conceda el beneficio de la duda.

Volvamos a Inform, aquí existe la librería Etemas que permite jugar con UN objeto con tres modos distintos de parsing:
-parsing estricto: Deben aparecer todas las palabras de vocabulario del objeto-tema
-parsing normal: Pueden aparecer algunas, aunque falla si metes palabras no reconocidas delante.
-parsing flexible: Con que aparezca una vale, las palabras desconocidas se ignoran.

El problema es que las palabras deben estar enteras y no contener espacios, cuando ya he explicado por qué creo más útil un vocabulario definido a trozos e incluso incompleto: 'por#que' 'donde#est' ...

Descartando una inteligencia artificial capaz de reconocer las gramáticas, cosa que hace el parser pero en un argot limitado a órdenes, veo más viable basarse en trozos. Como cuando estamos rodeados de ruido y tan sólo escuchamos fragmentos de las palabras de nuestro interlocutor, y a partir de trozos clave -y del contexto- tratamos de recomponer el mensaje completo.

...

He hecho un apaño en Etemas para poder jugar con cinco listas de vocabulario independientes por objeto, y barajo incluir más de un objeto en el parsing para poder tener 5+5+5... de forma independiente.
Dos o tres sectores de vocabulario: uno para órdenes y encabezados de preguntas (averiguar si el jugador quiere saber dónde, cuándo, por qué, o si ordena que se vaya, que se quede, que vaya con él, que le dé algo); y el otro para saber el sitio, el objeto... etc.
El orden en el que se escriban dará igual, los diversos objetos se sacarán del mismo texto barriéndolo repetidamente, será lo mismo escribir: di a pepe dame la manzana, que di a pepe la manzana dame

Para eso, se añade a Etemas un cuarto modo de parsing: parsing_multiple, basado en el parsing_flexible:

[ FlexIntnombreMultiple obj u i w n;
for ( i = 0 : i < consult_words : i++ ) {
w=NextWordStopped();
if( u== 1 )if (WordInProperty (w, obj, name)) n++;
if( u== 2 )if (WordInProperty (w, obj, name_f)) n++;
if( u== 3 )if (WordInProperty (w, obj, name_mp)) n++;
if( u== 4 )if (WordInProperty (w, obj, name_fp)) n++;
if( u== 5 )if (WordInProperty (w, obj, adjectives)) n++; }
return n; ];

Ésta función será llamada con dos parámetros, el objeto obj, y un valor 'u' que indica qué lista de vocabulario de ese objeto se consultará. En una primera fase se consultarán todas y se sumarán todos los valores para descubrir el objeto-tema ganador... excepto la lista de adjetivos, cuya puntuación no será tenida en cuenta, y si aparece en la función es porque sí que será necesaria para la segunda fase. Se puede ver en AveriguarTema cómo se realiza la suma disgregada como si se tratara de un objeto-tema normal con una sola lista name.

[ AveriguarTema T i n k max tmax nn;
max=0; ! La mejor puntuación de momento
tmax=0; ! El objeto correspondiente a esta puntuación
k=wn;
objectloop (i in T) {

!...etc

if (i has parsing_multiple){
wn=consult_from; nn=0;n=0;
nn=FlexIntnombreMultiple (i,1);
n=n+nn;wn=consult_from;
nn=FlexIntnombreMultiple (i,2);
n=n+nn;wn=consult_from;
nn=FlexIntnombreMultiple (i,3);
n=n+nn;wn=consult_from;
nn=FlexIntnombreMultiple (i,4);
n=n+nn;wn=consult_from;
! nn=FlexIntnombreMultiple (i,5);
! n=n+nn; !adjectives no suma de cara a la palabra ganadora
}
!...

Y ahora la fase 2, justo antes de devolver el objeto ganador, analizamos nuevamente ese objeto, pero ésta vez dejando constancia de qué listas de ese objeto contienen vocabulario escrito por el jugador y cuales no:

!... if(tmax>0){
i=1;
wn=consult_from; !name
if(FlexIntnombreMultiple(tmax,1)>0)i=i*2;
wn=consult_from; !name_f
if(FlexIntnombreMultiple(tmax,2)>0)i=i*3;
wn=consult_from; !name_mp
if(FlexIntnombreMultiple(tmax,3)>0)i=i*5;
wn=consult_from; !name_fp
if(FlexIntnombreMultiple(tmax,4)>0)i=i*7;
wn=consult_from; !adjectives
if(FlexIntnombreMultiple(tmax,5)>0)i=i*11;
}
switch (T){
temas:temas.capciones=i;
temas2:temas2.capciones=i;
!temas3:temas3.capciones=i; !...etc
}
return(tmax); ! Y retornar el mejor hallado
! Observar que no hay intento de aclarar
! ambigüedades si dos o más coincidieran en
! puntuación
];

Usamos números primos para otorgar el valor final de la variable(propiedad) temas.capciones.
Posteriormente, podremos jugar con ese valor, por ejemplo:
Si temas.capciones vale 2, significa que sólo ha habido coincidencia en la lista de name.
Si temas.capciones vale 66, significa que ha habido coincidencias en la listas de name, name_f y adjectives.

Aquí un ejemplo de un tema, con sus valores de consulta:

xTema tSaludos "" Temas
with name 'hola' 'saludos' 'tal' 'como',
name_f 'dias' 'noches' 'tardes',
name_mp 'adios' 'voy' 'chao' 'adios' 'luego' 'vista' 'otra' 'vemos',
name_fp 'haces' 'haciendo' 'pasa' 'ocurre' 'pasado' 'ocurrido',
adjectives 'que' 'estas' 'hasta' 'buenas' 'buenos',
;
! (i==2) !hola
! (i==22) !qué tal estás
! (i==5 || i==15) !Adios
! (i==77) !¿Qué haces?
! (i==33) !Buenos días, tardes, noches

Es conveniente al menos una segunda vuelta, para detectar otro objeto de la misma forma, y poder elaborar estructuras más complejas con objetos INDEPENDIENTES. Con una sola vuelta, aunque cada objeto tenga 5 listas, éstas dependen de estar contenidas en el mismo objeto.

Ejemplo de objeto de primera vuelta:

xTema tIR "" Temas1
with name 'vete' 've' 'ponte' 'colocate' 'situate' 'subete' 'sube' 'dirigete' 'largate' 'marchate' 'metete' 'entra' 'pirate' 'sal',
name_f 'vente' 'ven' 'acompaname',
name_mp 'espera' 'esperame' 'quedate' 'aguarda',
!name_fp 'xxx',
!adjectives 'xxx',
;
!(i%2==0) !vete, ve a...
!(i%3==0) !ven, acompañame
!(i%5==0) !espera
!(i%7==0) ! sin uso aún
!(i%11==0) ! sin uso aún

Ejemplo de objeto de segunda vuelta:

xTema tsitios1 "" Temas2
with name 'rio',
name_f 'camino',
name_mp 'casa',
name_fp 'norte',
adjectives 'sur',
;
!(i%2==0) -> en algún río
!(i==6) -> en/a el camino del río
!(i==105) -> en/a el camino de la casa de pepe
!(i==35) -> en/a la casa del norte
!(i==55) -> en/a la casa del sur.
!(i%2==0) -> en algún río
!(i%35==0) -> en la casa del norte, o en el camino de la casa del norte, o al sur de la casa del norte, o en el río de la casa del norte
!...etc

Los lugares que no quepan aquí se meten en otro tema del mismo objeto Temas y listo.
Se podría crear una tercera vuelta de consulta, una cuarta... todos los objetos que se quieran a costa de velocidad de parseado, simplemente llamando repetidamente a AveriguarTemas(), con objetos contenedores de temas independientes, y previendo en el código el almacenamiento en variables diferentes del objeto ganador de cada ronda, así como sus capciones, para luego poder consultarlos en la función de conversación.

Pongamos que tenemos tres objetos contenedores de temas:
Temas1, Temas2, Temas3
Cuyos objetos ganadores se almacenan en las variable: To1, To2 y To3
Y las capciones en: Cap1, Cap2, Cap3
Podríamos tener un código de conversación tal que:

[xxxhablarSub tema i;
print "", (name)noun, " ";
print "responde: ";
to1=AveriguarTema(Temas1);
to2=AveriguarTema(Temas2);
to3=AveriguarTema(Temas3);

if(to1==tIR){!a
if(to2==tsitios1){!a1
!entiende "espera" y "casa" y "norte"
if(cap1%5==0 && cap2==35)"Me estás diciendo que espere en la casa del norte.";
}!a1
!entiende "ve" y ningún sitio de la lista, luego suponemos un ¡márchate!
if(cap1%2==0 && to2==0)"Me estás diciendo que me vaya.";
}!a
if(to2==tsitios1){ if (cap2%3==0)"Quieres saber algo referente un camino ¿eh?";}
!...etc

Otra corrección es unificar el sistema de conversación, que en Inform es disparatado, estando dividido en decir, preguntar sobre, ordenar, pedir...

Mi sistema ideal es: PERSONAJE, MENSAJE
aunque de momento lo he unificado como: DI A PERSONAJE MENSAJE

inauguración

2008-02-04T23:57:00.000+01:00

Informitas e informitos, bienvenidos todos a la casa del compilador...
[Corten... pareces un cura, tío]
TOMA 2!

Pues nada, aquí, que me voy a hacer un blog de mis cosillas con Inform...
[¡Corten!... ahora parece el diario de una adolescente]
TOMA 3!

Hola, soy Jarel, me recordarán de aventuras como Las Llaves del Tiempo o Regreso al Edén...