Development/fr

Cet article a pour but de vous introduire au développement de DDNet. En tant que jeu open-source, il repose sur la générosité et le temps libre des contributeurs.

Environnement de développement

Il est fortement recommandé de mettre en place un environnement Linux pour commencer à programmer dans DDNet pour les raisons suivantes (à ce jour) :

• La plupart des contributeurs utilisent Linux;
• La gestion des paquets est plus facile, vous pouvez facilement installer toutes les librairies requises;
• Cet article n'a pas encore de version Windows et se concentre sur Linux.

Tout d'abord, DDNet est codé en utilisant le langage de programmation C++. Vous devrez être assez familier avec ce langage, mais vous pouvez aussi en connaître les bases et en apprendre davantage en développant sur DDNet.

Quelques ressources utiles pour apprendre le C++ :

• openclassrooms.com (bases, contient de la publicité, peut être limité en termes de pages par jour)
• openclassrooms.com (programmation orientée objet, contient de la publicité, peut être limité en termes de pages par jour)
• developpez.com (liste de tutoriels)
• cppreference.com (pour les utilisateurs avancés)

Le code source de DDNet est géré à l'aide de Git, un système de contrôle de version et un outil essentiel pour collaborer avec plusieurs développeurs.

Si vous ne disposez pas encore de git dans votre distribution Linux, veillez à l'installer, par exemple dans la plupart des distributions basées sur Debian/Ubuntu : sudo apt install git.

Obtenir le code source

Le code source se trouve sur Github, vous pouvez le récupérer en clonant le répertoire sans compte: git clone --recursive https://github.com/ddnet/ddnet.git. Cependant, vous devez avoir un compte pour proposer vos modifications à la communauté.

Si vous n'êtes pas familier avec git/github, vous pouvez apprendre les bases ici : Hello World - Github

Installer les dépendances

Sous Linux, vous pouvez installer les dépendances nécessaires en lisant le fichier README du répertoire github de DDNet: https://github.com/ddnet/ddnet#dependencies-on-linux--macos.

Pour Arch Linux :

sudo pacman -S --needed base-devel cmake curl ffmpeg freetype2 git glew glslang gmock libnotify libpng opusfile python rust sdl2 spirv-tools sqlite vulkan-headers vulkan-icd-loader wavpack x264

Pour Debian :

sudo apt install build-essential cargo cmake git glslang-tools google-mock libavcodec-extra libavdevice-dev libavfilter-dev libavformat-dev libavutil-dev libcurl4-openssl-dev libfreetype6-dev libglew-dev libnotify-dev libogg-dev libopus-dev libopusfile-dev libpng-dev libsdl2-dev libsqlite3-dev libssl-dev libvulkan-dev libwavpack-dev libx264-dev python3 rustc spirv-tools

Compiler DDNet

Nous utilisons CMake pour gérer la compilation. Une fois que toutes les dépendances sont installés (incluant CMake), vous pouvez exécuter les commandes suivantes depuis le répertoire DDNet :

mkdir build && cd build
cmake ..
make -j$(nproc)

Informations générales

Voici quelques informations générales :

• Actuellement, le code source est compilé avec le standard C++17, mais vous constaterez que de nombreuses parties du code sont plus proches du C puisque seul le nouveau code utilise des parties du standard C++17.
• std::string est rarement utilisé, les tableaux de caractères et l'utilisation des méthodes system.h pour les manipuler sont la norme.
• Tout ce qui est E/S, formatage et affichage est réalisés en utilisant les méthodes de system.h.

Disposition du code source

Maintenant que vous pouvez build DDNet, vous pouvez commencer à faire des modifications.

Répertoire src/base

Comme DDNet est un jeu multi-plateforme, une couche d'abstraction est nécessaire pour un développement plus aisé. Ce répertoire contient les fonctions utiles pour tout ce qui touche au système d'exploitation.

Répertoire src/engine

Ici se trouve le moteur de jeu qui gère tout ce qui n'est pas lié à la jouabilité, à savoir les graphismes, le son, le réseau, etc.

Répertoire src/game

Tout le code lié au gameplay est ici, séparé entre le client et le serveur.

Serveur

Le jeu repose sur un ensemble de composants qui dérivent tous de la classe mère CEntity définie dans src/game/server/entity.h.

Ces entités sont gérées par la classe CGameWorld définie dans src/game/server/gameworld.h.

Quelques entités importantes:

• CCharacter qui représente un Tee vivant. Elle est instanciée quand un tee apparaît et supprimée quand il meurt.
• CPlayer contient les informations non liées au Tee (pseudo, drapeau, etc.).

Client

Le client est lui aussi constitué de composants qui sont tous des classes dérivées de CComponent définie dans src/game/client/component.h. Ces composants peuvent implémenter les méthodes virtuelles OnInit, OnMessage, etc. pour fournir leurs fonctionnalités.

Réseau

Le protocole réseau est généré par des scripts Python qui produisent du code C++. Par exemple, le fichier datasrc/network.py définit tous les paquets réseaux.

Convention de code

La discussion sur les conventions d'écriture se trouve ici: ddnet#2945

Actuellement, ce qui suit s'applique :

Indentation

Le style d'Allman est utilisé.

Nommé d'après Eric Allman, ce style respecte un alignement strict des accolades ouvrantes et fermantes, comme dans l'exemple ci-dessous :

while(x == y)
{
    Something();
    SomethingElse();
}

FinalThing();

Classes et structures

Toutes les classes et structures doivent être précédées par un C ou un I pour les interfaces. Pour des raisons historiques, certaines structures ne l'ont pas comme dans la partie graphique.

Exemple:

class CCharacter : public CEntity
{
    // ...
}

Énumérations et constantes

Elles doivent être écrites en notation screaming snake case [1] (i.e. tout en majuscules avec un underscore _ entre les mots). Par example: MAX_PLAYERS

enum
{
	FAKETUNE_FREEZE = 1,
	FAKETUNE_SOLO = 2,
	FAKETUNE_NOJUMP = 4,
	FAKETUNE_NOCOLL = 8,
	FAKETUNE_NOHOOK = 16,
	FAKETUNE_JETPACK = 32,
	FAKETUNE_NOHAMMER = 64,
};

Convention de nommage

• Le nom des variables doit contenir 3 parties : le qualificatif, le préfixe et le nom.
• Les noms doivent commencer par une majuscule à moins qu'elle ne soit de longueur unitaire sans aucun qualificatif ou préfixe, par exemple les variables de boucle i et j.
• Les noms des variables doivent être écrits en anglais et suivent la convention camel case [2] (i.e. majuscule à chaque mot).
• Les variables peuvent avoir plus d'un qualificatif ou plus d'un préfixe.

Ils sont disposés de la manière suivante: [qualificatifs]_[préfixes][Nom].

Qualificatifs

• m pour les variables membres: m_MyVariable
• s pour les variables statiques: s_MyStaticVariable
• g pour les variables globales : gs_MyGlobalStaticVar

Préfixes

• p pour les pointeurs : pMyPointer, m_pCharacter, ppMyPointerToPointer
• a pour les tableaux : aMyArray[MAX_PLAYERS], aBuf
• v pour les std::vector : vMyVector, vpvMyVectorOfPointersToVectors.
• fn pour les fonctions : pfnMyCallback, m_papfnMyPointerToArrayOfCallbacks

Exemples courants

Voici une liste d'extraits de code que vous pouvez voir fréquemment dans la base de code :

Formatage de texte

char aBuf[128];
str_format(aBuf, sizeof(aBuf), "number: %d", 2);

Voir printf documentation pour une liste de tous les spécificateurs de format.

Itérer sur tous les joueurs

for(int i = 0; i < MAX_CLIENTS; i++)
{
    // Server-side
    CPlayer *pPlayer = GameServer()->m_apPlayers[i];
}

Afficher dans la console de jeu

Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "wikiprint", "Hello from the ddnet wiki!");

Affichage de débogage

int i = 2;
dbg_msg("wikiprint", "Hello from the ddnet wiki: %d", i)

Traduction du texte dans le client

Localize peut être utilisé dans le client du jeu pour obtenir la traduction d'un texte spécifique à partir du fichier de langue sélectionné par l'utilisateur.

DoButton(..., Localize("Connect"), ...);

Le texte peut également contenir des spécificateurs de format. La chaîne traduite doit alors contenir les mêmes spécificateurs de format.

char aBuf[128];
str_format(aBuf, sizeof(aBuf), Localize("%d of %d servers"), NumServers, TotalServers);

Un script est utilisé pour chercher dans le code les appels à Localize et collecter les chaînes de caractères pour mettre à jour les fichiers de traduction. Pour cette raison, l'appel à Localize ne doit pas contenir d'autre code, sinon le script ne peut pas déterminer le texte correctement.

// Ne faites PAS ça :
const char *pStr = Localize(Team == TEAM_RED ? "Red team" : "Blue team");

// Faites plutôt ceci :
const char *pStr = Team == TEAM_RED ? Localize("Red team") : Localize("Blue team");

Ressource externes

• UI Code in DDraceNetwork par Ryozuki
• An intro to the DDraceNetwork game source code par Ryozuki
• Code conventions in DDraceNetwork par Ryozuki
• Implementing a chat command in DDraceNetwork par Ryozuki
• Auto generated docs
• Technical documentation of Teeworlds file formats and network protocol
• The Anatomy of a One Tick Unfreeze
• Teeworlds programming YouTube tutorial par ChillerDragon
• Teeworlds 0.6/0.7 network protocol documentation par ChillerDragon

À propos du rendu des Skin

Cette section explique comment effectuer l'affichage du skin d'un Tee.

Valeurs rassemblées par Patiga
Remerciements à Jupstar

Segment Scaling:
   body: 100%
   feet: 150%
   eyes: 120%
   eye blink: 45%
   hand: 93.75%

Positioning:
   64/64 = 1 = width or height of the body segment
   body: 4/64 up
   feet:
       10/64 down
       7/64 left/right
   eyes:
       0.125 up
       0.05 left/right

   eye movement:
       dir = angle of eyes (view angle), right = 0
       eyes:
           x: cos(dir) * 0.125
           y: sin(dir) * 0.1
       each eye (away from the other):
           x: abs(cos(dir)) * 0.01