Problema: las impresoras multifunción Samsung como la CLX-3170fn o 3185 y similares pueden enviar el documento escaneado directamente a una dirección de correo (o varias). Esta característica no funciona, a priori, con cuentas de gmail o Google Apps con la configuración que Google te proporciona.

Motivo: el cliente de correo que lleva integrada la multifunción no permite utilizar conexión segura TLS o SSL. Para Google que permita conexión segura es un requisito, por tanto, cuando intentamos enviar un correo desde la impresora los servidores SMTP de Google rechazan la conexión “Error de conexión SMTP“.

Solución: tenemos que modificar la configuración de la impresora del siguiente modo. Después de conectar al cliente web de configuración de la impresora, vamos a la pestaña “Ajustes del equipo” y a la sección “Configuración de correo > Configuración servidor SMTP“.
La configuración que nos permitirá enviar emails usando a los amigos de la gran G es la siguiente:

...

Lo que hacemos es poner directamente uno de los servidores de correo de Google Apps. La lista completa de servidores en orden de prioridad es:

• ASPMX.L.GOOGLE.COM
• ALT1.ASPMX.L.GOOGLE.COM
• ALT2.ASPMX.L.GOOGLE.COM
• ASPMX2.GOOGLEMAIL.COM
• ASPMX3.GOOGLEMAIL.COM

Notas:
Se asume que la impresora está conectada a una toma de red ethernet.
Para que funcione la impresora debe tener algún servidor de DNS configurado en la pestaña “Ajustes de red”, sección “TCP/IP”. En general si se ha puesto con DHCP debería funcionar y si no siempre se puede probar la dirección IP del router (puerta de enlace y además servidor de DNS habitualmente) o las DNS de Google (primaria 8.8.8.8, secundaria 8.8.4.4)

Fuente:
hilo de soporte de google.co.uk.

Pues diviertete con unos apasionantes chistes UML, sí, es cierto. Chistes UML.

¿Dónde está el límite entre el lenguaje “humano” y el de los “ordenadores”? Eso se preguntan en esta web donde invitan a enviar chistes, la única condición es que deben estar construidos usando UML, toda una proeza. Lo peor es que tienen gracia y todo.

Como motivación: puedes ganar un portatil.

Enlace: UML Jokes

Ahora concretamos en la solución encontrada como más adecuada: JSqlParser.
Este parser es un proyecto de Software Libre alojado en SourceForge bajo licencia LGPL.

Al descargarlo de SourceForge, nos encontraremos con un archivo .jar. Este archivo contiene la libreria .jar que necesitamos y, además, tanto la documentación como el código fuente. Una forma sencilla de extraer el contenido es renombrar el archivo, cambiando su extensión por .zip. Entonces, lo extraemos con cualquier utilidad para descompresión de este tipo de ficheros.

Encontramos una estructura de carpetas donde nos interesan:

(si estas en Windows, tus barras serán así: \)
• Librería: “jsqlparser/lib/jsqlparser.jar”
• Documentación: “jsqlparser/docs” también en los Javadocs de la página web.
• Código fuente: “jsqlparser/src/net/sf/jsqlparser”
• Archivos SQL de prueba: “jsqlparser/testfiles”

Es interesante saber también que existe un foro en SourceForge donde es posible encontrar (u ofrecer) ayuda. En la página web podemos encontrar un ejemplo que nos será de extrema utilidad para empezar a trabajar con JSqlParser.

Dependiendo del entorno de desarrollo que use deberá agregar la libreria jsqlparser.jar para que esté disponible. A partir de ahí ya podemos usar la librería en nuestro código pero antes necesitamos saber unas cuantas cosas. Explicaremos a continuación una serie de conceptos que pueden facilitarnos la comprensión e la forma de trabajar de esta librería.

• Objeto visitador (Visitor): implementa diversas versiones del método visit(objeto_a_visitar) haciendo un uso extensivo del polimorfismo. Visitor es en realidad un interfaz que debe ser implementado por un objeto pero ahora veremos eso.
• Objetos visitables: tienen un método accept(objeto_visitador).

El funcionamiento es el siguiente. Si tenemos un objeto denominado Objeto1 que tiene un método accept(). Cuando invocamos Objeto1.accept(Objeto_visitador), estamos llamando al método accept() y pasándole un objeto que es el Objeto_visitador. Dentro del método accept() lo que ocurre es que se usa el Objeto_visitador, y se invoca su método visit(). De este modo hacemos: Objeto_visitador.visit(Objeto1).
En Objeto_visitador tenemos muchas versiones de visit(), una para cada tipo de objeto que podemos tratar, de este modo, con un unico Objeto_visitador podemos actuar sobre múltiples objetos distintos.
Todos los objetos implementan el método accept(), que provoca que el objeto acabe siendo pasado como parámetro al objeto_visitador, que usará el método visit() adecuado para cada tipo de objeto que reciba.

En resumen, cuando invocamos accept(Objeto_visitador) en un objeto, lo que estamos provocando es que Objeto_visitador reciba el objeto como parámetro en un método que se encargará de tratarlo.

El artículo de la wikipedia puede ser bastante más clarificador que estos párrafos.

Creo que la forma en que queda más claro es con un ejemplo y el ejemplo en Java de la Wikipedia es bastante bueno. Aunque yo hubiera usado personas en lugar de piezas de coche por que queda mucho más clara la analogía de la visita:

Imaginemos que el visitador es un médico y el visitable un paciente (hombre, mujer o niño) y el médico puede tratar a los tres.
El paciente enferma y usa su metodo accept(médico) porque necesita un médico, igualmente puede tener accept(fontanero) si lo que necesita es un fontanero. Cuando acepta al médico, lo llama y le pide que le visite, esto es, dentro de accept usa el método visit del médico pasandose a si mismo como argumento.
El médico recibe la petición de visita y dependiendo de que fuera quién ha llamado hará una visita para hombre, mujer o niño porque, aunque la llamada es la misma, se ejecuta un método distinto para cada uno.
El médico tratá al paciente con lo que tenga que hacerle y fin del proceso.

Es posible rizar esto un poco más: el médico puede curarse a si mismo, visitador y visitado pueden ser el mismo; puede haber, al igual que distintos pacientes, distintos médicos que apliquen tratamientos distintos, clases distintas que implementan el mismo interfaz (la forma de llamar al médico es siempre la misma).

Este patrón combinado con un uso jerárquico de llamadas nos da una capacidad y una flexibilidad sorprendente para tratar una estructura más o menos compleja como puede ser una consulta SQL.

En JSqlParser, existen múltiples interfaces Visitor. Que debemos implementar adecuadamente en una clase para tratar ese tipo de objetos. Usar los interfaces nos asegurará que implementamos todos los métodos necesarios para tratar esa parte de la estructura de la consulta.

No me voy a extender mucho aquí. La estructura corresponde a una descomposición desde arriba hacia abajo de la estructura de la consulta Select, el resto son similares. Para la descomposición se han ido tomando los campos de cada objeto sucesivamente, los que tienen una flecha roja indican que están descompuestos en otra parte del esquema (son enlaces en el archivo original). Para ver los métodos de cada objeto acudid a la documentación original.

Solo comentar que es cada cosa en las imagenes:

• Texto gris claro con imagen bombilla o campana: Documentación. Anotaciones útiles.
• Texto marrón con imagen clip: Interfaz. Cuando aparece un interfaz se descompone en todos los objetos que implementan ese interfaz.
• Texto rojo con imagen carpeta azul: Objeto. Se descompone en sus campos que pueden s er tipos de datos primitivos, objetos e interfaces.
• Texto azul: listas de objetos o interfaces. Muy usadas en toda la libreía.
• Texto rojo oscuro: Tipo de dato primitivo. Como un entero o una cadena.

Una de las imagenes contiene la estructura general y la otra la expansión del interfaz Expression que por su tamaño e importancia (y legibilidad) merece su propia imagen.

Cómo usar todo esto junto sin volverse loco

Partimos del supuesto que tenemos una consulta SQL en una cadena y queremos extraer sus partes. El procedimiento que podemos seguir pasa por crear una clase visitador que reciba la consulta, la analice con el parser que trae JSqlParser y entonces empieza el proceso maravilloso:
Tomamos la consulta completa, la cual tiene metodos para extraer sus partes. Bien, las extraemos y en cada parte usamos el método accept(visitor) esto hará que nuestro visitador vuelva a recibir las partes, que irán a su método visit() gracias al poliformismo de estos.
Una vez recibida cada parte podemos descomponerla en sus partes usando sus propios métodos y llamar en cada una accept(visitor) de nuevo.
Este proceso puede continuar hasta los elementos más elementales de la consulta: cadenas de texto que representan nombres de columnas y tablas, enteros, etc….

¿Y qué tiene esto de divertido? Lo divertido es que podemos incluir lo que necesitemos hacer en el proceso y modificar o extraer los datos que necesitemos de la consulta sin esfuerzo.

En el ejemplo de la web realiza un visitador que va recorriendo la consulta de arriba hacia abajo y cuando encuentra un nombre de tabla lo guarda en un ArrayList donde, al terminar el proceso, estarán todas las tablas que aparecen en la consulta. ¿Y cómo sabe cuando ha llegado a un nombre de tabla¿ Es tan sencillo como que en visit(Table tableName) sólo entrarán tablas, extreamos su nombre y lo guardamos.

Mi recomendación es que intentéis entender la estructura de la consulta, tomeis el ejemplo de la web, terminéis de implementar los interfaces que faltan, en caso de que los veais necesarios, del mismo modo que están los del ejemplo y uséis esa clase como padre para las que os serán de verdadera utilidad. De este modo ocultamos la clase “fea” y obtendremos una clase “bonita” donde sólo está la tarea que nos interesa.

Yo necesitaba extraer todos los nombres de columnas y tablas. Lo que hice fue terminar de implementar la clase del ejemplo que recorría la consulta de arriba hasta abajo. Esta es la clase padre.

Hecho esto, cree una clase que extendía la anteriormente creada. en esta nueva clase incluí sólo dos métodos que sobreescribían a los de la clase padre: visit(Column columnName) y visit(Table tableName) que recogían los nombres de las tablas y columnas que recibían y los iban guardando en unas listas destianadas para eso.

Y este es el final. Enhorabuena si has llegado hasta aquí leyendo y enhorabuena de nuevo si has entendido algo. El funcionamiento es confuso en un inicio si no estás familiarizado con este tipo de estructuras (para mi lo fue) pero, tras leer un poco y algo de esfuerzo, se pueden conseguir unos resultados muy buenos tanto en la descomposición como en la composición de consultas.

¡Suerte!

Podría parecer que un parser SQL para Java es una cosa poco exótica (bueno, depende de dónde te muevas, probablemente para la mayor parte de la gente lo sea :P) pero no hay una solución que podríamos considerar ampliamente aceptada. En lugar de eso podemos encontrar múltiples soluciones parciales más o menos incomodas.

Podemos resumir que todo fue un poco infernal hasta que me decidí a probar JSqlParser, un parser de Sql para Java basado en una gramática para JavaCC creada por un tal Guido Draheim. Yo hasta hace poco tampoco entendía nada de esto :)

En un artículo posterior profundizaremos en JSqlParser. En este articulo se comentan las posibilidades que existen y la dificultan que conllevan, así como algunos conceptos sobre parsers, gramáticas y trabajo innecesario: ¿quieres saber más? pues sigue leyendo:

En realidad tenemos múltiples opciones, que vamos a ir recorriendo de mayor a menor dificultad:

Puedes programar tu propio parser desde cero. Si no estás metido en lingüistica Computacional y sabes de que estás hablando, mejor que descartemos esta opción.

Una propuesta que se puede encontrar facilmente es: “Puedes hacerte tu propio parser utilizando una generador como JavaCC , ANTLR o LPG“. Bueno, la expresión equivalente podría ser algo como: “Si quieres ir al trabajo comodamente puedes construirte tu propia bicicleta con cualquier caja de herramientas”.

Los generadores de parser son complejos y si el parser no es algún aspecto central de tu tarea, no creo que valga la pena aprender. Estas herramientas funcionan del siguiente modo: una persona escribe un conjunto de reglas (normalmente llamadas gramática) y el generador, usando estas reglas, da como salida código en un lenguaje de programación concreto que permite parsear(permitidme la licencia, “analizar sintácticamente” es mucho más largo) el lenguaje de programación deseado. El lenguage de salida puede ser definido mediante la gramatica (como en ANTLR) o estar definido de antemano (como en JavaCC). Si os gustan los compiladores y teneis mucho tiempo libre, ¡adelante!. En otro caso, seguid leyendo.

Una opción más moderada es buscar una gramática que alguién haya creado ya y utilizar el generador de parsers para crear nuestra ansiada herramienta. Esta opción me pareció muy interesante al principio, pero encontramos dos problemas:

1. Encontrar la gramatica: no estan fácil encontrar una gramática completa para SQL estándar. Encontramos múltiples para subconjuntos o implementaciones concretas pero la gran gramática que buscamos es esquiva y se oculta bien.
2. El parser generado no es precisamente user friendly. De repente tendrás entre tus manos un maremagnum de clases y métodos y ninguna idea de como meterle mano (ni documentación, dicho sea de paso).

Como ejemplo mi experiencia, encontré una referencia (que no localizo ahora) acerca del parser de SQL que Derby usa internamente. Bien, destripé a Derby, extraje la gramática para JavaCC que contiene y generé el parser: el infierno es más sencillo de controlar. Huelga decir que, después de eso, destripar un plugin de SQuirreL no era una posibilidad.

Como tercera opción tenemos usar un parser completito, existente y, a ser posible, con una licencia generosa. Encontramos unos cuantos en la busqueda:

• ZQL: basado en un parser generado con JavaCC. Descartado por su falta de garantías y porque la batería “exhaustiva” de pruebas que muestra deja mucho que desear.
• SQL4J: demasiado bonito para ser cierto, es sencillo y parece funcionar muy bien para la mayor parte de los casos. Perdió su oportunidad cuando se atascó en un caso sencillo y habitual como el de encontrar una función como SUM(tabla.columna1) en la consulta. Esto sumado a la total falta de documentación provocaron su caída de la lista.
• sql development tools project dentro de Eclipse: basado en LPG, muy interesante si usas Eclipse pero no pude llegar a probarlo porque es incompatible con la versión que usamos en la empresa. Me quede con las ganas.

El último elemento de esta lista es el que titula este artículo: JSqlParser. Basado en un parser generado con JavaCC. Este parser asusta en un primer momento por su complejidad aparente (sobre todo si no has estudiado informatica o sabes bastante de POO como es mi caso) pero vale la pena el esfuerzo. Su curva de aprendizaje es un poco abrupta, lo que quiere decir que un pequeño esfuerzo inicial se ve compensado con un dominio más que suficiente de la herramienta en poco tiempo.
La documentación no es maravillosa pero sí aceptable y hay una cierta comunidad alrededor que puede dar respuestas.

Es útil tanto para analizar como para generar consultas SQL de una complejidad asombrosa, sin duda una gran opción y mi recomendación.

En el proximo artículo abordaremos un poco la estructura y la forma de trabajar de JSqlParser. Lo cual ahorrará a muchos el trabajo inicial de entender y empezar a trabajar con JSqlParser.

Todo empieza cuando decido poner en orden mi disco duro. Tengo un Toshiba Satellite M70 (con el que estoy muy contento) y traía su Windows Xp preinstalado como es habitual, posteriormente había repartido el sitio y había instalado Ubuntu, todo en orden. Afirmaba con orgullo que mi windows no había sido reinstalado nunca desde que tengo el ordenador pero el hecho de que estuviera ya algo achacoso y el uso que estaba haciendo de Linux me llevaron a la idea de repartir el espacio de nuevo, disminuyendo el espacio para Windows y creando una nueva partición en FAT32 (soy conservador respecto a Linux y NTFS, con calma) para que los datos fueran accesibles desde Win y Linux (para lo que uso Windows ahora no se si ha valido la pena todo esto).

Primero de todo, muchas copias de seguridad.

Luego reparto del sitio con un LiveCD y GParted, reinstalación de Linux. He de confesar que hasta este punto no estaba seguro de reinstalar Windows, ya que funcionaba bien y todo el mundo sabe lo tremendamente aburrido que es. Si no, habría instalado Windows antes de Linux. Pues bien, me dije: “ya que tienes el CD de recuperación de Toshiba, puedes tener una instalación bastante completa de Windows en sólo unos minutos ¡Vamos Allá!”.

Seguro que queréis saber que paso.

Situación en ese momento: cinco particiones, Windows, Linux /, Linux swap, Linux /home y FAT32. Todo funcionando perfectamente.
Decido meter el CD de recuperación de Toshiba…reinicio….iniciando Windows 98…recuperando 1%, 2%, 3%…. En este momento lo supe, estaba machacando el disco duro de forma cruel e imparable, pero era tarde y le deje hacer.
Volvía a tener una instalación limpia de Windows…y nada más. Me resultaba extraño, ¿el cd no me preguntó nada?, ¿machacó todos mis datos sin avisar?! ¡Que raro! Volví a reiniciar con el CD de recuperación y ahí estaba el menu:
1->Machacar todo
2->Menu avanzado, incluso te dejaba recuperar la imagen de windows a una partición.
Algo no iba bien.

Bueno, volvía a la tarea de reparticionar, rehice las particiones. Reinstalé Ubuntu y el mundo parecía ser de nuevo un lugar en orden.

He de confesar que caí de nuevo. Tenía que saberlo. Volví a insertar el CD de recuperacón de Toshiba. Yo había visto el menu, sabía que existía. Con todo listo y ordenado de nuevo, metí el CD de recuperación de Toshiba y volvió a pasar, no había menu, no había esperanza, esta vez lo corte cuando iba por un 1% o 2%.

¿Qué ha pasado? Sigamos investigando. Arranque con el CD de instalación de Ubuntu, GParted, rehago las particiones y ¡sorpresa! las particiones de linux se montan bien. Quizá no sea necesario reinstalarlo, solo recuperar el grub.
Una vez particionado, arranqué con el CD de recuperación de Toshiba y ahí estaba, AHÍ ESTABA EL MENU. Modo Avanzado, recuperar a una partición, aceptar…perfecto, windows recuperado en su partición. Reiniciar….no funciona, descubró que no tenía partición activa (boot), uso GParted y marco la de Windows. Bien Windows ya arranca en su partición, ahora solo tengo que arreglar grub. Tras investigar un poco encontré como hacerlo, lo recuperé pero el sistema de archivos se había ido a la porra y tuve que reinstalar Linux de nuevo. Y por fin todo quedó en orden.

Es decir, el menu del CD de recuperación de Toshiba sólo te pregunta si encuentra un sector de arranque de Windows, si encuentra Linux lo machaca todo, SIN PREGUNTAR SIQUIERA si estás seguro. El CD de recuperación es un recocido del Norton Ghost (en) para Toshiba. Al usarlo en modo avanzado, cuando reinstalé Windows a una partición, podía ver perfectamente las otras particiones e incluso las identificaba como particiones Linux, entonces ¿por qué no puedes reconococer otro sector de arranque? Supongo que buscará el de Windows y si no está, asume que el disco esta sin formato, corrupto o a saber y machaca. He de hacer notar que Toshiba es pro Windows en sus equipos.

Me quedan algunas tareas como poner los scripts para el recuento de visitas y alguna más pero son cosas de las que no sereis testigos :P Si alguien ha visitado este sitio en las últimas horas, habrá tenido la oportunidad de ver cambios de tema, entradas mutiladas, codificaciones de caracteres incorrectas y muchas más cositas ¿y eso porqué?

Pues porque las versiones anteriores de WordPress usaban una codificación de caracteres latin1 (idiomas de Europa occidental, sin el simbolo de Euro que está en latin9) pero la versión actual usa codificación UTF-8, una codificación universal. Bien el problema surge cuando descubres que si actualizas desde versiones anteriores de WordPress puedes tener ciertas incoherencias entre lo que debería ser y lo que es. Ya que la codificación de la base de datos y de los post puede no ser la que debiera o la que idealmente dedería ser.

Si es una instalación nueva de WordPress, no hay de que preocuparse. Todo esta bien. En otro caso, puedes seguir leyendo.

No se mucho de todo esto pero al final ha salido bien. Hay varias soluciones al problema, existe una sencilla y previsiblemente temporal, un borrador de una solución en el codex de wordpress que es solución definitiva pero muy engorrosa y una solución formal y elegante mediante el plug-in “UTF-8 Database converter”.

La solución del plug-in me ha llevado al huerto y me he decidido a probarla con catastófrico resultado… por eso hay que hacer un backup, por ejemplo mediante el plug-in WP-DB-Backup ¡MUY IMPORTANTE!

No sabría deciros los pasos poruqe me he equivocado un par de veces o más, obeteniendo entradas truncadas o sembradas de simbolitos raros. Pero creo que podría deciroslos:

1. Haz un backup de todos tus datos y ponlo a buen recaudo en tu ordenador
2. Sigue las instrucciones para usar el plug-in “UTF-8 Database converter”, esta todo en castellano. A leer un poquito. Tienes que editar el wp-config.php que no se olvide.
3. ¿Se te ha roto todo? Si es así sigue leyendo, si no pués ya está
4. Importa de nuevo el back-up de tu base de datos, asegurate de que indicas que la base de datos está codificada como latin1 al importar los datos
5. ¿Se ven simbolitos raros? Intentemos arreglarlo.
6. Dentro de la administración de WordPress, ve a Opciones->Lectura->Codificación para páginas y feeds. Introduce el valor UTF-8
7. Si se ve todo bien, enhorabuena,

Como os decía he tenido algún problema y no se si esta solución es la buena. Si además añadimos que no se mucho del tema, pues bueno, de ahí la utilidad del backup.

Si alguien prueba esto, pro favor que me diga los resultados, las condiciones de partida y lo pasos que ha dado para mejorar la recetilla.

Estos cursos parten prácticamente de cero en la mayor parte de los casos, en ocasiones sólo son necesarias nociones en algunos campos, claro está que un dominio medio en cosas como HTML o saber algo de bases de datos puede allanar bastante el camino.

Están organizados en forma de lección sencilla, ejemplo y ejercicio de cada parte con lo que te obligas a practicar lo aprendido. Una gran ventaja es que el código se escribe y se interpreta directamente en la web, así que las excusas de que hay que instalar Apache o que es una pesadez tener que subir cada archivo por ftp al servidor para probarlo se acabaron.

Las lecciones van aumentando la complejidad progresivamente y de forma bastante gradual, de forma que el curso completo forma un solo bloque, esto se echa en falta en otros cursos construidos mediante colaboración de muchas personas en los que las lecciones van dando saltos de dificultad y estilo, lo que puede llevarte a confusión. ¡Ah! Están completamente en español.

Cada curso está alojado bajo un dominio distinto del tipo www.”materiadeinteres”ya.com.ar, por ejemplo, para php el curso se encuentra en www.phpya.com.ar y para mysql es www.mysqlya.com.ar.

Los cursos cubren otras materias como:

• HTML
• CSS
• Javascript
• DHTML
• AJAX
• SQLserver
• ASP

Ya no teneis excusas para aprender. ¡Qué os sean útiles!

Por ahora tiene muy buena pinta, la instalación es fácil, como la de la mayoría, pero en este caso todas las instrucciones estan dadas a un nivel más alto, queriendo decir menos técnico. Esto tiene ventajas y desventajas, si sabes un poco que estas haciendo todo resulta sencillo, si tienes algún problema puede que no sepas de que te estén hablando y te encuentres perdido. Intuyo que todo estará resulto en la web de forma más o menos clara, no he tenido ocasión de comprobarlo porque por ahora ha ido como la seda.

La interfaz es una monada(tanto la web como la administración) y por ahora parece bastante intuitivo. La orientación parece clara hacia comunidades y viene con funciones para gestionar publicidad y estadísticas de serie.

Parece que la idea es que puedas hacer mucho sin saber una etiqueta de html, me reitero, tiene sus ventajas y sus inconvenientes.

Todo esto son primeras impresiones , ya que, como he dicho, es un descubrimiento (muy) reciente pero me ha causado buena sensación y, por ahora, recomiendo a todo el que esté interesado que le eche un vistazo.

Bien, el juego no funciona en WindowsXP. Lo que no es de extrañar dado que es un programita para MS-DOS y usará todas esas tripas feas que tenía aquel sistemita operativo de nacimiento algo turbio.

Asumo que casi todos los que me leen tienen buenos conocimientos informáticos pero por si acaso llega un alma cándida curioseante que cree que el MS-DOS es la segunda parte de la pelicula MS, intentare ser muy claro (se que no lo conseguiré).

1. Debeis bajaros el DOSBox, una pequeña maravilla que te permite ejecuta muchas muchas cosas hechar para MS-DOS pero en muchos otros SO, como WindowsXP. Vamos a Downloads y cogemos la versión Windows (está la primerita) que es Win32 installer. Lo bajamos del mirror que nos pille mas cerca o del que nos de mas coraje. Lo instalamos y ya tenemos donde ejecutar el juego.
2. Nos bajamos el Supaplex, por ejemplo de su página web, arriba tenemos “Free Download” de donde podemos bajar el juego comprimido en archivo .zip. Mi recomendacion es que creéis una carpeta sencilla en C:, tal y como C:\JUEGOSDOS y dentro otra carpeta llamada SUPAPLEX. Dentro de esta última carpeta procedemos a descomprimir el juego. Esto nos permitirá guardar más juegos dentro de la carpeta JUEGOSDOS, lo que resultará muy comodo por lo que ya vereis.
   Tenemos entonces C:\JUEGOSDOS\SUPAPLEX con todo el Supaplex dentro :D
3. Último paso. Ejecutamos DOSBox, nos saldrá una ventana que imita a la perfección una de MS-DOS y otra por detrás que no nos interesa. Tenemos que montar una unidad, que será donde estarán nuestros juegos. Nos encontramos con el promt “Z:\>_”, escribimos: mount c c:\juegosdos e Intro. Si has usado otro nombre para la carpeta que contiene la carpeta del Supaplex pues sustituye juegosdos por el nombre que hayas usado.
   Tachán, tenemos una nueva unidad C:, si escribes: c: cambiarás de unidad, y escribiendo dir vemos como todos los contenidos de nuestra carpeta JUEGOSDOS son ahora los de la unidad C:, podemos tener distintas carpetas con distintos juegos que nos proporcionarán la dicha y la felicidad más grandes.
   Tan sólo queda cd Supaplex para entrar en la carpeta y spfix63 (o el archivo .exe que haya si ya es otra versión) para iniciar este juego terrible.

¿Qué no te funciona bien el teclado?, los “:” están en la “Ñ” y la “\” está en “ç”.

Espero que lo disfruteis porque nadie puede decir que ha jugado a videojuegos toda su vida si no ha perdido antes unas horas con el amigo Supaplex.

Actualización: El Megaplex funciona perfectamente en WindowsXP, aunque echo en falta la música y parece que los efectos de sonido tampoco andan bien del todo. Trae algunas carácteristicas interesantes (o muy interesantes) como el editor de niveles, el zoom, control de velocidad. Espero que lo sigan mejorando porque aunque el nuevo interfaz y el aspecto gráfico es una actualización excelente, se echan de menos cosas como el cronómetro de tiempo real (no en frames), y la gestión de niveles y usuarios del original. Y por que no, el otro tiene encanto, que a uno le gusta alimentar la vena nostálgica escribiendo “cd supaplex” y jugando con esos graficos de punto gordo. Podemos retitular este post “La renovación del vicio en un click: Megaplex”. Gracias a aquellos que me han avisado de su existencia y al resto: ¡Probadlo!