jak project
v0.2.18
Importante
Nossos repositórios no GitHub são principalmente para desenvolvimento do projeto e rastreamento de problemas ativos. A maior parte das informações que você encontrará aqui refere-se à configuração do projeto para fins de desenvolvimento e não é relevante para o usuário final.
Para um guia de configuração sobre como instalar e jogar o jogo, há o seguinte vídeo que você pode conferir: https://youtu.be/K84UUMnkJc4
Para dúvidas ou informações adicionais referentes ao projeto, temos um Discord para discussão aqui: https://discord.gg/VZbXMHXzWv
Além disso, você pode encontrar mais documentação e respostas às perguntas mais frequentes no site principal do projeto: https://opengoal.dev
Aviso
Não use este projeto de descompilação sem fornecer sua própria cópia do jogo adquirida legalmente. Não distribuímos nenhum ativo do jogo - você deve usar sua própria cópia do jogo para PS2 obtida legitimamente. Oferecemos suporte a todas as versões de varejo PAL, NTSC e NTSC-J, incluindo cópias de Greatest Hits.
goalcdecompilergoal_src/game Este projeto visa portar o Jak and Daxter e Jak II originais para PC. Mais de 98% dos jogos são escritos em GOAL, uma linguagem Lisp personalizada desenvolvida pela Naughty Dog. Nossa estratégia é:
Nossos objetivos são:
Oferecemos suporte para Linux e Windows em x86-64.
Não oferecemos suporte nem planejamos oferecer suporte à arquitetura ARM. Isso significa que não será executado em dispositivos como dispositivos móveis.
Jak 1 é amplamente jogável do início ao fim, com alguns bugs que estão sendo continuamente corrigidos. Jak 2 está em desenvolvimento.
Lista de reprodução do YouTube: https://www.youtube.com/playlist?list=PLWx9T30aAT50cLnCTY1SAbt2TtWQzKfXX
Para ajudar na descompilação, construímos um descompilador que pode processar o código GOAL e descompactar os recursos do jogo. Especificamos manualmente os tipos de função e os locais onde acreditamos que o código original tinha conversões de tipo (ou onde eles parecem apropriados) até que o descompilador seja bem-sucedido e, em seguida, limpamos a saída do código descompilado adicionando comentários e ajustando a formatação e, em seguida, salvamos-o em goal_src .
Nosso descompilador foi projetado especificamente para processar a saída do compilador GOAL original. Como resultado, quando recebe conversões corretas, geralmente produz código que pode ser alimentado diretamente em um compilador e funciona perfeitamente. Isso é testado continuamente como parte de nossos testes de unidade.
O restante deste README é direcionado a pessoas interessadas em construir o projeto a partir da fonte, normalmente com a intenção de contribuir como desenvolvedor.
Se isso não soa como você e você deseja apenas jogar, consulte a seção acima Início rápido
Todos os três sistemas Linux são suportados usando Docker.
Escolha o tipo de Linux preferido com suporte e crie a imagem escolhida
docker build -f docker/(Arch|Fedora|Ubuntu)/Dockerfile -t jak .
Isso criará uma imagem com todas as dependências necessárias e já construída.
docker run -v "$(pwd)"/build:/home/jak/jak-project/build -it jak bash
Nota: Se você alterar o conteúdo do diretório build/ precisará executar novamente o comando build . Alternativamente, você pode obter a compilação via docker cp .
Isso vinculará sua pasta build/ às imagens para que você possa validar sua compilação ou testá-la em um dispositivo externo.
As imagens Docker podem ser vinculadas ao seu IDE (por exemplo, CLion) para ajudar na detecção de códigos, análise estática, execução de testes e construção contínua.
Infelizmente, você ainda precisará do executor de tarefas em sua máquina local para executar o jogo ou, em vez disso, execute o jogo manualmente por meio dos comandos encontrados em Taskfile.yml .
Instale pacotes e repositório init:
sudo apt install gcc make cmake ninja-build build-essential g++ nasm clang-format libxrandr-dev libxinerama-dev libxcursor-dev libpulse-dev libxi-dev python libgl1-mesa-dev libssl-dev
sudo sh -c " $( curl --location https://taskfile.dev/install.sh ) " -- -d -b /usr/local/binCompilar:
cmake -B build && cmake --build build -j 8Execute testes:
./test.sh Nota: descobrimos que clang e lld são significativamente mais rápidos para compilar e vincular do que gcc , geram código mais rápido e têm melhores mensagens de aviso. Para instalá-los:
sudo apt install lld clang e execute cmake (em um novo diretório de compilação) com:
cmake -DCMAKE_SHARED_LINKER_FLAGS= " -fuse-ld=lld " -DCMAKE_EXE_LINKER_FLAGS= " -fuse-ld=lld " -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ ..Instale pacotes e repositório init:
sudo pacman -S cmake libpulse base-devel nasm python libx11 libxrandr libxinerama libxcursor libxi
yay -S go-task Apenas para Arch, substitua task por go-task no restante das instruções.
Compilar:
cmake -B build && cmake --build build -j 8Execute testes:
./test.shInstale pacotes e repositório init:
sudo dnf install cmake python lld clang nasm libX11-devel libXrandr-devel libXinerama-devel libXcursor-devel libXi-devel pulseaudio-libs-devel mesa-libGL-devel
sudo sh -c " $( curl --location https://taskfile.dev/install.sh ) " -- -d -b /usr/local/bin Compilar com clang :
cmake -DCMAKE_SHARED_LINKER_FLAGS= " -fuse-ld=lld " -DCMAKE_EXE_LINKER_FLAGS= " -fuse-ld=lld " -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -B build
cmake --build build -j $( nproc )Execute testes:
./test.shUsamos principalmente o Visual Studio no Windows para desenvolvimento em C++. Baixe a última edição da comunidade aqui. No momento em que este artigo foi escrito, este era o Visual Studio 2022.
Você precisará da carga de trabalho Desktop development with C++ . Isso pode ser selecionado durante a instalação ou depois por meio do Visual Studio Installer , modificando a instalação do Visual Studio.
No Windows, é recomendado usar um gerenciador de pacotes, usamos o Scoop. Siga as etapas na parte inferior da página inicial aqui para obtê-lo.
Depois que o Scoop estiver instalado, execute os seguintes comandos:
scoop install git llvm nasm python taskClone o repositório executando o seguinte comando na pasta de sua escolha.
git clone https://github.com/open-goal/jak-project.git Isso criará uma pasta jak-project , abra o projeto como um projeto CMake via Visual Studio.
Em seguida, construa todo o projeto como Windows Release (clang) . Você também pode pressionar Ctrl+Shift+B como tecla de atalho para Build All. Atualmente preferimos clang no Windows em vez de msvc , embora deva funcionar também!
NOTA: A execução do jogo requer um Apple Silicon Mac executando macOS Sequoia ou um Intel Mac.
Certifique-se de ter as ferramentas de linha de comando do Xcode instaladas (isso instala coisas como Apple Clang). Caso contrário, você pode executar o seguinte comando:
xcode-select --installNo Apple Silicon, o Rosetta 2 também deve ser instalado:
softwareupdate --install-rosettabrew install cmake nasm ninja go-task clang-format
cmake -B build --preset=Release-macos-x86_64-clang
cmake --build build --parallel $(( `sysctl - n hw.logicalcpu` )) brew install cmake ninja go-task clang-format
cmake -B build --preset=Release-macos-arm64-clang
cmake --build build --parallel $(( `sysctl - n hw.logicalcpu` )) Talvez seja necessário adicionar o SDK do MacOS ao seu LIBRARY_PATH :
export LIBRARY_PATH="$LIBRARY_PATH:/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib"Se você não quiser ou não puder usar o Visual Studio para trabalhar com o projeto C++, o VSCode é uma boa alternativa.
A extensão clangd é recomendada e requer que clangd esteja em seu $PATH . Se você conseguir executar clangd em um terminal com sucesso, você estará pronto para prosseguir.
Depois de gerar seu CMake pela primeira vez, o clangd LSP deverá ser capaz de indexar o projeto e fornecer inteligência.
TODO - Considere contribuir com documentação :)
Conseguir um jogo em execução envolve 4 etapas:
Primeiro, defina suas configurações para que os scripts a seguir saibam qual jogo você está usando e qual versão. Para a versão black label do jogo, execute o seguinte em um terminal:
task set-game-jak1
task set-decomp-ntscv1 Para outras versões do jogo, você precisará usar um comando -set-decomp-<VERSION> diferente. Um exemplo para a versão PAL:
task set-game-jak1
task set-decomp-palExecute
task --listpara ver as outras opções disponíveis
No momento em que este artigo foi escrito, espera-se que apenas Jak 1 funcionasse de ponta a ponta!
O primeiro passo é extrair o conteúdo do arquivo ISO para a pasta iso_data/<game-name> . No caso de Jak 1, é iso_data/jak1 .
Feito isso, abra um terminal na pasta jak-project e execute o seguinte:
task extractO próximo passo é construir o próprio jogo. Para fazer isso, no mesmo terminal execute o seguinte:
task replVocê será saudado com um prompt como este:
_____ _____ _____ _____ __
| | ___ ___ ___ | __ | | _ | |
| | | . | -_ | | | | | | | | __
| _____ | _ | ___ | _ | _ | _____ | _____ | __ | __ | _____ |
| _ |
Welcome to OpenGOAL 0.8 !
Run (repl-help) for help with common commands and REPL usage.
Run (lt) to connect to the local target.
g >Execute o seguinte para construir o jogo:
g > (mi)NOTA IMPORTANTE! Se você não estiver usando a versão não padrão do jogo, poderá encontrar problemas ao tentar executar
(mi)nesta etapa. Um exemplo de erro pode incluir algo como:
Input file iso_data/jak1/MUS/TWEAKVAL.MUS does not exist.Isso ocorre porque as entradas/saídas do descompilador usam o campo JSON
gameNamena configuração do descompilador. Por exemplo, se você estiver usando Jak 1 PAL, ele assumiráiso_data/jak1_paledecompiler_out/jak1_pal. Portanto, você pode informar o REPL/compilador sobre isso através do campo de configuraçãogameVersionFolderdescrito aqui
Finalmente o jogo pode ser executado. Abra um segundo terminal no diretório jak-project e execute o seguinte:
task boot-gameO jogo deverá inicializar automaticamente se tudo tiver sido feito corretamente.
Conectar o REPL ao jogo permite inspecionar e modificar códigos ou dados enquanto o jogo está em execução.
Para fazer isso, no REPL após um (mi) bem-sucedido, execute o seguinte:
g > (lt)Se for bem-sucedido, seu prompt deverá mudar para:
gc >Por exemplo, executar o seguinte imprimirá algumas informações básicas sobre Jak:
gc > * target * Você também pode iniciar o jogo sem inicializar. Para fazer isso, execute o seguinte em um terminal
task run-game E então no seu REPL execute o seguinte (após um sucesso (mi) ):
g > (lt)
[Listener] Socket connected established ! (took 0 tries). Waiting for version...
Got version 0.8 OK !
[Debugger] Context: valid = true, s7 = 0x147d24, base = 0x2123000000, tid = 2438049
gc > (lg)
10836466 # xa559f2 0.0000 ("game" "kernel")
gc > (test-play)
(play :use-vis # t :init-game #f) has been called!
0 # x0 0.0000 0
gc > Na janela gráfica, você pode usar a tecla de ponto final para abrir o menu de depuração. Os controladores também funcionam, usando o mesmo mapeamento do jogo original.
Confira pc_debug , examples e pastas pc em goal_src para alguns exemplos de código GOAL que escrevemos. Os arquivos de depuração que não são carregados automaticamente pelo mecanismo possuem instruções sobre como executá-los.
Existem quatro componentes principais no projeto.
goalc - o compilador GOAL para x86-64decompiler - nosso descompiladorgoal_src/ - a pasta que contém todo o código OpenGOAL/GOOSgame - também conhecido como tempo de execução escrito em C++Vamos analisar cada componente.
goalcNossa implementação de GOAL é chamada OpenGOAL.
Todo o código-fonte do compilador está em goalc/ . O compilador é controlado por meio de um prompt que pode ser usado para inserir comandos para compilar, conectar-se a um programa GOAL em execução para interação, executar o depurador OpenGOAL ou, se você estiver conectado a um programa GOAL em execução, pode ser usado como um REPL para execute o código interativamente. Além de compilar arquivos de código, o compilador possui recursos para compactar e construir arquivos de dados.
Agnóstico Ambiental
Se você instalou task conforme recomendado acima, poderá executar o compilador com task repl
Linux
Para executar o compilador no Linux, existe um script scripts/shell/gc.sh .
Windows
No Windows, há scripts/batch/gc.bat e um script scripts/batch/gc-no-lt.bat , o último dos quais não tentará se anexar automaticamente a um destino em execução.
decompilerO segundo componente do projeto é o descompilador.
O descompilador produzirá código e outros dados destinados a serem inspecionados por humanos na pasta decompiler_out . Os arquivos nesta pasta não serão usados pelo compilador.
Você deve ter uma cópia do jogo de PS2 e colocar todos os arquivos do DVD dentro de uma pasta correspondente ao jogo dentro da pasta iso_data ( jak1 para Jak 1 Black Label, etc.), como pode ser visto nesta imagem:
O descompilador extrairá os ativos para a pasta de assets . Esses ativos serão usados pelo compilador ao construir o port, e você pode querer desligar a extração de ativos depois de executá-lo uma vez.
Agnóstico Ambiental
Se você instalou task conforme recomendado acima, você pode executar o compilador com task decomp
Linux
Para executar, você pode usar scripts/shell/decomp.sh para executar o descompilador
Windows
Para executar, você pode usar scripts/shell/decomp-jak1.bat para executar o descompilador
goal_src/ O código fonte do jogo, escrito em OpenGOAL, está localizado em goal_src . Todos os códigos GOAL e GOOS devem estar nesta pasta.
game O componente final é o “tempo de execução”, localizado no game . Esta é a parte do jogo escrita em C++.
No porto, isso inclui:
game/kernel . Isto deve ser o mais próximo possível do jogo e todas as diferenças devem ser anotadas com um comentário.game/sce . As implementações de recursos de biblioteca específicos para a porta PC estão localizadas em game/system .game/overlord . Assim como o kernel C, tentamos manter isso o mais próximo possível do jogo real.989SND . O código da biblioteca e uma interface para ela estão localizados em game/sound .game/graphics . Embora muitas liberdades sejam tomadas para que isso funcione, o resultado final deve corresponder muito ao jogo real.game/assets . Isso inclui arquivos de texto extras, ícones, etc.
