Compilar o cliente Metin2 para Android e conectá-lo a um servidor de teste

Entre os projetos públicos analisados, cemreefe/metin2-android é a base mais completa para testar o cliente inteiro de Metin2 no Android. Inclui o cliente C++, um launcher Android, controles táteis, bibliotecas nativas e instruções para conexão com um servidor compatível. Este guia usa a revisão exata 4ac33651d49000de95e520e6de4373213dc54405. Não é um APK universal para qualquer servidor privado: cliente, dados do jogo e servidor precisam ser compatíveis.

Uma observação sobre o termo “open source”: em 25 de outubro de 2026, o repositório principal não declarava uma licença que cobrisse o cliente inteiro. Código público não significa permissão automática para redistribuição. O componente OpenGr2ndma usa MPL-2.0, enquanto os dados originais do jogo têm direitos próprios. Este guia não fornece os dados nem um APK com esses arquivos. Código-fonte, licença OpenGr2ndma.

Ilustração: personagem reconhecível de Metin2 em um telefone durante a preparação de um cliente personalizado. Não é uma captura da compilação nem do jogo.

O tópico Metin2 Mobile & PC Cross Platform Source no Turkmmo disponibiliza as variantes BGFX e OpenGL após o login. O arquivo opengl.zip analisado contém um projeto Android e código C++ do cliente. Porém, faltam as bibliotecas Android .a/.so necessárias para compilá-lo; a biblioteca Granny para Windows incluída não as substitui. Não encontramos APK, wrapper Gradle completo nem licença do cliente inteiro. Lemos os arquivos sem executar os programas do pacote.

Um tópico mais recente, “Mobile Source … Full”, descreve um protótipo Unity e indica controles táteis e suporte Android/iOS como trabalhos futuros. Não avaliamos o grande arquivo separado. O título da postagem não comprova que o cliente móvel esteja pronto.

O autor do port relata que testou login, entrada no mundo, combate, inventário e salvamento. As principais evidências vêm de um emulador x86_64; é preciso validar separadamente um celular arm64 e sessões longas. Para conhecer o cenário, consulte a visão geral dos clientes móveis Metin2.

O procedimento principal conecta o cliente Android, pela LAN, ao próprio servidor de testes. O servidor roda em um Linux separado ou VM; o telefone usa a mesma rede Wi-Fi. A opção com servidor dentro do APK aparece no fim.

Build Tools 33.0.1 aparece em app/build.gradle; o exemplo de instalação upstream indica outro subnúmero. Não troque automaticamente as versões fixadas pelas mais recentes.

Estes comandos são para Bash no Linux. Indique o caminho real do Android SDK e do Gradle 8.1.1. JDK 17 precisa estar ativo em JAVA_HOME. Instale o SDK com as ferramentas oficiais do Android e leia/aceite você mesmo qualquer nova licença. Documentação do SDK.

java -version
gradle --version
sdkmanager "platforms;android-33" "build-tools;33.0.1" \
  "ndk;25.2.9519653" "cmake;3.22.1" "platform-tools"

mkdir -p "$HOME/metin2-lab"
cd "$HOME/metin2-lab"
git clone https://github.com/cemreefe/metin2-android.git
cd metin2-android
git checkout --detach 4ac33651d49000de95e520e6de4373213dc54405
git submodule update --init --recursive
git submodule status

export M2_REPO="$PWD"
export M2_ANDROID="$M2_REPO/r10dev.net OPENGL-ITJA/android"
export ANDROID_SDK_ROOT="$HOME/Android/Sdk"
export GRADLE="/opt/gradle-8.1.1/bin/gradle"
printf 'sdk.dir=%s\n' "$ANDROID_SDK_ROOT" > "$M2_ANDROID/local.properties"

O submódulo OpenGr2ndma está fixado no commit 210f5c326531297495c24e7bb1e24dc1b1a77833. Se for omitido, o CMake falha; baixar um ZIP do GitHub não o inicializa. Mantenha entre aspas o caminho r10dev.net OPENGL-ITJA.

Coloque o conteúdo abaixo em profiles/home.properties. Troque 192.168.1.50 pelo endereço LAN do seu servidor Linux. No celular, 127.0.0.1 aponta para o próprio celular, não para o PC servidor.

m2.abi=arm64-v8a
m2.serverMode=remote
m2.serverHost=192.168.1.50
m2.authPort=11000
m2.channelPort=11011
m2.gamePortOffset=0
m2.applicationIdSuffix=.lab
m2.appLabel=Metin2 Local Lab
m2.versionName=home
m2.dataBundled=false
m2.dataUrl=
m2.dataVersion=1
m2.serverListUrl=
m2.devUrl=
m2.updateChannel=

Em servers/servers.json, deixe somente o servidor de testes:

{
  "version": 1,
  "servers": [
    {
      "name": "Home Lab",
      "host": "192.168.1.50",
      "authPort": 11000,
      "channelPort": 11011
    }
  ]
}

Deixar m2.serverListUrl= vazio é intencional: sem essa propriedade, o build usa o catálogo remoto padrão do autor. Deixar m2.devUrl= vazio desativa o envio opcional de diagnósticos e a verificação de atualizações. O laboratório não exibirá um servidor de desenvolvimento de terceiros. Veja ServerCatalog.java e DevReporter.java.

Isso separa os erros de ferramentas e bibliotecas nativas dos problemas de dados e servidor. Compilar sozinho não demonstra que é possível entrar no mundo.

cd "$M2_ANDROID"
"$GRADLE" --no-daemon --max-workers=4 assembleDebug \
  -Pm2profile=home -Pm2abi=arm64-v8a
ls -lh app/build/outputs/apk/debug/app-debug.apk

Para emulador x86_64, use -Pm2abi=x86_64. A ABI precisa corresponder ao dispositivo. Na data da análise, o repositório não oferecia APK público pronto; este processo gera uma build debug.

Resultado verificado da compilação

No Windows, a revisão original parou ao compilar C++: UserInterface/Locale.h ocultava o cabeçalho de sistema locale.h. Em uma cópia de trabalho isolada, removemos o caminho UserInterface da lista include_directories(...) em clientsource/CMakeLists.txt e adicionamos logo depois da lista:

add_compile_options("-iquote${CMAKE_CURRENT_SOURCE_DIR}/UserInterface")

A pasta do jogo segue disponível para includes entre aspas sem interferir na busca por cabeçalhos do sistema. Depois dessa mudança, assembleDebug concluiu para x86_64 e arm64-v8a, produzindo um APK comum. Isso comprova o build da nossa cópia, não do upstream inalterado em todo Windows. Os passos Linux vêm do código e do guia do autor. Não validamos assim entrada no mundo, celular físico, desempenho ou servidor offline.

Coloque em ~/metin2-lab/client-data um checkout de dados que você tenha direito de usar e com estrutura compatível. Este guia não concede direitos sobre modelos, mapas ou músicas originais. Um pack qualquer de outro servidor privado não é substituto verificado: protos, interface Python e formatos podem variar.

sudo apt install rsync patch python3-pil libsodium23 liblzo2-2 zip imagemagick ninja-build
export M2_DATA="$HOME/metin2-lab/client-data"
export M2_STAGE="$HOME/metin2-lab/staged-data"
test -d "$M2_DATA/assets/root"
"$M2_ANDROID/tools/stage_client_data.sh" "$M2_DATA" "$M2_STAGE" en

stage_client_data.sh mescla os packs na ordem esperada, coloca root por cima, converte item_proto/mob_proto e adiciona scripts de compatibilidade, escala e HUD tátil. Se algo falhar, revise o staging antes do motor gráfico. Não renomeie em massa nomes coreanos para minúsculas.

O cliente também precisa da biblioteca padrão Python 2.7.18, especificamente a pasta Lib, não o Python 3 do computador. Baixe o pacote-fonte oficial Python 2.7.18, extraia em uma pasta de trabalho separada e configure, por exemplo, M2_PYLIB=~/metin2-lab/python-2.7.18/Lib. Python 2 não é runtime atual para serviços comuns; aqui é uma dependência do cliente antigo embutido.

Para incluir os dados no APK, mude m2.dataBundled=true em home.properties e execute:

export M2_PYLIB="$HOME/metin2-lab/python-2.7.18/Lib"
test -f "$M2_PYLIB/os.py"
M2_CLIENT_DATA="$M2_STAGE" M2_PYLIB="$M2_PYLIB" \
M2_BUNDLE_OUT="$HOME/metin2-lab/bundle" GRADLE="$GRADLE" \
  "$M2_ANDROID/tools/make_bundle.sh" home 1

O resultado será ~/metin2-lab/bundle/metin2-home-1.apk e um ZIP de dados versionado. Reserve espaço para dados extraídos, ZIP e APK. Se alterar os dados, incremente m2.dataVersion: apagar apenas o ZIP antigo não força o aplicativo instalado a extrair novamente a mesma versão. A versão do APK é separada. Veja make_bundle.sh.

Esta seção segue o guia de self-hosting do autor. Use uma VM Linux de teste separada; não altere um servidor de produção. O upstream indica Ubuntu 22.04, g++ 11, CMake 3.22 e MariaDB 10.6.

sudo apt install build-essential cmake git mariadb-server python3
cd "$HOME/metin2-lab"
git clone https://github.com/d1str4ught/m2dev-server-src.git
git -C m2dev-server-src checkout --detach 66068c1
git -C m2dev-server-src apply "$M2_REPO/server/m2dev-server-src-linux.patch"
cmake -S m2dev-server-src -B m2dev-server-src/build -DCMAKE_BUILD_TYPE=Release
cmake --build m2dev-server-src/build -j4

git clone https://github.com/d1str4ught/m2dev-server.git m2srv
git -C m2srv checkout --detach ad30738
cp m2dev-server-src/build/bin/{db,game,qc} m2srv/share/bin/
cp m2srv/share/bin/qc m2srv/share/locale/english/quest/qc
(cd m2srv/share/locale/english/quest && python3 make.py)

Antes de iniciar, crie os bancos e um usuário SQL limitado. Este SQL é para uma VM nova e isolada, sem bancos existentes com esses nomes. Em sudo mariadb, substitua as duas ocorrências de DOPLN_VLASTNI_HESLO pela mesma senha forte. Não execute com esse texto literal.

CREATE DATABASE account;
CREATE DATABASE common;
CREATE DATABASE player;
CREATE DATABASE log;
CREATE DATABASE hotbackup;
CREATE USER 'm2lab'@'127.0.0.1' IDENTIFIED BY 'DOPLN_VLASTNI_HESLO';
CREATE USER 'm2lab'@'localhost' IDENTIFIED BY 'DOPLN_VLASTNI_HESLO';
GRANT ALL ON account.* TO 'm2lab'@'127.0.0.1', 'm2lab'@'localhost';
GRANT ALL ON common.* TO 'm2lab'@'127.0.0.1', 'm2lab'@'localhost';
GRANT ALL ON player.* TO 'm2lab'@'127.0.0.1', 'm2lab'@'localhost';
GRANT ALL ON log.* TO 'm2lab'@'127.0.0.1', 'm2lab'@'localhost';
GRANT ALL ON hotbackup.* TO 'm2lab'@'127.0.0.1', 'm2lab'@'localhost';

Depois importe os quatro esquemas fornecidos; conforme o runtime, hotbackup deve começar vazio:

cd "$HOME/metin2-lab/m2srv"
for db in account common player log; do
  sudo mariadb "$db" < "sql/$db.sql"
done

Em share/conf/db.txt, altere usuário e senha em SQL_ACCOUNT, SQL_PLAYER, SQL_COMMON e SQL_HOTBACKUP para seu m2lab e a senha escolhida. Faça o mesmo em share/conf/game.txt para ACCOUNT_SQL, PLAYER_SQL, COMMON_SQL e LOG_SQL. Preserve os demais valores e a ordem específica dos campos. Não salve credenciais reais em repositório Git público. Configuração DB, configuração game.

MariaDB deve escutar apenas em 127.0.0.1; o telefone não se conecta a ela. Na VM, crie o arquivo separado /etc/mysql/mariadb.conf.d/99-metin2-lab.cnf sob [mysqld]:

[mysqld]
bind-address=127.0.0.1
sql_mode=NO_ENGINE_SUBSTITUTION

Depois de sudo systemctl restart mariadb, teste com mariadb -h 127.0.0.1 -u m2lab -p account e digite a senha no prompt. O runtime antigo precisa desse modo SQL. Não o aplique a bancos compartilhados de outro projeto.

Crie credenciais novas de teste para a conta do jogo; o dump já inclui contas preparadas. Após substituir os exemplos:

INSERT INTO account.account (login, password, social_id, status)
VALUES ('VLASTNI_TEST_LOGIN', PASSWORD('VLASTNI_TEST_HESLO'), '1234567', 'OK');

Com os bancos preparados, execute python3 install.py em m2srv. As configurações serão geradas. Em cada channels/channel1/coreN/CONFIG do jogo, defina um endereço acessível pelo telefone:

BIND_IP: 192.168.1.50

A detecção automática pode ignorar o IP da LAN. Cada core anuncia o próprio endereço ao cliente. Se executar install.py novamente, confira a alteração: os arquivos gerados são substituídos.

Em m2srv, inicie o canal com python3 start.py 1 e pare com python3 stop.py. Confira os logs auth e dos três cores. Se o login passar, mas você voltar à lista após escolher personagem, verifique primeiro o endereço e a porta do core que hospeda o mapa. A porta auth sozinha não basta.

Não atualize o servidor às cegas. Desde o commit 0cc595bf097dcf89ddba60615e56fe790823cd22, o handshake muda para 0xf8 com libsodium/XChaCha20. O cliente escolhido espera o antigo 0xfb/0xfa. Para um servidor mais novo, é preciso portar o protocolo no cliente; mudar IP ou senha não resolve.

adb devices
adb shell getprop ro.product.cpu.abilist
adb install -r "$HOME/metin2-lab/bundle/metin2-home-1.apk"
adb shell pm path com.metin2.client.lab

Abra o app, selecione seu Home Lab e conecte-se somente com a conta de teste do próprio servidor. Este perfil usa o package com.metin2.client.lab; os dados externos costumam ficar aqui:

adb shell ls /sdcard/Android/data/com.metin2.client.lab/files/
adb shell cat /sdcard/Android/data/com.metin2.client.lab/files/syserr.txt
adb logcat -d > metin2-android-logcat.txt

O package base usa com.metin2.client; o perfil offline upstream, com.metin2.client.offline. Não confunda os caminhos. O código usa getExternalFilesDir(null), então vale o armazenamento real do app no dispositivo. Se a atualização falhar, confira ABI, package ID e assinatura do APK; desinstalar sem cuidado pode apagar personagens offline.

O projeto upstream também oferece o perfil bundled: compila os processos do servidor para Android, adiciona uma camada SQLite no lugar do MySQL e inclui os dados do servidor. O telefone então não precisa de servidor remoto. É outra compilação e outro pacote de dados, não uma função automática do APK da etapa 3.

Em servers/servers.json, registre a instância integrada:

{
  "version": 2,
  "servers": [
    { "name": "Single Player", "embedded": true }
  ]
}

Em profiles/bundled.properties, deixe m2.serverListUrl=, m2.devUrl= e m2.updateChannel= vazios. Mantenha m2.serverMode=embedded, m2.dataBundled=true e o sufixo .offline. Para cada novo pacote de dados, incremente m2.dataVersion.

Com os checkouts de runtime e de código-fonte prontos, o empacotamento fica assim:

"$M2_REPO/r10dev.net OPENGL-ITJA/server/tools/make-server-pack.sh" \
  "$HOME/metin2-lab/m2srv" \
  "$HOME/metin2-lab/m2dev-server-src" \
  "$HOME/metin2-lab/server-pack"

M2_SERVER_PACK="$HOME/metin2-lab/server-pack" \
M2_CLIENT_DATA="$M2_STAGE" M2_PYLIB="$M2_PYLIB" \
M2_BUNDLE_OUT="$HOME/metin2-lab/bundle" GRADLE="$GRADLE" \
  "$M2_ANDROID/tools/make_bundle.sh" bundled 1

Antes de executar, confira bundled.properties, catálogo privado, dataVersion e conta de teste no banco seed. make-server-pack.sh espera checkout do runtime, checkout das fontes e diretório de saída, nessa ordem. Não use no lugar o exemplo diferente da seção Web da documentação upstream. O Gradle do servidor embutido contém um caminho NDK de Linux; não o apresentamos como build offline Windows verificado.

Compilação, aplicativo iniciado, conexão e sessão contínua são resultados diferentes. Para testar, crie um personagem, entre no mapa, lute, troque de core, reinicie o cliente e confira se o inventário foi salvo. Sem isso, não se pode dizer que um telefone e servidor específicos foram validados juntos.