jak-project

[!IMPORTANT] Nos dépôts sur GitHub sont principalement destinés au développement du projet et au suivi des enjeux actifs. La plupart des informations que vous...

Dépôt créer le : 22/08/2020

Release du : 11/03/2026 v0.2.31

Forks: 210 Watcher: 0 3245

Github: https://github.com/open-goal/jak-project

Ajouter à une sélection :

Connectez-vous pour gérer vos sélections.

Veuillez lire en premier

[!IMPORTANT] Nos dépôts sur GitHub sont principalement destinés au développement du projet et au suivi des enjeux actifs. La plupart des informations que vous trouverez ici concernent la mise en place du projet à des fins de développement et ne sont pas pertinentes pour l'utilisateur final.

Pour un guide de configuration sur la façon d'installer et de jouer le jeu, il y a la vidéo suivante que vous pouvez vérifier: https://youtu.be/K84UUMnkJc4

Pour des questions ou des renseignements supplémentaires sur le projet, nous avons un désaccord à discuter ici : https://discord.gg/VZbXMHXzWv

En outre, vous pouvez trouver d'autres documents et réponses àquestions fréquemment poséessur le site web principal du projet: https://opengoal.dev

[!ARRÊT] N'utilisez pas ce projet de décompilation sans fournir votre propre copie légalement achetée du jeu.Nous ne distribuons aucun actif du jeu - vous devez utiliser votre propre copie PS2 légitimement obtenu du jeu. Nous soutenons toutes les constructions PAL, NTSC et NTSC-J, y compris les copies Greatest Hits.

Project Description
- Current Status
- Methodology
Setting up a Development Environment
Technical Project Overview

Description du projet

Ce projet doit porter les Jak et Daxter originaux et Jak II sur PC. Plus de 98% des jeux sont écrits en GOAL, un langage Lisp personnalisé développé par Naughty Dog. Notre stratégie est :

décompiler le code de jeu original en code GOAL lisible par l'homme
développer notre propre compilateur pour GOAL et recompiler le code de jeu pour x86-64
créer un outil pour extraire des actifs de jeu dans des formats qui peuvent être facilement vus ou modifiés
créer des outils pour reconditionner les actifs du jeu dans un format que notre port utilise.

Nos objectifs sont les suivants :

faire du port une "application indigène" sur x86-64, avec des performances élevées. Il ne devrait pas être ému, interprété ou transpiré.
Les performances de notre compilateur GOAL devraient être les mêmes que celles de C non optimisé.
essayer de faire correspondre les choses du jeu original et le développement que possible. Par exemple, le compilateur GOAL d'origine a pris en charge la modification en direct du code pendant que le jeu est en cours d'exécution, donc nous faisons la même chose, même si ce n'est pas nécessaire pour juste porter le jeu.
des modifications de soutien. Il devrait être possible de faire des modifications au code sans que tout le reste se brise.

Nous soutenons Linux et Windows sur x86-64.

Nous ne soutenons pas, ni ne prévoyons de soutenir l'architecture ARM. Cela signifie que cela ne fonctionnera pas sur des appareils comme un appareil mobile.

État actuel

Jak 1 est largement jouable du début à la fin avec une poignée d'insectes qui sont continuellement repassés. Jak 2 est en développement.

Liste de lecture YouTube : https://www.youtube.com/playlist?list=PLWx9T30aAT50cLnCTY1Sabt2TtWQzKfXX

Méthodologie

Pour aider à décompiler, nous avons construit un décompilateur qui peut traiter le code GOAL et décompresser les actifs du jeu. Nous spécifions manuellement les types de fonctions et les emplacements où nous croyons que le code original avait des castes de type (ou où ils se sentent appropriés) jusqu'à ce que le décompilateur réussisse, puis nous nettoyons la sortie du code décompilé en ajoutant des commentaires et en adaptant le formatage, puis nous l'enregistrons dansgoal_src.

Notre décompilateur est spécialement conçu pour traiter la sortie du compilateur GOAL original. En conséquence, lorsqu'il est donné des castes correctes, il produit souvent un code qui peut être directement introduit dans un compilateur et fonctionne parfaitement. Ceci est continuellement testé dans le cadre de nos tests unitaires.

Mise en place d'un environnement de développement

Le reste de ce README est destiné aux personnes intéressées à construire le projet à partir de la source, généralement avec l'intention de contribuer en tant que développeur.

Si cela ne vous ressemble pas et que vous voulez juste jouer au jeu, référez-vous à la section ci-dessusQuick Start

Coq

Les trois systèmes Linux sont pris en charge par Docker.

Choisissez votre saveur préférée de linux et construisez votre image choisie

docker build -f docker/(Arch|Fedora|Ubuntu)/Dockerfile -t jak .

Cela créera une image avec toutes les dépendances requises et déjà construite.

docker run -v "$(pwd)"/build:/home/jak/jak-project/build -it jak bash

Remarque: Si vous modifiez le contenu de labuild/répertoire que vous aurez besoin de réexécuter lebuildcommande. Sinon, vous pouvez obtenir la construction viadocker cp.

Cela liera votrebuild/dossier vers les images ainsi peut valider votre construction ou le tester sur un périphérique externe.

Les images Docker peuvent être reliées à votre IDE (p. ex. CLion) pour faciliter le codage, l'analyse statique, les tests d'exécution et la construction continue.

Malheureusement, vous aurez toujours besoin de la tâche coureur sur votre machine locale pour exécuter le jeu ou plutôt, exécuter manuellement le jeu via les commandes trouvées dansTaskfile.yml.

Linux

Ubuntu (20.04)

Installer les paquets et le dépôt 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/bin

Compiler:

cmake -B build && cmake --build build -j 8

Essais d'exécution:

./test.sh

Remarque : nous avons trouvé queclangetlldsont beaucoup plus rapides à compiler et à relier quegcc, générer un code plus rapide et avoir de meilleurs messages d'avertissement. Pour les installer :

sudo apt install lld clang

et courircmake(dans un nouveau répertoire de construction) avec:

cmake -DCMAKE_SHARED_LINKER_FLAGS="-fuse-ld=lld" -DCMAKE_EXE_LINKER_FLAGS="-fuse-ld=lld" -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ ..

Arche

Installer les paquets et le dépôt init :

sudo pacman -S cmake libpulse base-devel nasm python libx11 libxrandr libxinerama libxcursor libxi
yay -S go-task

Pour Arch seulement, remplacertaskavecgo-taskdans le reste des instructions.

Compiler:

cmake -B build && cmake --build build -j 8

Essais d'exécution:

./test.sh

Fedora

Installer les paquets et le dépôt 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

Compiler avecclang:

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)

Essais d'exécution:

./test.sh

Windows

Logiciel requis

Nous utilisons principalement Visual Studio sur Windows pour le développement de C++. Téléchargez la dernière édition communautaire dehere. Au moment de l'écriture, c'est Visual Studio 2022.

Vous devrezDesktop development with C++charge de travail. Ceci peut être sélectionné pendant l'installation, ou après viaVisual Studio Installer, modifier l'installation de Visual Studio.

Sur Windows, il est recommandé d'utiliser un gestionnaire de paquets, nous utilisons Scoop. Suivez les étapes en bas de la page d'accueilherepour l'avoir.

Une fois que Scoop est installé, exécutez les commandes suivantes :

scoop install git llvm nasm python task

Utilisation de Visual Studio

Cloner le dépôt en exécutant la commande suivante dans votre dossier de choix.

git clone https://github.com/open-goal/jak-project.git

Cela créera unejak-projectdossier, ouvrez le projet en tant que projet CMake via Visual Studio.

Ensuite, construire le projet entier commeWindows Release (clang). Vous pouvez également appuyer sur Ctrl+Shift+B en tant que hotkey pour Build All. Nous préféronsclangsur Windows par opposition àmsvc, bien que cela devrait fonctionner aussi bien!

MacOS

REMARQUE: L'exécution du jeu nécessite un Mac Apple Silicon qui exécute macOS Sequoia, ou un Mac Intel.

Assurez-vous que vous avez installé des outils en ligne de commande Xcode (ceci installe des choses comme Apple Clang). Si vous ne le faites pas, vous pouvez exécuter la commande suivante :

xcode-select --install

Sur Apple Silicon, Rosetta 2 doit également être installé:

softwareupdate --install-rosetta

Bâtiment pour x86 64

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

Bâtiment pour ARM64 (expérimental, sans support)

brew install cmake ninja go-task clang-format
cmake -B build --preset=Release-macos-arm64-clang
cmake --build build --parallel $((`sysctl -n hw.logicalcpu`))

Vous devrez peut-être ajouter le SDK MacOS à votreLIBRARY_PATH:

export LIBRARY_PATH="$LIBRARY_PATH:/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib"

Code VS

Si vous ne voulez pas ou ne pouvez pas utiliser Visual Studio pour travailler avec le projet C++, VSCode est une bonne alternative.

Lesclangdextension estrecommendedet nécessiteclangdêtre sur votre$PATH. Si vous pouvez courirclangddans un terminal avec succès alors vous devriez être prêt à partir.

Une fois que vous avez généré votre CMake pour la première fois, le LSP clangd devrait pouvoir indexer le projet et vous donner de l'intelligence.

Construction et débogage

TODO - Envisager de contribuer à la documentation :)

Construire et exécuter le jeu

Obtenir un jeu en cours d'exécution implique 4 étapes:

Construire des outils C++ (suivre les étapes de démarrage ci-dessus pour votre plateforme)
Extraire des actifs du jeu
Construisez le jeu
Lancez le jeu

Extraire des actifs

Tout d'abord, configurer vos paramètres afin que les scripts suivants sachent quel jeu vous utilisez, et quelle version. Pour la version de marque noire du jeu, exécutez ce qui suit dans un terminal:

task set-game-jak1
task set-decomp-ntscv1

Pour d'autres versions du jeu, vous devrez utiliser un autre-set-decomp-<VERSION>commande. Un exemple pour la version PAL:

task set-game-jak1
task set-decomp-pal

Exécutertask --listpour voir les autres options disponibles

Au moment de l'écriture, seul Jak 1 devrait fonctionner de bout en bout !

La première étape consiste à extraire le contenu de votre fichier ISOiso_data/<game-name>dossier. Dans le cas de Jak 1iso_data/jak1.

Une fois cela fait, ouvrir un terminal dans lejak-projectdossier et exécutez ce qui suit :

task extract

Construire le jeu

La prochaine étape est de construire le jeu lui-même. Pour ce faire, le même terminal exécute les opérations suivantes:

task repl

Vous serez accueilli avec une prompte comme ceci:

 _____             _____ _____ _____ __
|     |___ ___ ___|   __|     |  _  |  |
|  |  | . | -_|   |  |  |  |  |     |  |__
|_____|  _|___|_|_|_____|_____|__|__|_____|
      |_|
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 >

Exécutez ce qui suit pour construire le jeu:

g > (mi)

Remarque importante ! Si vous n'utilisez pas la version non par défaut du jeu, vous pouvez frapper des problèmes en essayant d'exécuter(mi)dans cette étape. Une erreur d'exemple peut inclure quelque chose comme:

Input file iso_data/jak1/MUS/TWEAKVAL.MUS does not exist.

C'est parce que les entrées/sorties de décompilateurgameNameChamp JSON dans la configuration de décompilateur. Par exemple, si vous utilisez Jak 1 PAL, il supposeraiso_data/jak1_paletdecompiler_out/jak1_pal. Par conséquent, vous pouvez en informer le REPL/compilateurgameVersionFolderchamp de configuration décrithere

Lance le jeu

Enfin le jeu peut être lancé. Ouvrir un deuxième terminal à partir dujak-projectrépertoire et exécutez les opérations suivantes:

task boot-game

Le jeu devrait démarrer automatiquement si tout était fait correctement.

Connexion du REPL au jeu

La connexion du REPL au jeu vous permet d'inspecter et de modifier le code ou les données pendant le jeu.

Pour ce faire, dans le REPL après un succès(mi), exécuter les opérations suivantes:

g > (lt)

Si vous réussissez, votre promptitude devrait changer pour :

gc>

Par exemple, exécuter ce qui suit va imprimer quelques informations de base sur Jak:

gc> *target*

Exécuter le jeu sans auto-boting

Vous pouvez également démarrer le jeu sans démarrer. Pour ce faire, lancez ce qui suit dans un terminal

task run-game

Et puis dans votre REPL, lancez ce qui suit (après un succès(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>

Interagir avec le jeu

Dans la fenêtre graphique, vous pouvez utiliser la touche période pour faire apparaître le menu debug. Les contrôleurs fonctionnent également, en utilisant la même cartographie que le jeu original.

Regardezpc_debug,examplesetpcdossiers sousgoal_srcpour quelques exemples de code GOAL que nous avons écrits. Les fichiers de débogage qui ne sont pas chargés automatiquement par le moteur ont des instructions pour les exécuter.

Aperçu du projet technique

Le projet comporte quatre composantes principales.

goalc- le compilateur GOAL pour x86-64
decompiler- notre décompilateur
goal_src/- le dossier contenant tout le code OpenGOAL / GOOS
game- aka l'exécution écrite en C++

Découpons chaque composant.

`goalc`

Notre mise en œuvre de GOAL s'appelle OpenGOAL.

Tout le code source du compilateur est dansgoalc/. Le compilateur est contrôlé par une invite qui peut être utilisée pour entrer des commandes pour compiler, se connecter à un programme GOAL en cours d'exécution pour l'interaction, exécuter le débogueur OpenGOAL, ou, si vous êtes connecté à un programme GOAL en cours d'exécution, peut être utilisé comme un REPL pour exécuter le code interactivement. En plus de compiler des fichiers de code, le compilateur a des fonctionnalités pour emballer et construire des fichiers de données.

Lancer le compilateur

Environnement Agnostique

Si vous avez installétaskcomme recommandé ci-dessus, vous pouvez lancer le compilateur avectask repl

Linux

Pour exécuter le compilateur sous Linux, il y a un scriptscripts/shell/gc.sh.

Windows

Sous Windows, il y ascripts/batch/gc.batscripts et unscripts/batch/gc-no-lt.batscript, dont ce dernier ne tentera pas de s'attacher automatiquement à une cible en cours d'exécution.

`decompiler`

Le deuxième élément du projet est le décompilateur.

Le décompilateur affichera le code et d'autres données destinées à être inspectées par l'hommedecompiler_outdossier. Les fichiers de ce dossier ne seront pas utilisés par le compilateur.

Lancer le décompilateur

Vous devez avoir une copie du jeu PS2 et placer tous les fichiers du DVD dans un dossier correspondant au jeu dansiso_datadossier (jak1pour Jak 1 Black Label, etc.), comme le montre cette image:

Le décompilateur va extraire des actifsassetsdossier. Ces actifs seront utilisés par le compilateur lors de la construction du port, et vous pouvez désactiver l'extraction des actifs après l'avoir exécuté une fois.

Environnement Agnostique

Si vous avez installétaskcomme recommandé ci-dessus, vous pouvez lancer le compilateur avectask decomp

Linux

Pour courir, vous pouvez utiliserscripts/shell/decomp.shpour exécuter le décompilateur

Windows

Pour courir, vous pouvez utiliserscripts/shell/decomp-jak1.batpour exécuter le décompilateur

`goal_src/`

Le code source du jeu, écrit dans OpenGOAL, se trouve dansgoal_src. Tous les codes GOAL et GOOS doivent être dans ce dossier.

`game`durée

Le dernier élément est le "temps de run", situé dansgame. C'est la partie du jeu qui est écrite en C++.

Dans le port, cela comprend:

Le "C Kernel", qui contient le lien GOAL et quelques fonctionnalités de langue GOAL de bas niveau. GOAL a un format de fichier objet entièrement personnalisé et dynamiquement lié, donc pour charger le premier code GOAL, vous avez besoin d'un lien écrit en C++. Certaines fonctions de bas niveau pour l'attribution de la mémoire, en communiquant avec le processeur d'E/S, table de symboles, chaînes de caractères et le système de type sont également implémentés en C, car elles sont nécessaires pour le linker. Il écoute également les messages entrants du compilateur et les transmet au jeu en cours d'exécution. Cela initialise également le jeu, en initialisant le matériel PS2, en attribuant les tas GOAL, en chargeant le noyau GOAL hors du DVD, et en exécutant la fonction de régulateur de noyau. C'est dans legame/kerneldossier. Ceci devrait être le plus proche possible du jeu, et toutes les différences devraient être notées avec un commentaire.
Mise en œuvre de la bibliothèque standard de Sony. GOAL code peut appeler des fonctions de bibliothèque C, et Naughty Dog a utilisé certaines fonctions de bibliothèque Sony pour accéder aux fichiers, cartes mémoire, contrôleurs, et communiquer avec le processeur d'E/S séparé. Les fonctions de la bibliothèque sontgame/sce. Les implémentations de fonctions de bibliothèque spécifiques au port PC sont situées dansgame/system.
Le pilote I/O Processor, OverLORD. Le PS2 avait un processeur distinct appelé I/O Processor (IOP) qui était directement connecté au matériel du lecteur DVD et au matériel sonore. Naughty Dog a créé un pilote personnalisé pour l'IPO qui a géré les données en streaming hors du DVD. C'est beaucoup plus compliqué que je ne le pensais. Il est situé dansgame/overlord. Comme le noyau C, nous essayons de garder ceci le plus près possible du jeu réel.
Code sonore. Coquin Dog a utilisé une bibliothèque tierce pour le son appelé989SND. Code pour la bibliothèque et une interface pour elle est situé dansgame/sound.
Code graphique spécifique au PC. Nous avons un rendu OpenGL fonctionnel et un contexte qui peut créer une fenêtre de jeu et afficher des graphiques dessus. Les rendus spécifiques utilisés par le jeu cependant sont principalement mis en œuvre. Outre les effets post-traitement, tout dans le jeu est rendu. Ceci est situé dansgame/graphics. Alors que de nombreuses libertés seront prises pour faire ce travail, le résultat final devrait très étroitement correspondre au jeu réel.
Les actifs supplémentaires utilisés par le port d'une certaine façon, situé dansgame/assets. Ils comprennent des fichiers texte supplémentaires, des icônes, etc.