Client Metin2 pe 32 sau 64 de biți: verifică EXE-ul și LAA

Un client Metin2 poate rămâne un program x86 pe 32 de biți chiar dacă rulează pe Windows pe 64 de biți și are activat indicatorul Large Address Aware. Acest indicator, asociat adesea cu un „patch 4 GB”, privește spațiul de adrese. Un client x64 nativ este o altă compilare, cu o altă arhitectură a mașinii. Niciuna dintre aceste etichete nu dovedește singură un FPS mai mare sau rezolvarea tuturor blocărilor.

Prima întrebare utilă este: ce arhitectură are executabilul propriu-zis al jocului? Cerințele Windows ale unui server, launcherul și procesul jocului pot descrie lucruri diferite. Acest ghid explică verificarea antetului EXE numai prin citire și limitele rezultatului. Nu presupune că toate serverele Metin2 distribuie același client.

Ilustrație generată pe baza referințelor din Metin2. Nu este captură de ecran, măsurare a memoriei sau dovadă a unei anumite compilări a clientului.

Documentația Microsoft despre LAA și tabelele limitelor de memorie deosebesc spațiul virtual de adrese al procesului de memoria RAM fizică instalată. Rândurile despre limitele de memorie de mai jos presupun o ediție x64 de Windows. Rândul ARM64 identifică o altă arhitectură de fișier; nu afirmă că un astfel de fișier rulează pe Windows x64.

Acestea sunt limite ale spațiului de adrese. Nu promit că un client poate aloca un singur bloc continuu de 4 GB, poate utiliza toată memoria RAM sau poate evita orice eșec de alocare. Un executabil x64 nativ cu LAA dezactivat are și el restricții suplimentare. Nu deduce limita efectivă doar din expresia „64 de biți”.

În sens invers,32 GB de RAM fizic nu elimină plafonul spațiului de adrese al unui proces x86. Ridicarea acestuia tratează numai problemele care depind într-adevăr de el. O resursă coruptă, un pointer invalid sau un modul incompatibil necesită un diagnostic propriu.

În discuția Turkmmo din mai 2026, autorul indică baza MartySama v5.8 și afirmă că obținerea compilării serverului pe 64 de biți a fost mai ușoară decât portarea clientului. Răspunsurile discută întreținerea distribuțiilor x86 și x64 în paralel și păstrarea compatibilității pachetelor. Sunt relatări despre setul său de surse, nu o procedură de migrare testată pentru alt server.

O discuție independentă pe Reddit despre un server Linux și un client x64 arată o altă ambiguitate: întrebat dacă a portat el clientul, autorul spune că l-a obținut de la altcineva. O captură de ecran sau faptul că serverul a fost portat nu identifică originea, revizia și arhitectura fiecărei componente.

Jurnalul EterNext din 1 aprilie 2026 anunță un client nativ pe 64 de biți pentru proiectul respectiv. Nu i-am inspectat executabilul actual și nu i-am reprodus afirmațiile despre performanță. Tratează declarația datată a operatorului drept informație despre acel proiect; verifică efectiv compilarea înainte de a o extinde asupra altui client.

Identifică mai întâi executabilul care rulează jocul. Patcherul, actualizatorul și configuratorul pot fi fișiere separate, cu arhitecturi diferite. Consultă documentația operatorului sau numele procesului jocului în Managerul de activități. Nu presupune că fiecare client privat folosește același nume de fișier.

Specificația Microsoft PE/COFF definește câmpul Machine, formatul antetului opțional și indicatorul IMAGE_FILE_LARGE_ADDRESS_AWARE. Cititorul următor pentru Python 3 folosește numai biblioteca standard și deschide fișierul ales în modul binar de citire. Salvează-l ca pe_info.py, apoi rulează python pe_info.py client.exe, înlocuind ultimul nume cu executabilul propriu-zis identificat.

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))

Interpretează câmpurile împreună. Machine:0x014C, Format:PE32, LAA:true înseamnă un executabil x86 marcat large-address-aware, nu un executabil x64 nativ. Machine:0x8664 împreună cu PE32+ identifică AMD64; 0xAA64 identifică, în schimb, ARM64. Aceste nume sunt definite în specificația Microsoft, nu deduse din numele fișierului.

Cititorul verifică semnăturile DOS/PE, limitele antetelor și cele trei perechi Machine/Magic acceptate. Este un mic inspector de metadate, nu un validator complet al încărcătorului PE, un verificator de semnături sau o evaluare a siguranței executării unui fișier. Un antet neacceptat sau contradictoriu este un motiv să oprești interpretarea rezultatului, nu o instrucțiune de reparare a EXE-ului. Scriptul nu modifică antetele și nu execută fișierul.

Ghidul Microsoft pentru portarea jocurilor identifică trunchierea pointerilor, alinierea, structurile binare persistente și bibliotecile terțe ca probleme de migrare. DLL-urile native obișnuite, încărcate în același proces, trebuie să corespundă arhitecturii procesului. Redenumirea unui DLL x86 nu îl transformă într-o dependență x64.

Într-un arbore de surse Metin2, verifică codul care stochează pointeri sau lungimi în întregi mai înguști, interfața dintre Python și codul nativ, decodoarele de resurse și bibliotecile folosite de exact acea revizie. Construiește apoi dependențele corespunzătoare. Lucrările concrete depind de proiect; lista nu este un patch instalabil pentru un pachet de surse neidentificat.

Separă arhitectura de rezultatele de performanță. Compară aceeași revizie a clientului, aceleași resurse, scenă și setări și notează condițiile în care apar erorile de memorie, pe lângă timpii cadrelor. Microsoft cere o nouă profilare după portare. Pentru acest articol nu am măsurat un câștig de FPS al unei compilări Metin2 x64.

Rețeaua transmite octeți, nu eticheta CPU-ului clientului. Un client pe 32 de biți și un server pe 64 de biți pot comunica dacă protocolul lor efectiv rămâne compatibil. Verificarea unei anumite perechi Metin2 necesită definițiile pachetelor și teste. Numele identice de server sau compilarea reușită nu stabilesc compatibilitatea.

Acesta este un exemplu ilustrativ de format binar, nu o definiție de pachet Metin2:

import struct

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

Rezultatul este <BI 5 01e8030000 și <BQ 9 01e803000000000000. Conform documentației Python struct, < specifică little-endian, dimensiuni standard și absența octeților de umplere pentru aliniere; I ocupă 4 octeți, iar Q 8. Simpla lărgire a acelui câmp schimbă mesajul de la 5 la 9 octeți. Receptorul care așteaptă structura veche are nevoie de o schimbare de protocol convenită, nu de presupunerea că noua arhitectură CPU va rezolva situația.

Același audit se aplică datelor binare salvate și formatelor de resurse. Păstrează contractele explicite de transmisie și de fișier sau gestionează deliberat versiunile modificărilor și testează ambele capete. Nu înlocui mecanic fiecare întreg pe 32 de biți cu un tip de dimensiunea unui pointer: ID-urile jocului, contoarele, lungimile și pointerii au roluri diferite.

Pentru jucători, verificarea antetului diferențiază arhitectura fișierului ales de eticheta launcherului sau de cerința Windows. Folosește distribuția acceptată de server și întreabă operatorul ce compilare a jocului conține. Rezultatul nu verifică autentificarea, intrarea în lume, stabilitatea sau compatibilitatea cu protecția acelui server.

Pentru proprietari, păstrează o compilare despre care știi că funcționează cât timp auditezi sursele și dependențele pe care le deții sau pe care ai licență să le folosești. Codul public, un link de descărcare și o licență open-source sunt lucruri diferite. Articolul nu recomandă un pachet de surse neverificat drept client gata făcut pe 64 de biți.

Am executat cititorul pe patru exemple sintetice de antete și pe două executabile Windows existente, verificând că octeții lor au rămas neschimbați. Zece exemple deteriorate sau contradictorii au fost respinse. Exemplul de serializare a produs și el rezultatele documentate de 5/9 octeți. Aceste verificări validează exemplele; niciun client Metin2 nu a fost compilat, modificat sau pornit și nu se afirmă vreun rezultat de performanță în joc.

Pentru alt proiect, pornește de la compilarea sa actuală și de la propriile cerințe; catalogul de servere private Metin2 te ajută să îi găsești profilul. Pentru un client care se oprește la inițializarea graficii, ghidul separat No Appropriate Device tratează acel simptom diferit.

• Microsoft: LAA și spațiul de adrese de 4 GB, limite de memorie pe versiuni Windows, formatul PE/COFF, portarea jocurilor la 64 de biți.
• Python: formate binare standard și aliniere.
• Turkmmo: întrebare de migrare cu baza de surse identificată și Reddit: răspunsurile autorului despre originea clientului.
• EterNext: propriul anunț de migrare.

Surse verificate la 5 noiembrie 2026. Afirmațiile surselor, metadatele executabilului și comportamentul testat în joc rămân dovezi separate.