Cliente Metin2 de 32 o 64 bits: comprobar el EXE y el indicador LAA

Un cliente de Metin2 puede seguir siendo un programa x86 de 32 bits aunque se ejecute en Windows de 64 bits y tenga activado el indicador Large Address Aware. Ese indicador, asociado a menudo con un «parche de 4 GB», afecta al espacio de direcciones. Un cliente x64 nativo es una compilación distinta para otra arquitectura de máquina. Ninguna de esas etiquetas demuestra por sí sola más FPS ni la solución de todos los cierres inesperados.

La primera pregunta útil es: ¿qué arquitectura tiene el ejecutable que realmente ejecuta el juego? Los requisitos de Windows del servidor, su lanzador y el proceso del juego pueden describir componentes diferentes. Esta guía explica cómo leer la cabecera del EXE sin modificarlo y cuáles son los límites del resultado. No presupone que todos los servidores de Metin2 distribuyan el mismo cliente.

Ilustración generada a partir de referencias del juego Metin2. No es una captura, una medición de memoria ni la prueba de una compilación concreta.

La documentación de Microsoft sobre LAA y sus tablas de límites de memoria distinguen el espacio de direcciones virtuales del proceso de la RAM física instalada. Las filas sobre límites de memoria de la tabla presuponen una edición x64 de Windows. La fila ARM64 identifica otra arquitectura de archivo; no afirma que ese archivo pueda ejecutarse en Windows x64.

Son límites del espacio de direcciones, no una promesa de que el cliente pueda reservar un bloque contiguo de 4 GB, utilizar toda la RAM o evitar cualquier fallo de asignación. Un binario x64 nativo con LAA desactivado también tiene restricciones adicionales; la expresión «64 bits» no basta para deducir su límite efectivo.

Del mismo modo, disponer de 32 GB de RAM física no elimina el techo de direcciones de un proceso x86. Ampliarlo solo aborda los problemas que realmente dependen de él. Un recurso dañado, un puntero inválido o un módulo incompatible necesitan su propio diagnóstico.

En la discusión de Turkmmo de mayo de 2026, el autor identifica una base MartySama v5.8 y cuenta que compilar el servidor para 64 bits fue más sencillo que portar el cliente. Las respuestas hablan de mantener distribuciones x86 y x64 y conservar la compatibilidad de los paquetes. Son relatos sobre las fuentes de ese autor, no un procedimiento de migración probado para otro servidor.

Una discusión independiente en Reddit sobre un servidor Linux y un cliente x64 muestra otra ambigüedad: cuando le preguntan si portó el cliente él mismo, el autor responde que lo consiguió de otra persona. Una captura o el hecho de haber portado un servidor no identifican el origen, la revisión ni la arquitectura de todos sus componentes.

El diario de desarrollo de EterNext del 1 de abril de 2026 anuncia un cliente nativo de 64 bits para ese proyecto concreto. No hemos inspeccionado su ejecutable actual ni reproducido sus afirmaciones de rendimiento. Trata una declaración fechada del operador como información sobre ese proyecto; comprueba la compilación real antes de extenderla a otro cliente.

Identifica primero el ejecutable que hace funcionar el juego. El parcheador, el actualizador y la herramienta de configuración pueden ser archivos separados con arquitecturas distintas. Consulta la documentación del operador o el nombre del proceso del juego en el Administrador de tareas; no todos los clientes privados utilizan el mismo nombre de archivo.

La especificación PE/COFF de Microsoft define el campo Machine, el formato de la cabecera opcional y el indicador IMAGE_FILE_LARGE_ADDRESS_AWARE. El siguiente lector de Python 3 solo utiliza la biblioteca estándar y abre el archivo elegido en modo de lectura binaria. Guárdalo como pe_info.py y ejecuta python pe_info.py client.exe, sustituyendo el último nombre por el ejecutable real que hayas identificado.

import json
import struct
import sys

def inspect_pe(path):
    with open(path, "rb") as f:
        size = f.seek(0, 2)
        f.seek(0)
        dos = f.read(64)
        if len(dos) != 64 or dos[:2] != b"MZ":
            raise ValueError("Missing DOS header")
        offset = struct.unpack_from("<I", dos, 0x3C)[0]
        if offset < 64 or offset + 26 > size:
            raise ValueError("PE offset outside file")
        f.seek(offset)
        header = f.read(24)
        if header[:4] != b"PE\0\0":
            raise ValueError("Missing PE signature")
        machine = struct.unpack_from("<H", header, 4)[0]
        optional_size, flags = struct.unpack_from("<HH", header, 20)
        if optional_size < 2 or offset + 24 + optional_size > size:
            raise ValueError("Truncated optional header")
        magic = struct.unpack("<H", f.read(2))[0]
        expected = {0x014C: 0x010B, 0x8664: 0x020B, 0xAA64: 0x020B}
        if machine not in expected or magic != expected[machine]:
            raise ValueError("Unsupported or inconsistent Machine/Magic")
        return {
            "Machine": f"0x{machine:04X}",
            "Format": "PE32" if magic == 0x010B else "PE32+",
            "LAA": bool(flags & 0x0020),
        }

if __name__ == "__main__":
    if len(sys.argv) != 2:
        raise SystemExit("Usage: python pe_info.py client.exe")
    print(json.dumps(inspect_pe(sys.argv[1]), indent=2))

Interpreta los campos conjuntamente. Machine:0x014C, Format:PE32, LAA:true describe un binario x86 marcado como large-address-aware, no un ejecutable x64 nativo. Machine:0x8664 junto a PE32+ identifica AMD64; 0xAA64 identifica ARM64. Esos identificadores están definidos en la especificación de Microsoft y no se deducen del nombre del archivo.

El lector comprueba las firmas DOS/PE, los límites de las cabeceras y las tres parejas Machine/Magic admitidas. Es un pequeño inspector de metadatos, no un validador completo de la carga PE, un verificador de firmas ni una evaluación de si es seguro ejecutar el archivo. Una cabecera no admitida o incoherente debe detener la interpretación, no motivar una reparación del EXE. El script no modifica cabeceras ni ejecuta el archivo.

La guía de Microsoft para portar juegos identifica como aspectos de la migración el truncamiento de punteros, la alineación, las estructuras binarias persistidas y las bibliotecas de terceros. Las DLL nativas habituales cargadas dentro del proceso deben coincidir con su arquitectura; cambiar el nombre de una DLL x86 no la convierte en una dependencia x64.

En los fuentes de un cliente de Metin2, revisa el código que almacena punteros o longitudes en enteros más pequeños, la interfaz entre Python y código nativo, los decodificadores de recursos y las bibliotecas utilizadas por esa revisión exacta. Después compila las dependencias correspondientes. El trabajo concreto depende del proyecto; esta lista no es un parche instalable para un paquete de fuentes sin identificar.

Distingue la arquitectura de los resultados de rendimiento. Compara la misma revisión del cliente, recursos, escena y ajustes, y registra las condiciones de los fallos de memoria además de los tiempos de fotograma. Microsoft recomienda volver a perfilar la aplicación después de portarla. Para este artículo no hemos medido una mejora de FPS de una compilación Metin2 x64.

La red intercambia bytes, no la etiqueta de CPU del cliente. Un cliente de 32 bits y un servidor de 64 bits pueden comunicarse si su protocolo real sigue siendo compatible. Para confirmar que una pareja concreta de Metin2 funciona hacen falta sus definiciones de paquetes y sus pruebas; compartir nombre o compilar correctamente no demuestra esa compatibilidad.

Este es un ejemplo ilustrativo de formato binario, no una definición de paquete de Metin2:

import struct

for fmt in ("<BI", "<BQ"):
    packet = struct.pack(fmt, 1, 1000)
    print(fmt, len(packet), packet.hex())

La salida es <BI 5 01e8030000 y <BQ 9 01e803000000000000. Según la documentación de struct de Python, < establece little-endian, tamaños estándar y ausencia de relleno de alineación; I ocupa 4 bytes y Q ocupa 8. Ampliar solo ese campo cambia el mensaje de 5 a 9 bytes. Un receptor que espera el formato anterior necesita un cambio de protocolo acordado, en lugar de suponer que la nueva arquitectura de CPU lo solucionará.

La misma revisión se aplica a los datos binarios guardados y a los formatos de recursos. Conserva contratos explícitos para los datos transmitidos y los archivos, o versiona sus cambios deliberadamente y prueba ambos extremos. No sustituyas mecánicamente cada entero de 32 bits por un tipo del tamaño de un puntero: los identificadores del juego, contadores, longitudes y punteros cumplen funciones distintas.

Para los jugadores, la lectura de la cabecera distingue la arquitectura del archivo proporcionado de la etiqueta del lanzador o de los requisitos de Windows. Utiliza la distribución admitida por el servidor y pregunta al operador qué compilación del juego incluye. El resultado no verifica el inicio de sesión, la entrada al mundo, la estabilidad ni la compatibilidad con la protección del servidor.

Para los operadores, conserva una compilación conocida que funcione mientras revisas las fuentes y dependencias que realmente posees o estás autorizado a utilizar. Un código fuente públicamente legible, un enlace de descarga y una licencia de código abierto son hechos distintos. Este artículo no recomienda un paquete de fuentes sin verificar como cliente de 64 bits listo para usar.

Ejecutamos el lector sobre cuatro archivos sintéticos de cabecera y dos ejecutables de Windows existentes, comprobando que sus bytes no cambiaban. Se rechazaron diez archivos de prueba malformados o incoherentes. El ejemplo de serialización también produjo los resultados documentados de 5 y 9 bytes. Estas comprobaciones validan los ejemplos; no se ha compilado, modificado ni iniciado ningún cliente de Metin2, ni se atribuye ningún resultado de rendimiento en el juego.

Para otro proyecto, empieza por su compilación actual y sus propios requisitos; el directorio de servidores privados de Metin2 ayuda a encontrar su perfil. Si el cliente falla al inicializar los gráficos, la guía No Appropriate Device aborda ese síntoma diferente.

• Microsoft: LAA y espacio de direcciones de 4 GB, límites de memoria por versión de Windows, formato PE/COFF, portar juegos a 64 bits.
• Python: formatos binarios estándar y alineación.
• Turkmmo: pregunta de migración sobre una base identificada y Reddit: respuestas del autor sobre la procedencia del cliente.
• EterNext: su propio anuncio de migración.

Fuentes comprobadas el 5 de noviembre de 2026. Las declaraciones de las fuentes, los metadatos de un ejecutable y el juego efectivamente probado siguen siendo evidencias distintas.