El código puede verse en: https://gist.github.com/axelei/dafd305213ed1b2655545f06edfbc905

# Programa para clonar prestashop
# Copyright Krusher 2015 - Licenciado bajo GPL3

paramfile="httpdocs/app/config/parameters.php"
extractDatabaseName="s/.*'database_name' => '\(.*\)'.*/\1/p"
extractDatabaseUser="s/.*'database_user' => '\(.*\)'.*/\1/p"
extractDatabasePassword="s/.*'database_password' => '\(.*\)'.*/\1/p"

if [ "$#" -lt 4 ]; then
  echo "Error: Se requieren 3 argumentos."
  echo "Uso: $0 dir_web_original dir_web_destino url_original url_destino"
  exit 1
fi

echo Traspasando de $1 a $2 \(urls: $3 -- $4 \)

databaseName=$(sed -n "$extractDatabaseName" $1/app/config/parameters.php)
databaseUser=$(sed -n "$extractDatabaseUser" $1/app/config/parameters.php)
databasePassword=$(sed -n "$extractDatabasePassword" $1/app/config/parameters.php)

echo Datos de la base de datos de origen: $databaseName / $databaseUser / $databasePassword

targetName=$(sed -n "$extractDatabaseName" $2/app/config/parameters.php)
targetUser=$(sed -n "$extractDatabaseUser" $2/app/config/parameters.php)
targetPassword=$(sed -n "$extractDatabasePassword" $2/app/config/parameters.php)

echo Datos de la base de datos de destino: $targetName / $targetUser / $targetPassword

if [[ -z "$databaseName" ]] || [[ -z "$databaseUser" ]] || [[ -z "$databasePassword" ]] || [[ -z "$targetName" ]] || [[ -z "$targetUser" ]] || [[ -z "$targetPassword" ]]; then
  echo "Error: Algunas de las variables no han sido extraídas, comprueba los errores y los directorios."
  exit 1
fi

echo URL de la instancia origen: $3
echo URL de la instancia destino: $4

read -p "Pulsa enter para continuar o CTRL+C para cancelar"
echo  "Procediendo con el traspaso."

echo Extrayendo base de datos
rm -f temp.sql
mysqldump -u $databaseUser $databaseName -p$databasePassword > temp.sql
echo Borrando base de datos objetivo
mysql -u $targetUser $targetName -p$targetPassword -e "drop database $targetName; create database $targetName"
echo Insertando la base de datos origen en la objetivo
mysql -u $targetUser -D $targetName -p$targetPassword < temp.sql
rm -f temp.sql

echo borra ficheros contenido antiguo
rm -Rf $2/*
echo copia ficheros
cp -r $1/* $2/

echo Configurando base de datos objetivo con los datos originales

sed -i "s/'database_name' => '\(.*\)'/'database_name' => '$targetName'/g" $2/app/config/parameters.php
sed -i "s/'database_user' => '\(.*\)'/'database_user' => '$targetUser'/g" $2/app/config/parameters.php
sed -i "s/'database_password' => '\(.*\)'/'database_password' => '$targetPassword'/g" $2/app/config/parameters.php

echo Configurando la nueva URL en la instancia destino

mysql -u $targetUser $targetName -p$targetPassword -e "update prstshp_configuration set value = '$4' where NAME IN ('PS_SHOP_DOMAIN', 'PS_SHOP_DOMAIN_SSL')"
mysql -u $targetUser $targetName -p$targetPassword -e "UPDATE prstshp_shop_url SET domain = '$4', domain_ssl = '$4' WHERE id_shop_url = 1;"
sed -i s/\\^$3\\$/^$4$/g $2/.htaccess

echo Terminado.

Podría estar mejor hecho, en un lenguaje mejor o usar herramientas más avanzadas, pero es cómo me las tuve que apañar en un entorno que le faltaban muchas herramientas y comandos. Si te ha sido útil deja un comentario con tu experiencia.

La entrada De cómo clonar una instancia de Prestashop se publicó primero en Detrás del último no va nadie.

No obstante y como mero entretenimiento, voy a tratar de discurrir sobre cómo sería hacer café en diversos lenguajes de programación, inspiración que me ha venido de mi locuelo compinche de fechorías retroinformáticas Ilgrim. También del famosísimo comic de Toggl, por supuesto.

Basic

No será rápido, pero será fácil. Eso sí, no podrás personalizar demasiado el café ni ver los entresijos de la maquinaria, dado que será un café para principiantes. Perfectamente válido para consumo ocasional, aunque seguramente quieras pasarte a un café mejor en cuanto hayas aprendido lo fundamental.

PASCAL

Muy parecido al café Basic, aunque los botones en la cafetera tienen símbolos parecidos aunque distintos, o pueden no estar exactamente en el mismo sitio.

COBOL

El café en COBOL es negro y sin azúcar. Ha sido así desde que el Hombre tiene memoria y lo será hasta el final de los tiempos. Esta tradición es tan sagrada que nadie se atrevería a cuestionarla, y aunque este café está más desactualizado que llevar el jersey por los hombros y tenga pocos adeptos, siempre existirá el café COBOL.

Java

A menudo se critica a este café por ser lento, pero afortunadamente ha mejorado con el paso de los años. Más recientemente, se ha descrito la incomodidad de pedirlo con cuidado, ya que si alguno de los ingredientes no está disponible, el camarero te interrumpirá con un guantazo. Por ello, a veces los clientes hablan en Kotlin, un idioma para pedir café Java que evita esta burocracia.

Dado que es mi especialidad de café, puedo explayarme mejor. De hecho hay tres formas fundamentales de hacerlo.

La primera es, por supuesto, usar la cafetera que ya trae Java, importándola de java.coffee. No es mal café, pero puede que no sea justo el que necesitas o que no sea posible ponerle sacarina.

Por supuesto, puedes hacer tu propia cafetera usando los componentes de java.coffee. Pero mejor heredar la cafetera anterior y ponerle un asa más chula o añadir un botón para ponerle sacarina, dado que hacer café no es algo fácil y lo necesitamos para ayer.

La tercera, la más fácil, es simplemente diciéndole al gestor de paquetes que compre una cafetera nueva en Maven o en Gradle. Hay multitud de modelos para elegir con montones de versiones y algunas hacen un café de primera, aunque puede resultar un proceso lento dependiendo de tu casa. Parece increíble, pero la mayoría son gratuitas y traen los planos de cómo se hicieron, aunque a veces los añadidos pueden costar un extra. El uso de estas cafeteras puede variar, y es mejor asegurarse de que la toma de enchufe sea la misma que la que tienes.

A pesar de todo lo anterior, por desgracia, cuando llegue el momento de hacer el café, te darás cuenta que ya hay una cafetera a medio construir. Empezó siendo una hoja Excel donde se anotaban los tiempos en los que los empleados consumían café, y ahora es una fábrica de cafeteras complicadísima, sin el menor atisbo de documentación de su intrincadísima ingeniería. Hay que tener mucho cuidado con estas cafeteras, ya que son tremendamente caras, lentas, ineficientes y a veces, al cambiar algún pequeño ajuste, dejan de funcionar partes sin relación alguna.

El café tiene que tener un grado de dulzor, acidez, tueste y molienda perfectamente iguales a los que el cliente quiere, pero lo que ha pedido es un café indo-etrusco, y nadie tiene la menor idea de qué significa eso. El café llegará frío, tarde y saldrá un 80% más caro, y la culpa siempre será del barista de inferior salario.

C#

Las malas lenguas dicen que no es más que una copia del café Java. Lo cierto es que el manual de instrucciones es ligeramente distinto, con mayúsculas donde antes esperabas minúsculas, y emplea referencias elegantes para definir tareas antes comunes y aburridas.

Aunque no tiene la comunidad de cafeteros que tiene el café Java, es el nuevo favorito de los jugadores. Además no necesita el aparatoso transformador de corriente que puede venir o no con las cafeteras de Java.

Lisp

Es el café favorito de las inteligencias artificiales. El café viene servido en una taza, dentro de un vaso, dentro de un plato, dentro de una bandeja, dentro de una tabla, en una mesa colocada sobre una tarima. Se dice que este café podría tener autoconsciencia.

C

Es el café de los sistemas operativos, y lleva siendo así desde los años 70. Normalmente el entorno ya proporciona los granos de café, pero a veces tiene que plantarlos uno mismo, regarlos y recolectarlos. La cafetera hay que montarla desde cero, aunque es posible usar piezas que hayas encontrado en una cuneta.

Aunque puede ser farragoso de hacer la cafetera, el café en sí es rapidísimo, y en principio no hay problema para hacerlo en cualquier hogar, siempre que el manual de instrucciones esté en el idioma local. Hay que tener mucho ojo, eso sí: si falta algún ingrediente lo normal es que la cafetera explote. Si se toca un cable pelado se puede ir la electricidad en toda la habitación, y si la instalación eléctrica es antigua, en todo el barrio. La forma de la cafetera es totalmente permisiva, y puede que haya ingredientes cuya localización sea otra habitación, estando totalmente inaccesibles, aun así ocupando espacio.

Con todo, este café a menudo es citado como una de las mayores hazañas en procesos de preparación de café de la historia. Su inventor, lamentablemente, falleció el mismo día que un conocido y carismático diseñador de cafeteras de diseño carísimas, de modo que no se le recuerda como le es merecido.

C++

Normalmente se piensa en este café como una mejora sustancial del café C, aunque esto es objeto de debate. La gran diferencia es que este café permite hacer referencia a la taza como un objeto, y no como una estructura de partículas cerámicas abstracta. Para hacer café no es necesario juntar todas las piezas al principio del proceso, sino que puedes cogerlas según las vayas necesitando.

Ensamblador

El café ensamblador difícilmente se define como una manera de hacer café. Todo lo que se proporciona es una tierra baldía. Se conoce como el café más rápido posible, siempre que la cafetera sea la correcta, aunque sólo funcionará en cierto lugar de la encimera de tu cocina. También es cierto que, antes de este café, sólo existían ciertas fórmulas para preparar diversas sustancias definiendo su forma molecular, de modo que podemos considerarlo un pionero.

Lo primero y más llamativo con respecto a los cafés descritos anteriormente es que uno debe buscar primero minerales para hacer sus herramientas, y luego refinarlos, fundirlos y montarlos con otras herramientas. Estas herramientas serán, probablemente, para construir las herramientas que se usarán en la elaboración del café.

Las semillas de café deben estar perfectamente definidas. Hay que realizar todo el proceso que toma hacer café C, pero el proceso se describe con palabras muy pequeñas en frases muy muy cortas que realizan pasos diminutos. No sólo hay que regar y cuidar los cafetos, el proceso debe estar perfectamente descrito sin atisbo a malentendidos en este lenguaje minimalista. El café debe cosecharlo uno mismo, a mano o construyendo herramientas al efecto siguiendo los pasos descritos anteriormente. Incluso el abono debe proporcionarlo uno mismo, y ya sabemos lo que eso implica: para hacer este café hay que estar dispuesto a llenarse las manos de mierda.

La cafetera, aunque parece robusta, tiene formas espartanas. Si no fuera por las recientes mejoras en las instalaciones eléctricas domésticas, el aparato podría hacer cualquier cosa, como encender la tele o hacer sonar el timbre. (aunque esto también es aplicable café C)

Es, probablemente, el café más complicado que existe de hacer, y es tan específico que sólo servirá para un consumidor. Eso sí, la satisfacción será del 100% si está correctamente realizado.

PHP

Hacer café en PHP es de lo más sencillo, pues simplemente se le pide a la cafetera que trae incorporada que te lo prepare.

Aunque la teoría es sencilla, la práctica nunca es lo que parece. La cafetera tiene dos botones de encendido, pero para apagarlo hay que usar una palanca. Puede que el café que prepare sea un moka, un cappuccino, un expreso, un cortado, un americano, un vaso de agua o un sándwich de morcón. Esto depende de la versión de la cafetera, de la situación dentro de la cocina, de sus ajustes, del usuario, de la casa donde se aloje, de cómo se pida o de las fases de la luna.

Otro problema de la cafetera es que, en caso de que algo no funcione, puede que el mensaje esté en inglés, en italiano, en klingon, que no haya mensaje alguno, que la cafetera deje de funcionar, que sólo eche azúcar o que explote. También puede que no ocurra nada en absoluto. Todo esto depende de las condiciones escritas anteriormente descritas, las cuales pueden cambiar (y cambiarán) en cualquier momento.

JavaScript

Todas las semanas hay una tecnología nueva para hacer este tipo de café, que es el favorito de la gente guay. El café es precioso. El problema es que todas las cafeteras se usan de forma distinta. Al menos en los hogares domésticos es prácticamente imposible hacerse daño al usarlas.

SQL, HTML, CSS, YAML…

Aunque a veces se hable de ellos como cafés resulta que no lo son, son líquidos para diversos usos, como desengrasantes domésticos, líquido para circuitos de freno hidráulicos o aceites para la piel. Algunos se pueden beber sin mayores consecuencias que un dolor de estómago, otros causan la muerte instantánea.

Etcétera

¡Gracias por llegar hasta aquí! Como siempre, agradezco cualquier comentario aportación, corrección o insulto en la sección de comentarios, aunque advierto que, en pro del humor (o lo contrario) me he permitido la licencia de usar hipérboles o chascarrillos que no son totalmente certeros. ¡Disfrutad! (si podéis)

Agradecimientos a mis amigos programadores que me han asesorado para escribir esta entrada:

• El puntero loco
• La función vietnamita
• La variable glotona
• Don Entrada y Don Salida
• El listener sátiro
• El paquete humano
• Y, por último, el señor Por-qué-no-compila-esto-odio-mi-trabajo-ah-era-este-punto-y-coma.

La entrada Cómo hacer café con distintos lenguajes de programación se publicó primero en Detrás del último no va nadie.

Existieron versiones en un mogollón de plataformas, desde el Macintosh (la original) hasta GameBoy Advance, pero mi favorita es la de MS-DOS y es sobre la que trata este artículo. Hay dos ficheros interesantes: el ejecutable (SC2000.EXE) y el fichero de datos (SC2000.DAT). Lamentablemente, la versión de Windows no salió en español, y la versión Network Edition que permitía juego en red funciona fatal (y también está sólo en inglés).

SC2000.EXE

El ejecutable del juego no parece contener muchos recursos, pero sí que tiene algunos textos de la interfaz. En el editor hexadecimal se pueden ver algunas etiquetas de ancho fijo.

También hay algunos de ancho variable que corresponden a más etiquetas de la interfaz. También parece haber algunos ficheros empotrados, en los que por ejemplo se describen los escenarios del juego.

Por ahora desemsamblar un ejecutable de hace cerca de 25 años no está entre mis especialidades, por lo que no he averiguado gran cosa. Los punteros no son evidentes en el ejecutable, por lo que dejado ahí. Pero la chicha está en el fichero de datos.

SC2000.dat

Este es el principal fichero de datos del juego. No tiene cabecera, pero un vistacillo en el editor hexadecimal arroja bastantes pistas sobre su estructura.

Resulta que desde el byte 0, lo primero que nos encontramos son bloques de 16 bytes que describen los ficheros contenidos en el paquete. El primer campo es evidente: son 12 bytes con el nombre del archivo (8 + 3 caracteres de los ficheros de MS-DOS más el punto). Si sobran caracteres, el resto de bytes son 00h.

Los cuatro restantes no tanto, pero resulta que el juego es original de Macintosh, que en aquella época usaba procesadores Motorola. Estos procesadores, a diferencia de los Intel, son Little-Endian (siendo Big-Endian los de Intel). Esto significa que los números de más de un byte se guardan ordenados del byte menos significativo al más significativo, en lugar del ordenamiento «natural». Se trata, pues, de un entero de 32 bits sin signo en formato Little-Endian en el que se codifica el offset (desplazamiento) del fichero cuyo nombre está justo antes.

La idea feliz sobre el offset se la debo a Brett Lajzer, un ingeniero de software de Albany que empezó antes que yo a investigar este fichero. Le escribí para intercambiar información y me advirtió sobre este punto, que no llegó a describir en su artículo.

El desempaquetamiento y empaquetamiento, sabido esto, resulta relativamente sencillo. He escrito un pequeño programa en Java que realiza esta operación:

package sce2000;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

import org.apache.commons.io.FileUtils;

public class Sce2000 {
	
	public static final String SC2000DAT = "G:\\dos\\sce2000\\sc2000.dat";
	public static final int NUMFILES = 399;
	
	public static class Filestrut implements Serializable {
		private static final long serialVersionUID = 1L;
		public String filename;
		public int offset;
		public int targetOffset;
	}

	public static void main(String[] args) throws IOException, ClassNotFoundException {
		
		if (args.length == 0) {
			info();
		} else if ("x".equals(args[0])) {
			extract();
		} else if ("c".equals(args[0])) {
			create();
		} else {
			info();
		}

	}
	
	public static void info() {
		System.out.println("Usage: x to eXtract or c to Create (after eXtract) + sc2000.dat file");
	}

	public static void create() throws IOException, ClassNotFoundException {
		
		File sc2000dat = new File(SC2000DAT);
		File metafile = new File(SC2000DAT + "!/meta");
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream(metafile));
		List<Filestrut> files = (List<Filestrut>) ois.readObject();
		
		List<Byte> targetFile = new ArrayList<Byte>();

		for (Filestrut file : files) {
			byte[] fileNameBytes = file.filename.getBytes(StandardCharsets.US_ASCII);
			for (Byte myByte : fileNameBytes) {
				targetFile.add(myByte);
			}
			for (int i = 0; i < 16 - fileNameBytes.length; i++) {
				targetFile.add((byte) 0);
			}
			//sourceFile.length();
		}
		
		int i = 0;
		for (Filestrut file : files) {
			byte[] binary = Files.readAllBytes(Paths.get(SC2000DAT + "!/" + file.filename));
			int fileOffset = targetFile.size();
			for (Byte myByte : binary) {
				targetFile.add(myByte);
			}
			int filePointer = 12 + (16 * i);
			
			byte[] offsetBytes = fromInt(fileOffset);
			targetFile.set(filePointer, offsetBytes[0]);
			targetFile.set(filePointer + 1, offsetBytes[1]);
			targetFile.set(filePointer + 2, offsetBytes[2]);
			targetFile.set(filePointer + 3, offsetBytes[3]);
			
			i++;
		}
		
		byte[] binaryFile = new byte[targetFile.size()];
		for (i = 0; i < targetFile.size(); i++) {
			binaryFile[i] = targetFile.get(i);
		}
		
		FileUtils.writeByteArrayToFile(sc2000dat, binaryFile);

		
		System.out.println();
		
	}
		

	public static void extract() throws IOException {
		
		Path sc2000dat = Paths.get(SC2000DAT);
		byte[] data = Files.readAllBytes(sc2000dat);
		
		int vector = 0;
		List<Filestrut> files = new ArrayList<Filestrut>();
		for (int i = 0; i < NUMFILES; i++) {
			
			Filestrut currfile = new Filestrut();
			
			currfile.filename =  convertFilename(Arrays.copyOfRange(data, vector, vector + 12));
			vector += 12;
			
			currfile.offset = fromByteArray(Arrays.copyOfRange(data, vector, vector + 4));
			vector += 4;
			
			System.out.println("Found file " + currfile.filename + " at " + currfile.offset);
			
			files.add(currfile);
			
		}
		
		File dir = new File(SC2000DAT + "!");
		if (dir.exists()) {
			FileUtils.deleteDirectory(dir);
		}
		
		dir.mkdir();
		
		Iterator<Filestrut> fileIt = files.iterator();
		
		Filestrut file = fileIt.next();
		Filestrut fileNext = null;
		
		boolean stop = false;
		while (!stop) {
			
			File extracted = new File(SC2000DAT + "!/" + file.filename);
			
			int init = file.offset;
			int end = -1;
			if (fileIt.hasNext()) {
				fileNext = fileIt.next();
				end = fileNext.offset;
			} else {
				end = data.length;
				stop = true;
			}

			System.out.println("Writing: " + extracted.getAbsolutePath());
			FileUtils.writeByteArrayToFile(extracted, Arrays.copyOfRange(data, init, end));
			
			file = fileNext;
			
		}
		
		File metafile = new File(SC2000DAT + "!/meta");
		
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(metafile));
		oos.writeObject(files);
		oos.close();
		
		System.out.println("OK!");
	}
	
	public static byte[] fromInt(int number) {
		byte[] bytes = ByteBuffer.allocate(4).putInt(number).array();
		swapEndianess(bytes);
		return bytes;
	}
	
	public static void swapEndianess(byte [] bytes) {
		byte temp1 = bytes[0];
		byte temp2 = bytes[1];
		bytes[0] = bytes[3];
		bytes[1] = bytes[2];
		bytes[2] = temp2;
		bytes[3] = temp1;
	}
	
	public static int fromByteArray(byte[] bytes) {
		// Change endianness
		swapEndianess(bytes);
		return ByteBuffer.wrap(bytes).getInt();
	}
	
	public static String convertFilename(byte[] data) {
	    StringBuilder sb = new StringBuilder(data.length);
	    for (int i = 0; i < data.length; ++ i) {
	        if (data[i] < 0) { 
	        	throw new IllegalArgumentException();
	        }
	        if (data[i] == 0) {
	        	break;
	        }
	        sb.append((char) data[i]);
	    }
	    return sb.toString();
	}


}

Este programa está hecho rápidamente y no está precisamente optimizado. He podido permitirme cargar o gestionar los ficheros enteros en memoria ya que el tamaño del DAT completo es de pocos megas. Además, tiene hardcodeado (incrustado en el código) el número de ficheros y la ruta al DAT. Mejorarlo lo dejo de deberes para el lector.

¿Por qué en Java? No es un lenguaje muy indicado para manejar binarios, y desde luego el no disponer de tipos sin signo no ayuda. Sencillamente lo hice en Java y no en C porque es el lenguaje con el que me gano la vida y con el que tengo más soltura, y llevo casi 8 años sin programar nada en C.

Usando el código anterior (o cualquier otro que el intrépido lector codifique) podemos ver los siguientes tipos de fichero:

• RAW, con imágenes sin cabecera.
• PAL, con la paleta de colores que se usa en el juego.
• Ficheros de texto, algunos TXT* sin extensión y otros con extensión RAW.
• XMI, con la música.
• VOC, con los efectos de sonido.
• FNT, con las fuentes del juego.
• Etc, etc…

Hablemos un poco de cada uno.

Ficheros VOC

Los efectos sonoros del juego se almacenan en ficheros VOC. Bueno, ésta es fácil, ya que se trata de un formato no común pero ampliamente soportado por muchos editores de audio. Es un formato de Creative Labs que almacena principalmente audio codificado en PCM y ADPCM, aunque de forma puntual ha servido para otras codificaciones.

Se puede abrir y guardar con Adobe Audition perfectamente. La frecuencia de muestreo varía de un fichero a otro, pero la reconoce sin problemas.

Ficheros de texto

Existen tres tipos de ficheros de texto. Los más sencillos son los ficheros in extensión TXT*, siendo * un número. Se pueden abrir con el Notepad++ y editar sin problemas.

Bueno, no del todo. La codificación no es ASCII, ni ANSI, ni tampoco UNICODE porque aún no era común. ¿Cuál entonces? Pues, dado que el juego se programó para Macintosh, la codificación es Macintosh Roman. Esto es un problema porque Notepad++ no da soporte a esta codificación. Está pedido, pero no parece prioritario, por lo que si quieres editar cómodamente hay que convertirlo antes.

Otros ficheros de texto son los STR*.RAW y *.RAW, siendo * un número. Su formato no es tan bonito.

Al parecer el primer byte es siempre 00h, y el segundo parece almacenar el número de cadenas que hay en el texto. Las cadenas no son como las de C: en lugar de ser cadenas terminadas en 00h son cadenas precedidas de su longitud, codificada en 1 byte. Lo ideal para editar estos ficheros sería construir una utilidad al efecto, pero parece más que viable.

El tercer tipo de ficheros corresponde únicamente al fichero PPDT1003.RAW, que contiene una de las características más divertidas de SimCity 2000: los periódicos.

Lamentablemente este formato es una pesadilla. Comienza con un diccionario de términos separados por 00h, y luego tiene una ristra de textos para generar los artículos. Esta codificación personalizada es de ancho variable (por ejemplo, 5C96h representa la letra ñ) y usa los términos definidos anteriormente, y naturalmente contiene marcadores de posición para los términos del artículo. Éstos se generaban proceduralmente, y un artículo que denunciaba la desaparición de un animal tenía como protagonista un gato o un rinoceronte, de la señora Dwight o del señor Martínez.

Antiguamente existían editores, como Thingy, que daban soporte a ficheros TBL. En ellos se podía especificar un diccionario de términos (o toda una codificación) y editarlos «cómodamente». De todas formas sólo nos servirá si mantenemos el ancho de las cadenas, así que habría que descifrar el número que las precede (y su codificación) para poder editarlas como es debido. Parece bastante complicado, por lo que lo he dejado para mejor ocasión.

Editado: Al parecer, los punteros para los textos de los periódicos están en el fichero PPDT1004.RAW. Consisten en conjuntos de 4 bytes en Big-Endian. Menudo lío.

Ficheros de imagen

Con la excepción de algunos ficheros usados para texto (descritos en el apartado anterior), los RAW son las imágenes usadas en la interfaz del juego. Los edificios y otros elementos están en unos ficheros DAT que quedan fuera del ámbito de este documento ya que se pueden editar mucho más fácilmente con el SimCity Urban Renewal Kit (SCURK), una herramienta que se incluía con versiones posteriores para editar ciudades «a manubrio» y modificar el aspecto de los edificios.

En lo que nos ocupa: estos ficheros RAW son mapas de bits con 8 bits por pixel (256 colores) con una cabecera de 4 bytes. No parece haber información sobre la resolución o los colores, pero para esto último existe un fichero, MINE.PAL, que especifica la paleta que usa el juego. No es un fichero de Microsoft Palette, como sugiere su extensión, sino una paleta en bruto tipo ACT. Casualmente, es el formato que usa preferentemente Adobe Photoshop.

En cuanto a la resolución, no parece haber forma fácil de averiguarla simplemente mirando el archivo. Lo más sencillo es factorizar el número (menos 4 bytes) en dos múltiplos, cosa en la que el propio Photoshop nos puede asistir al abrir el archivo, al menos en versiones modernas. Por el nombre del fichero podemos más o menos discernir para qué sirve si no tenemos una idea, y si hemos jugado al juego (¡deberías!) podemos conocer más o menos su relación altura/anchura. Algunas son fáciles: la pantalla de título (TITLE.RAW) es una imagen de 640×480 pixeles. Todas las imágenes usan la misma paleta, dado que el juego maneja 256 colores en todo momento.

Para editar los ficheros con color indexado en 8 bits siempre uso la misma técnica: las convierto a color de 24 bits + 8 de canal alfa y las edito cómodamente. Después, antes de salvarlas, las cambio a color indexado cargando la paleta del juego nuevamente. Sorprendentemente, salvando en formato Adobe RAW el juego las lee bien, dado que Photoshop permite conservar los 4 bytes de la cabecera. ¡Qué alivio!

Nota: ni que decir tiene que este formato RAW no tiene nada que ver con los formatos de datos en bruto de las cámaras digitales.

Ficheros XMI

En los ficheros XMI se almacena cada una de las músicas del juego. El formato XMI soporta varias canciones por fichero, pero no parece ser el caso. La estructura es diferente a los MIDI, pero hacen prácticamenente lo mismo: almacenar notas y eventos musicales. Se pueden reproducir en Windows cómodamente con Foobar2000, y es posible convertir ficheros MIDI a XMI (y viceversa). MIDIPLEX parece hacerlo desde Windows, pero no se ofrecen binarios compilados y lo hice con herramientas más antiguas para MS-DOS, usando DOSBox. De todas formas, el propio SimCity 2000 necesitará DOSBox para funcionar en sistemas modernos.

Ficheros FNT

Presumiblemente las tipografías del juego, al juzgar por los nombres, los números que los acompañan y la extensión. No parece que sea mismo formato de fuentes en mapa de bits FNT para Windows, por lo que no he podido abrirlo con ningún editor.

Otros

Otros ficheros presentes en el paquete son fuentes General Midi para chipsets OPL, diversos índices y cabeceras para los conjuntos de gráficos de edificios… nada demasiado interesante para modificar el juego. Todo lo demás parece estar incrustado en el propio ejecutable, algo que está fuera de mi alcance.

En Windows

Como apunte, la versión de Windows es mucho más fácil de modificar. Los recursos de imagen y sonido están presentes en formato WAV y BMP, que son mucho menos oscuros que los descritos anteriormente. El resto de recursos se encuentra incrustado en el ejecutable del juego, pero con un editor de recursos se pueden extraer y modificar sin problemas, y en formatos más accesibles que los de MS-DOS. (Yo uso Resource Hacker, que es gratis y funciona bastante bien)

Los periódicos, sin embargo, parecen conservar el calamitoso formato de la versión de MS-DOS. Una pena porque hubiera sido interesante traducir esta versión al español.

Pues hasta aquí. Espero que haya sido muy educativo todo, aunque tras tanto tiempo no parece que el juego suscite mucho interés para ser modificado de ninguna forma. Siempre he querido tocar el juego y hacer mi propia versión, SimCity efecto 2000, un poco más gamberra, pero otra vez será.

La entrada Desmontando SimCity 2000 se publicó primero en Detrás del último no va nadie.

Con este pequeño artículo quisiera mostrar las demos que más me han sorprendido por romper las barreras que creíamos impenetrables, por hacer lo común a través de lo imposible o simplemente porque me parecen técnicamente relevantes.

The Timeless // Mercury

Algunas categorías populares en la demoscene son las que limitan el tamaño del producto final (no así de la memoria o disco que pueden consumir al ejecutarse, ojo). 64k era el tamaño de la memoria de algunos ordenadores de 8bit como el Commodore 64 o muchos Amstrad CPC, y ahora es una de las más reñidas en la demoscene de PC. Una de las más sonadas es The Timeles, de 2014. Puedes ver el vídeo o descargarla.

El simple hecho de entender el reto técnico que supone meter todo esto en 64k ya es ajeno a legos y principiantes. Entender cómo se hizo ya es un reto para los más avezados en la tecnología de la programación, y llegar a hacerlo es algo sólo alcanzable a los grandes maestros. Otra de las demos del grupo, Luma, es menos espectacular visualmente pero me encanta su banda sonora. Hay demos en esta categoría a patadas, y aún así no dejan de asombrarme. Algunas incluso tienen parte cantada (NSFW).

8088 MPH // Hornet + CRTC + DESiRE

Una de las demos más sonadas de 2015 (de la cual escribí en Pixfans) fue 8088 MPH, que diríamos que compitió en su propia categoría. Se ejecuta sobre el IBM PC original, el modelo 5150 que apareció en verano de 1981. Las especificaciones donde funciona esta demo son de risa: 640 KB de RAM, un procesador 8088 a 4,77 MHz (y gracias, porque sólo podía leer un byte por cada ciclo de reloj) y un chipset gráfico CGA que daba 4 colores. (de unas paletas predefinidas espantosas, y a una resolución exageradamente pobre)

Por si hacer una demo artísticamente interesante en un hardware así no fuera suficiente, la tecnología empleada es impresionante. El sonido es muy destacable, sobre todo teniendo en cuenta que el sonido del ordenador estaba limitado a un pequeño buzzer de 1 bit. Pero lo impresionante es conseguir la cifra de 1024 colores en pantalla, siendo el primer programa en conseguirlo en CGA. Para quien esté interesado, hay un post técnico muy detallado acerca de cómo se ha logrado tal hazaña. También hay otro explicado de forma gráfica. Se puede bajar de Pouët, aunque sin el hardware apropiado es muy difícil de verla correctamente, sólo con builds muy específicos de PCem es posible (y sólo parcialmente) emularla.

Elevated // Rgba & TBC

Las demos de 64k son un logro impresionante. ¿Qué tal si subimos más aún el listón? ¿Qué tal, digamos, 4k? Este es el trabajo de unas mentes que sólo puedo calificar como brillantes. Como dicen por ahí: enséñale este vídeo a alguien aficionado a la informática y quedará más o menos indiferente. Dile lo que ocupa el programa y tendrá que verlo con sus propios ojos.

Demos de 4k haylas, pero ninguna tan impresionante ni de lejos como ésta.

Vicious Sid // Soundemon, Mixer, The Human Codemachine

Vicious Sid es una demo interesante. Visualmente no es de las más impresionantes, pero su sonido nos hace olvidar que se ejecuta en un Commodore 64. Ya con Fanta in Space consiguieron lo imposible al mezclar samples digitales y sonido sintetizado con filtros y efectos, repitiendo hazaña en la presente con resultado mejores, si cabe. Pero lo verdaderamente espectacular, y que se gana a pulso el título de «intro loca» es la parte «NO SID».

No tengo constancia de que esto se haya hecho antes, ni en el Commodore 64 ni en ningún otro ordenador. Sonido digital… SIN USAR EL CHIP DE AUDIO. ¿Pero qué cojones? No, el microprocesador no tiene una salida analógica (caso del Z80) ni existe un chip no documentado. El truco es ingenioso: programar el chip de vídeo de tal formas que sus interferencias en el circuito de audio produzcan un sonido leve, pero modelable. Completamente de locos. Completamente de genios. Se dice que el músico  Aphex Twin hizo esto con un ordenador anterior, pero hasta ahora no he podido confirmarlo.

Editado: El Z80 no tiene una salida analógica. En Spectrum lo que se hace es una señal modulada por pulsos por el Z80 y transformada a una forma de onda por el chip ULA.

Robotic Liberation // PWP

La demoscene parece nutrirse, de forma muy paradójica, con límites. Los límites en tamaño son relativamente nuevos, originalmente los límites eran el propio hardware. Es por eso por lo que esta demo es impresionante, ya que funciona en un ordenador VIC-20, con sólo 5120 bytes de memoria RAM disponibles para el programador, y no hablemos de la CPU, gráficos y sonido que poseía dicho computador…

Esta máquina de 8 bits, anterior al Commodore 64 apenas pudo articular algún que otro juego medio cojo, ha aprendido incluso a cantar (más o menos). Hasta el hardware más pequeño (literalmente) como una calculadora programable de bolsillo es capaz de hacer funcionar demos, como DXM // Imation funcionando en una TI-82.

.kkrieger // .theprodukkt

Bueno, esto no es exactamente una demo, sino un juego de PC. No obstante uno con mucha relación con la demoscene, creado por los veteranos .theprodukkt. No es particularmente jugable, su sonido espectacular y no tiene un desarrollo demasiado inspirado. ¿Qué tiene de destacable entonces? Que ocupa 96 Kb. Demencial.

Hacer una demo en un tamaño ridículo es digno de un maestro. Hacer un juego como éste en 96 Kb es de locos. Por supuesto puede descargarse y probarlo, debería funcionar razonablemente bien en ordenadores modernos.

A mind is born // Linus Åkesson

La barrera de los 4k es algo ridículo. Este artículo, sin las imágenes, es bastante más grande que eso. Cuatro mil caracteres, y eso usando una codificación ASCII. Es difícil hasta imaginar que sea posible hacer demos interesantes en tan poco espacio. Pero hay quien una vez pensó: ¿y si pusiéramos un límite aún más restrictivo? ¿cómo sería hacer demos en 256 bytes? Sí, 256 bytes. Apenas dos frases.

Es bastante difícil de creer. El payo, en su página web, da una explicación extensiva de cómo consiguió esta proeza, pero da igual porque no he entendido un pimiento. Hay más demos en 256 bytes, algunas bastante impresionantes, pero ninguna con este sonido. Por ahora, creo que es bastante justo decir que éste es el límite a batir. Un humilde servidor cree que no hay nada que se le parezca en este momento.

Y aún hay más

La cantidad de talento que se ha vertido en la demoscene es prácticamente ilimitada. Hay tantas demos buenas en cada categoría que es imposible no quedarse con algunas otras más. Si bien no creo que lleguen al nivel o a la locura de las anteriores, vale la pena echarles un vistazo. Los enlaces nos llevarán a su página de Pouët, el portal dedicado a la demoscene, en el cual hay siempre descargas y enlaces para verlo en Youtube.

• debris. // farbrausch: Demo de temática urbana en 177 kb que, pese a no caer en ninguna categoría, dio el pelotazo en 2007 por su excelente apartado artístico, sin igual en las demos con contenido procedural. Imprescindible.
• State of the Art // Spaceballs: Una de las demos más conocidas, y no sin motivo. Este disquette para Amiga 500 hará que creas que los 90 han vuelto. Si has sido joven en esa década su estética te va a flipar. Otra de las demos del grupo, 9 fingers, si bien no es tan original es casi mejor aún.
• Starstruck // The Black Lotus: Probablemente la demo más impresionante hecha para el chipset AGA de Amiga. No sólo impresiona su apartado artístico, también hace un uso de las 3D excelente y tiene un gran sonido.
• Second Reality // Future Crew: No necesita presentación. Su música es, probablemente, el fichero musical para tracker más oído y aplaudido, y esta veterana demo (¡1993!) sigue siendo de inspiración para muchos seguidores de la Demoscene.
• Blastersound BBStro // Iguana: Una humilde presentación de una BBS de shareware y demos de principios de los ’90. El efecto de nieve no es nuevo, y desde luego no es el mejor aprovechado, pero junto con su música para OPL2 fue bastante popular en España.
• 1995 // Kewlers: De nuevo una demo cuya tecnología no es particularmente interesante, aunque el raytracing en tiempo real siempre es de agradecer. Su música y sus efectos visuales, sin embargo, han hecho que sea una de las favoritas de los aficionados.

Me he dejado muchas demos impresionantes en el tintero, así como otras categorías o sistemas que quizá no sean tan populares. Sin duda da para muchos artículos, pero hasta aquí lo que más me ha sorprendido. No sé qué depara el futuro de la demoscene, si sonido digital en una tostadora o gráficos 3D en un cepillo de dientes…

La entrada Demos locas se publicó primero en Detrás del último no va nadie.

Una de las cosas que más me ha roto la cabeza es optimizar queries con muchos JOINs. Recientemente, un informe requería una consulta con 25 JOINs, y al tratar de ejecutarla nuestro servidor prácticamente lloraba que por favor parásemos. Sin embargo, me he topado (al decir verdad, fue mi jefe) con una variable de configuración muy interesante a la hora de encarar este problema.

optimizer_search_depth

The maximum depth of search performed by the query optimizer. Values larger than the number of relations in a query result in better query plans, but take longer to generate an execution plan for a query. Values smaller than the number of relations in a query return an execution plan quicker, but the resulting plan may be far from being optimal. If set to 0, the system automatically picks a reasonable vaue.

Tan fácil como establecer esta variable de configuración a 0, las queries han pasado de tardar años a pocos segundos. En concreto, queries con unos 10 JOINs pasan de tardar 40 segundos a tardar 2. Haciendo profiling parece que casi todo el tiempo se emplea en generar un plan de ejecución pero, vaya si vale la pena. (la query original nunca conseguí que acabase, tuve que quitarle elementos para ir probándola)

Esta configuración se realiza tanto a nivel de sesión como de servidor, por lo que parece una buena opción a probar si hemos terminado de tirarnos de los pelos optimizando la query. Es probable que un DB admin promedio conozca estos trucos, pero a mí me sorprende lo «escondida» que está.

La entrada Consultas MySQL con muchos JOINs se publicó primero en Detrás del último no va nadie.

Aunque hay un montón de soluciones disponibles, me he propuesto hacer un pequeño simulador de navegador (un webcrawler) en Java, que permita fácilmente y de forma sencilla implementar tareas. Le he puesto a la criatura Hoverkraft. Dejo por aquí el código fuente.

package net.krusher.hoverkraft;

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Serializable;
import java.net.HttpCookie;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;

/**
 * Hoverkraft - Das Web Boot
 * @author Axelei
 *
 */
public class Hoverkraft implements Serializable {
	
	/**
	 * 
	 */
	private static final long serialVersionUID = -4846381367781986634L;
	public static final String USER_AGENT = " Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.114 Safari/537.36";
	public static final String ACCEPT = "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8";
	public static final String ACCEPT_LANGUAGE = "es,en-US;q=0.8,en;q=0.6";
	public static final int MAX_TRIES = 5;
	private static final String LINE_FEED = "\r\n";
	
	public enum Method {
		GET, POST
	}
	
	private URL url;
	private HttpURLConnection connection;
	private String content;
	private int code = -1;
	private Method method;
	private String referer;
	private Map<String, String> postVars = new HashMap<String, String>();
	private Map<String, HttpCookie> cookies = new HashMap<String, HttpCookie>();
	private Map<String, File> uploads = new HashMap<String, File>();
	
	public Document getXml() {
		return Jsoup.parse(content);
	}
	
	public Hoverkraft() {
		super();
	}

	/**
	 * Set sail to a destination
	 * @param url
	 * @throws MalformedURLException
	 */
	public void go(String url, Method method) throws MalformedURLException {
		this.url = new URL(url);
		this.method = method;
	}
	
	public void go(String url) throws MalformedURLException {
		go(url, Method.GET);
	}
	
	public void disconnect() {
		connection.disconnect();
	}
	
	public void setPostVars(Map<String, String> vars) {
		this.postVars = vars;
	}
	
	public void setUploads(Map<String, File> uploads) {
		this.uploads = uploads;
	}
	
	/**
	 * Executes the web petition
	 * @throws IOException 
	 */
	public void execute() throws IOException {
		
		boolean redirect = false;
		int tries = 0;
		
		do {
			connection = (HttpURLConnection) url.openConnection();
			setProperties(connection);
			
			connection.connect();
			
			code = connection.getResponseCode();
			
			// Redirecciones

			if (code != HttpURLConnection.HTTP_OK) {
				if (code == HttpURLConnection.HTTP_MOVED_TEMP
					|| code == HttpURLConnection.HTTP_MOVED_PERM
					|| code == HttpURLConnection.HTTP_SEE_OTHER
					)
				redirect = true;
			}
		 
			if (redirect) {
				go(connection.getHeaderField("Location"), method);
			}
		} while (redirect == true && tries++ < MAX_TRIES);
		
		InputStream is = (InputStream) connection.getContent();
		content = stream2string(is);
		
		referer = url.toString();

		Map<String, List<String>> headers = connection.getHeaderFields();
		
		/**
		 * Obtener cookies
		 */
		if (headers.containsKey("Set-Cookie")) {
			List<String> cookiesObtenidas = headers.get("Set-Cookie");
			
			for (String cookie : cookiesObtenidas) {
				List<HttpCookie> cookiesParseadas = HttpCookie.parse(cookie);
				for (HttpCookie cookieParseada : cookiesParseadas) {
					
					if (cookies.containsKey(cookieParseada.getName())) {
						cookies.remove(cookieParseada.getName());
					}
					cookies.put(cookieParseada.getName(), cookieParseada);
				}
			}
		}
	}
	
	private void setProperties(HttpURLConnection connection) throws IOException {
		
		// Cabeceras
		connection.setRequestProperty("user-agent", USER_AGENT);
		connection.setRequestProperty("accept", ACCEPT);
		connection.setRequestProperty("accept-language", ACCEPT_LANGUAGE);
		if (referer != null) {
			connection.setRequestProperty("referer", referer);
		}
		connection.setRequestMethod(method.toString());
		
		// Cookies
		for (HttpCookie cookie : cookies.values()) {
			connection.setRequestProperty("Cookie", cookie.toString());
		}
		
		connection.setDoOutput(false);
		
		// Variables Post y demás
		if (method == Method.POST && !postVars.isEmpty() && uploads.isEmpty()) {
			
			connection.setDoOutput(true);
			StringBuffer urlParameters = new StringBuffer();
			
			for (Entry<String, String> var : postVars.entrySet()) {
				urlParameters.append(URLEncoder.encode(var.getKey(), "UTF-8") + "=" + URLEncoder.encode(var.getValue(), "UTF-8") + "&");
			}
			
			if (urlParameters.charAt(urlParameters.length() - 1) == '&') {
				urlParameters.deleteCharAt(urlParameters.length() - 1);
			}
			postVars.clear();
			
			connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded"); 
			connection.setRequestProperty("charset", "utf-8");
			connection.setRequestProperty("Content-Length", Integer.toString(urlParameters.toString().getBytes().length));
			
			DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
			wr.writeBytes(urlParameters.toString());
			wr.flush();
			wr.close();
		}
		
		if (method == Method.POST && !uploads.isEmpty()) {

			String boundary = "===" + System.currentTimeMillis() + "===";

			connection.setUseCaches(false);
			connection.setDoOutput(true);
			connection.setDoInput(true);

			connection.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
			connection.setRequestProperty("charset", "UTF-8");
			
			OutputStream outputStream = connection.getOutputStream();
			PrintWriter writer = new PrintWriter(new OutputStreamWriter(outputStream, "UTF-8"), true);

			for (Entry<String, String> var : postVars.entrySet()) {

				writer.append("--" + boundary).append(LINE_FEED);
		        writer.append("Content-Disposition: form-data; name=\"" + var.getKey() + "\"").append(LINE_FEED);
		        writer.append("Content-Type: text/plain; charset=UTF-8").append(LINE_FEED);
		        writer.append(LINE_FEED);
		        writer.append(var.getValue()).append(LINE_FEED);
		        writer.flush();
			}
			
			for (Entry<String, File> fichero : uploads.entrySet()) {
		        String fileName = fichero.getValue().getName();
		        writer.append("--" + boundary).append(LINE_FEED);
		        writer.append("Content-Disposition: form-data; name=\"" + fichero.getKey() + "\"; filename=\"" + fileName + "\"").append(LINE_FEED);
		        writer.append("Content-Type: " + URLConnection.guessContentTypeFromName(fileName)).append(LINE_FEED);
		        writer.append("Content-Transfer-Encoding: binary").append(LINE_FEED);
		        writer.append(LINE_FEED);
		        writer.flush();
		        
		        FileInputStream inputStream = new FileInputStream(fichero.getValue());
		        byte[] buffer = new byte[4096];
		        int bytesRead = -1;
		        while ((bytesRead = inputStream.read(buffer)) != -1) {
		            outputStream.write(buffer, 0, bytesRead);
		        }
		        outputStream.flush();
		        inputStream.close();
		         
		        writer.append(LINE_FEED);
		        writer.flush();   
			}
			
			writer.append(LINE_FEED).flush();
	        writer.append("--" + boundary + "--").append(LINE_FEED);
	        writer.close();

			postVars.clear();
			uploads.clear();
			
		}

		
	}
	
	/**
	 * Resets the browser
	 */
	public void reset() {
		url = null;
		connection = null;
		content = null;
		code = -1;
		referer = null;
		postVars.clear();
		cookies.clear();
		uploads.clear();
	}
	
	/**
	 * Get contents of last execution
	 * @return
	 */
	public String getContent() {
		return content;
	}
	
	/**
	 * Gets HTTP code of last execution
	 * @return
	 */
	public int getCode() {
		return code;
	}
	
	private static String stream2string(InputStream is) {
		String salida = "";
		Scanner scanner = new Scanner(is);
		scanner.useDelimiter("\\A");
		while (scanner.hasNext()) {
			salida += scanner.next();
		}
		scanner.close();
		return salida;
	}
}

Este código depende de la librería jsoup, que naturalmente está disponible como software libre por ahí y funciona desde Maven perfectamente.

Por supuesto estaría encantado de poder leer cualquier mejora o crítica. ¡Comenta, comenta!

La entrada Webcrawler java Hoverkraft se publicó primero en Detrás del último no va nadie.

¿Cómo hacer, pues, que el valor de un control se enlace directamente con un objeto? Pues JSF provee para ello los converters. Bueno, permite que tú los programes, claro. Tampoco PrimeFaces, que es mi librería de componentes de eleción, incluye estos conversores. Así pues, he programado uno pequeño para los SelectOneMenu, los menús desplegables asemejables a comboboxes. Lo dejo aquí para referencia mía y por si puede servirle de algo a alguien.

/**
 * The Class SelectOneMenuConverter.
 */
@FacesConverter("selectOneMenuConverter")
public class SelectOneMenuConverter implements Converter {

	@Override
	public Object getAsObject(final FacesContext arg0, final UIComponent arg1, final String objectString) {
		if (objectString == null) {
			return null;
		}

		return fromSelect(arg1, objectString);
	}

	/**
	 * Serialize.
	 *
	 * @param object
	 *            the object
	 * @return the string
	 */
	private String serialize(final Object object) {
		if (object == null) {
			return null;
		}
		return object.getClass() + "@" + object.hashCode();
	}

	/**
	 * From select.
	 *
	 * @param currentcomponent
	 *            the currentcomponent
	 * @param objectString
	 *            the object string
	 * @return the object
	 */
	private Object fromSelect(final UIComponent currentcomponent, final String objectString) {

		if (currentcomponent.getClass() == UISelectItem.class) {
			final UISelectItem item = (UISelectItem) currentcomponent;
			final Object value = item.getValue();
			if (objectString.equals(serialize(value))) {
				return value;
			}
		}

		if (currentcomponent.getClass() == UISelectItems.class) {
			final UISelectItems items = (UISelectItems) currentcomponent;
			final List<Object> elements = (List<Object>) items.getValue();
			for (final Object element : elements) {
				if (objectString.equals(serialize(element))) {
					return element;
				}
			}
		}


		if (!currentcomponent.getChildren().isEmpty()) {
			for (final UIComponent component : currentcomponent.getChildren()) {
				final Object result = fromSelect(component, objectString);
				if (result != null) {
					return result;
				}
			}
		}
		return null;
	}

	@Override
	public String getAsString(final FacesContext arg0, final UIComponent arg1, final Object object) {
		return serialize(object);
	}

}

Básicamente, convierte cualquier objeto en una cadena codificada con el nombre de la clase y el hash. A la hora de recuperarlo, accede a la colección enlazada al valor de nuestro desplegable para buscar el objeto adecuado y así devolverlo. Ciertamente depende de que el método hashCode esté bien codificado y devuelva (casi con toda seguridad) valores distintos para objetos distintos, pero es una forma rápida de hacerlo y que funcionaría en casi toda circunstancia. Usarlo es tan fácil como:

<p:selectOneMenu id="utiSelector" converter="selectOneMenuConverter" value="#{miBean.miObjeto}">
	<f:selectItem itemValue="#{null}" noSelectionOption="true" />
	<f:selectItems value="#{miBean.listaObjetos}" var="objeto" itemValue="#{objeto}" itemLabel="#{objeto.etiqueta}" />
</p:selectOneMenu>

Algo que suelo hacer en los DTO o entidades es que el hashcode sea la clave, o el hashcode de ésta si no es numérica. Pero eso ya es otra historia.

La entrada Converter JSF para SelectOneMenu se publicó primero en Detrás del último no va nadie.