Servidor privado de World of Warcraft


No sé qué tendrá el World of Warcraft que siempre me ha apetecido volver. Lo intenté retomar en un par de ocasiones, aunque es cierto que ya no dispongo de tanto tiempo para disfrutarlo como la primera vez que lo jugué.
Por el camino, los servidores privados en los que jugaba han desaparecido y el soporte de Mac parece un tanto abandonado, pero aún existe una posibilidad que cualquiera puede aprovechar y que soporta hasta la versión 3.3.5a (Wrath of the Lich King).
Funcionará en Windows, MacOS y Linux; aunque la versión del cliente del juego no es compatible con versiones recientes de MacOS por ser una aplicación de 32-bit; pero como hemos visto también este inconveniente se puede solucionar.

Empezaremos instalando Docker, ya sea descargándolo de la web oficial o, como en mi caso, a través de Homebrew:
$ brew install --cask docker
A continuación, descargaremos el software azerothcore, una implementación hecha mediante ingeniería inversa del servidor de juego que correrá como un contenedor de docker, lo que hará mucho más fácil tanto la instalación de todas las herramientas necesarias como su actualización y mantenimiento. Descomprimimos sus contenidos donde no nos estorben, entramos al directorio mediante la terminal y obtenemos la última versión de los paquetes necesarios:
$ docker compose pull
Una vez que este proceso haya concluido, lo cual depende principalmente de la velocidad de la conexión a internet, importaremos a las bases de datos del servidor todos los datos del juego. Puedes irte a tomar un par de cañas mientras la instalación se lleva a cabo 🍺🍺…
$ docker compose up ac-db-import
Y el siguiente paso consiste en arrancar el contenedor del servidor:
$ docker compose up -d

El servidor ya está funcionando pero necesitamos un usuario con el que poder autenticarnos. Para ello, vamos a conectarnos al proceso del servidor a través de una terminal. Para saber el nombre del proceso, introducimos:
$ docker compose ps
En mi caso existe un proceso llamado acore-docker-ac-worldserver-1 al que me puedo conectar con la siguiente orden:
$ docker attach acore-docker-ac-worldserver-1
El simbolo del terminal cambiará a AC>. Crear el usuario es tan fácil como:
AC> account create USUARIO CONTRASEÑA
AC> account set gmlevel USUARIO 3 -1

Donde USUARIO y CONTRASEÑA serán tus credenciales para conectarte al servidor y le habremos dado permisos de GM. Puedes desconectar la terminal del servidor pulsando seguidas las combinaciones de teclas Ctrl+P y Ctrl+Q.

Listo! Hora de que cambies tu configuración de realmlist para que apunte a tu servidor privado. Si juegas desde el mismo ordenador donde tienes el servidor, puedes referirte a él como «localhost» y si es desde otra máquina de tu red local, incluso puedes utilizar el nombre de host (por ejemplo, en mi caso, «MacBook-Pro»).
Y que vuelvas a disfrutar de Azeroth!


Más info:
https://www.chromiecraft.com/es/como-instalar-un-servidor-de-wow-en-tu-computadora/
https://www.azerothcore.org/wiki/install-with-docker

World of Warcraft (32-bit) en MacOS

Hace un par de años que Apple retiró de MacOS el soporte para aplicaciones de 32-bit. A estas alturas, salvo que utilices aplicaciones muy antiguas y abandonadas, esto no debería ser un problema, pero sí que existen algunos programas que ya no podrás ejecutar en versiones nuevas del SO.
Una de ellas es el antiguo cliente de World of Warcraft. Aunque se trataba de una aplicación nativa, Blizzard lo dejó de lado y empezó a ofrecer WoW a través de su servicio Battle.net, que cuenta con una suite muy al estilo Steam, pero que ya no permite modificar el servidor al que te vas a conectar.

En definitiva, sin launcher compatible con 64-bit, la solución pasa por crear una envoltura para la aplicación de Windows a través de traducción de librerías, muy al estilo de otras cosas que hice en Linux.

En primer lugar, instalamos Winery. Puedes descargarlo manualmente desde https://github.com/Gcenx/WineskinServer/releases pero yo prefiero hacerlo con Homebrew, con lo que también se instalarán sus actualizaciones de forma automatizada:
$ brew install --no-quarantine gcenx/wine/unofficial-wineskin
El flag --no-quarantine evitará tener que insistirle (botón derecho/abrir) a MacOS para abrir la aplicación 😉


Si has optado por descargarlo manualmente, lo encontrarás bajo el apartado de Assets comprimido con extensión .txz, y una vez lo hayamos bajado y desempaquetado, tendremos la aplicación tal y cómo se puede ver en esta imagen:

Puedes arrastrarla por ejemplo a tu carpeta de Aplicaciones.

Ejecútala y te encontrarás con algo muy similar a esto:

En primer lugar pulsa la flecha de refrescar y a continuación en el símbolo «+» para comprobar qué motores nuevos puede haber disponibles y escoger el más reciente. Al momento de escribir esto, el más nuevo es WS11WineCX64Bit21.2.0.
Este nombre no nos dice nada, pero el número de versión es el más alto. Confirmamos que lo queremos descargar e instalar:

Una vez que tenemos nuestro motor de traducción, ya podemos crear la envoltura. Hacemos click en «Create New Blank Wrapper» y le damos un nombre, por ejemplo «World of Warcraft».
Este paso le tomará un poco de tiempo a la máquina ya que tiene que configurar una versión específica de Wine con el motor de traducción que le hemos indicado. Una vez esté listo, haz clic en «View wrapper in Finder».

La ventana que se abre contiene lo que será la supuesta aplicación pero por ahora está vacía. Haz clic con el botón derecho sobre ella y elige «Mostrar contenido del paquete». Ahora ejecuta la app Wineskin que hay dentro y selecciona «Install Software»:

Ahora podemos escoger si copiar o mover toda la carpeta con el juego (para Windows). Yo voy a escoger copiar, seleccionaré el directorio donde están todos los archivos del juego y confirmaré cual es el archivo que lanza la aplicación (que en este caso es «Wow.exe»)

Y listo! Se puede toquetear alguna cosa más, como el icono de la aplicación, por ejemplo, pero en principio no es necesario hacer nada extra para conseguir que el juego funcione bajo macOS.
He de decir que también he hecho esto con el Age Of Empires III Complete Collection y no he tenido ningún problema, lo que me ha permitido librarme de una máquina virtual que tenía por ahí para poder ejecutarlo.

La solución no es perfecta, en mi caso a veces se ven algunos artefactos gráficos, pero no estoy seguro de si es cosa del motor de traducción de librerías o de que estoy utilizando macOS Monterey en un Mac que, oficialmente, no lo soporta.

Descargar una web completa

Existe una forma que permite descargar toda una web a una carpeta almacenada de forma local a través del comando wget. En MacOS este comando no viene de serie así que lo instalé a través de Homebrew:
$ brew install wget
En muchas distribuciones de Linux, sin embargo, viene ya con el sistema operativo.

Y ahora para descargar toda una web:
$ wget \
--recursive \
--no-clobber \
--page-requisites \
--html-extension \
--convert-links \
--restrict-file-names=windows \
--domains www.mipagina.com \
--no-parent \
http://www.mipagina.com/subdirectorio/html/

Donde las opciones son:
--recursive: descargar la página web completa.
--domains www.mipagina.com: no descargar nada que no pertenezca a este dominio.
--no-parent: no seguir enlaces fuera de la ruta /subdirectorio/html/.
--page-requisites: descargar todos los recursos necesarios (imágenes, CSS, etc.)
--html-extension: guardar archivos con extensión .html
--convert-links: modificar todos los enlaces para que funcionen de forma local.
--restrict-file-names=windows: modificar nombres de ficheros para que funcionen correctamente bajo Windows (si éste es tu SO).
--no-clobber: no sobreescribir archivos existentes (por si se corta la descarga y vuelves a ejecutar el comando, para que no baje cosas que ya tienes).

Aunque este truco le resultará familiar a todos los fans del intérprete de comandos, pocas veces lo he necesitado y quiero dejarlo por aquí apuntado para un futuro.

Transferir archivo a servidor mediante SCP

Hoy me he encontrado con la siguiente situación: quería transferir un archivo a desde un ordenador con Windows a mi Mac a través de la red local. Hay unas cuantas formas de hacerlo pero la primera que se me ha ocurrido ha sido mediante el protocolo SCP, que es suficientemente rápido y fácil como para solucionar el problema sin demasiadas complicaciones.

En primer lugar, hay que configurar el Mac para que podamos hacer login remoto (por SSH). Esto se hace activando la opción de «Sesión Remota» en la categoría «Compartir» de las Preferencias del Sistema:

Es importante que en esta pantalla hagamos clic sobre el símbolo «+» y añadir nuestro usuario de MacOS.
En el lado del Mac (que actuará como servidor) ya está todo listo. Vamos a Windows.

Un buen cliente de SCP es PSCP, del mismo desarrollador de la utilidad Putty. Basta con descargar el ejecutable necesario para tu plataforma ya que no requiere instalación:

Por comodidad, lo he descargado al escritorio, aunque si lo vas a usar habitualmente puede que te resulte más cómodo moverlo a otra ubicación que se encuentre en el PATH del Símbolo de sistema (p.ej. a C:\Windows\System32\).
Ahora en mi escritorio tengo el ejecutable y el archivo que quiero transferir:

Ya sólo queda ejecutar el comando que realizará la transferencia. Desde un intérprete de comandos, me posiciono en el Escritorio y lanzo la siguiente orden:
$ pscp -P 22 test.zip emilio@192.168.1.35:/Users/emilio

El flag -P establece el puerto de la conexión (por defecto el 22 para conexiones SSH), y después del nombre del fichero establecemos el destino: usuario «emilio» en la IP local de mi Mac, seguido de dos puntos y una ruta donde este usuario tiene permisos de escritura (por ejemplo, su carpeta personal). Si es la primera vez que ejecutas este comando, se te preguntará si confías en el host (y se mostrará su firma criptográfica):

Cabe resaltar que en lugar de la IP del Mac, puedo modificar el comando y referirme a él por su nombre de host local, e incluso que el destino sea otra carpeta como la de descargas:
$ pscp -P 22 test.zip emilio@MacBook-Pro:/Users/emilio/Downloads/

Las siguientes veces que te conectes a esta máquina no se te pedirá confirmar su clave criptográfica ya que Putty las almacena en el registro de Windows. Si quieres comprobarlas (o incluso eliminarlas) las encontrarás bajo la ruta:
HKEY_CURRENT_USER\Software\SimonTatham\PuTTY\SshHostKeys

En MacOS (y creo que también en Linux) tenemos ya por defecto disponible un cliente equivalente en el terminal, llamado «scp». El comando funciona con la misma sintaxis y de forma prácticamente idéntica. Las claves quedan luego almacenadas en este fichero:
~/.ssh/known_hosts

🙂

Problema Productor Consumidor (Java)

He desarrollado un pequeño código a través del cual poder entender y experimentar con el escenario conocido como «problema de productor-consumidor», que tiene que ver con sincronización de hilos y acceso a memoria.

Para ponernos en contexto, pensemos en un programa que lanza dos procesos (o más) que deben escribir y consultar el contenido de una variable de forma repetitiva.
El proceso que genera los datos (el productor) no puede seguir escribiendo nuevos datos mientras la variable aun contenga el dato anterior; y el proceso que los consulta (el consumidor) no debe obtenerlos mientras no hayan sido actualizados (o mientras no hayan empezado a generarse).
La variable puede ser cualquier cosa, no necesariamente una tipo de dato simple. Podemos estar hablando incluso de estructuras abstractas de datos: listas, pilas, etc.

La forma de resolver todo esto se basa en un mecanismo sencillo, aunque no trivial. Veámoslo por partes.

Los datos
Para este ejemplo voy a desarrollar una clase llamada InfoBuffer, que simplemente contendrá un valor entero. Este valor será privado y solo se puede consultar a través de los métodos put y get.
Una variable llamada «isWritable» actúa como bandera (flag) para señalar si la variable está esperando para ser escrita o para ser leída. Inicialmente la ponemos como verdadera, para que el primero en actuar sea el productor.

Lo realmente importante está en el hecho de que los métodos get y put son métodos sincronizados («synchronized»). Marcarlos como tal hace que mientras uno se ejecuta en un hilo, el resto de métodos quedan bloqueados para esa instancia de esa clase (se mantiene su ejecución en espera).
Es decir, si yo tengo un objeto de tipo InfoBuffer y estoy leyendo (get) en un hilo, otros hilos deben esperar si están intentando realizar operaciones que estén también marcadas como «synchronized». Esto previene que los métodos intenten acceder de forma concurrente a la misma variable, y que cada uno espere a que el anterior termine.

En el caso del método put, comprobamos si la variable está en modo escritura. Si no lo está, hacemos que el hilo espere.
Cuando esté, salimos del bucle while, cambiamos el valor y la ponemos en modo de lectura (!isWritable).
El método get realiza las mismas operaciones pero con la comparación opuesta y retorna el valor almacenado.

El productor
La clase productor debe implementar la interfaz Runnable para poder lanzarla más adelante en un hilo separado. Algo similar podría obtenerse haciendo que extienda la clase Thread, pero yo he preferido hacerlo así. Para construir un productor, debemos pasarle el objeto InfoBuffer sobre el que estará escribiendo.
El método run contiene un bucle con 10 pasos en los que tratará de almacenar un valor en el objeto InfoBuffer.

El consumidor
La clase que consume datos funciona de forma análoga al productor. En este caso el bucle ejecuta 10 veces la función get para mostrar los datos en pantalla.

Programa principal
El programa principal sólo tiene que crear un objeto InfoBuffer, un productor y un consumidor, dándoles la referencia del primero. Ambos procesos se lanzan en hilos separados.

Output
El programa se puede compilar mediante la orden de terminal:
$ javac ProducerConsumer.java
Se ejecuta con:
$ java ProducerConsumer
O directamente, sin compilar ni nada, se puede hacer:
$ java ProducerConsumer.java
(Esto sólo funciona si todas las clases están escritas en el mismo archivo pero la primera es la clase pública que contiene el método «main»).

La salida es:

Y se puede ver cómo el programa va escribiendo diferentes valores en cada paso del bucle de escritura, alternándose con las operaciones de lectura de esos valores de forma ordenada a pesar de haber sido lanzadas desde dos hilos concurrentes.

Documentación
Puedes generar documentación del programa «parseando» los comentarios escritos en el código si ejecutas la orden:
$ javadoc ProducerConsumer.java -package -d help
Esto generará un directorio llamado «help» con unos cuantos archivos dentro. Si abres el archivo «index-all.html» en tu navegador, verás algo como esto:

Código completo

El código completo se puede descargar en este enlace:
https://github.com/emilio-devesa/producerconsumer/archive/refs/heads/main.zip