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.

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.