Cours de programmation côté serveur pour jeux vidéo

Leçon 1 • Concepts de boucle de jeu sur le serveur

Traduit le modèle classique de boucle de jeu en un système de ticks côté serveur. Les étudiants implémentent une boucle de mise à jour à cadence fixe qui pilote l'état de jeu faisant autorité.

Leçon 2 • Introduction à HTTP et aux WebSockets

Oppose le modèle requête-réponse de HTTP aux connexions WebSocket persistantes pour les données en temps réel. Explique pourquoi les jeux privilégient les WebSockets pour les mises à jour d'état à faible latence.

Leçon 3 • Structures de données de base pour l'état du jeu

Couvre les maps, les files d'attente et les graphes d'objets utilisés pour représenter les joueurs, les salons et les entités. Le choix de la structure appropriée impacte directement le débit du serveur et la clarté du code.

Leçon 4 • Configuration de l'environnement de développement

Installe et configure l'environnement d'exécution, le gestionnaire de paquets et les outils d'échafaudage de projet. Garantit que chaque étudiant dispose d'une base de travail fonctionnelle avant d'écrire une quelconque logique de jeu.

Leçon 1 • Gestion des salons et des salles

Crée des objets de salon côté serveur qui regroupent les joueurs avant et pendant une partie. Les salons isolent l'état du jeu et permettent des sessions indépendantes simultanées.

Leçon 2 • Gestion des erreurs et résilience des connexions

Implémente des modèles try, des événements d'erreur et des procédures d'arrêt progressif. Une gestion résiliente des erreurs empêche un seul mauvais client de faire planter l'ensemble du serveur.

Leçon 3 • Construction d'un serveur WebSocket

Implémente un serveur WebSocket à l'aide d'une bibliothèque Node.js populaire et gère les événements de connexion. Fournit la colonne vertébrale réseau pour toutes les fonctionnalités de jeu construites dans les chapitres suivants.

Leçon 4 • Gestion des connexions des joueurs

Suit les joueurs connectés avec des identifiants uniques et gère les scénarios de reconnexion avec élégance. Une gestion fiable des connexions est essentielle pour des sessions multijoueur équitables.

Leçon 1 • Implémentation des opérations CRUD

Écrit des fonctions de création, lecture, mise à jour et suppression encapsulées dans des modèles async/await. Encapsuler les appels à la base de données dans des modules de service maintient la logique de jeu propre.

Leçon 2 • Choix d'une base de données pour les données de jeu

Compare les bases de données relationnelles et documentaires en termes de latence, de flexibilité du schéma et de besoins de requêtes. Le bon choix dépend des relations entre les données et des modèles de lecture-écriture.

Leçon 3 • Mise en cache des données fréquemment consultées

Introduit une couche de cache en mémoire pour réduire les allers-retours vers la base de données pour les données chaudes. La mise en cache des classements et des profils réduit considérablement les temps de réponse du serveur.

Leçon 4 • Modélisation des données des joueurs et des parties

Conçoit des schémas pour les profils des joueurs, les enregistrements de parties et les entrées de classement. Une bonne conception de schéma réduit la complexité des requêtes et prend en charge les futures fonctionnalités.

Leçon 1 • Résolution de conflits et rollback

Gère les actions conflictuelles simultanées de plusieurs joueurs via un arbitrage côté serveur. Les étudiants implémentent un mécanisme de rollback simple pour les mouvements rejetés.

Leçon 2 • Application et diffusion des changements d'état

Met à jour l'état de jeu canonique et pousse les deltas vers tous les clients concernés de manière atomique. Les mises à jour atomiques empêchent les clients d'observer des états intermédiaires incohérents.

Leçon 3 • Persistance des instantanés de l'état du jeu

Sauvegarde des instantanés périodiques de l'état en mémoire ou sur disque pour la reprise après incident et le rejeu. Les instantanés permettent aux serveurs de reprendre des sessions interrompues sans perte de données.

Leçon 4 • Validation des entrées du joueur sur le serveur

Applique des vérifications de règles avant de modifier l'état du jeu pour rejeter les mouvements tricheurs ou mal formés. La validation côté serveur est la principale défense contre la manipulation par le client.

Leçon 1 • Enregistrement des utilisateurs et sécurité des mots de passe

Implémente des points de terminaison d'enregistrement avec un stockage de mot de passe haché à l'aide d'un algorithme fort. Le stockage sécurisé des identifiants est le fondement de toutes les fonctionnalités d'authentification ultérieures.

Leçon 2 • Contrôle d'accès basé sur les rôles

Attribue les rôles de joueur, modérateur et administrateur et les applique sur les actions sensibles du serveur. Le RBAC empêche les joueurs ordinaires d'accéder aux commandes administratives du jeu.

Leçon 3 • Sécurisation contre les attaques d'authentification courantes

Atténue les attaques par force brute, de vol de jeton et de rejeu avec des contre-mesures côté serveur. Un durcissement proactif réduit la surface d'attaque avant la mise en production du jeu.

Leçon 4 • Authentification basée sur des jetons

Émet des JSON Web Tokens signés lors de la connexion et les vérifie sur chaque requête protégée. Les jetons sans état montent en charge sur plusieurs instances de serveur sans stockage de session partagé.

Leçon 1 • Application des pénalités et des bannissements

Applique des avertissements, des suspensions temporaires et des bannissements permanents via un moteur de politique côté serveur. Une application automatisée cohérente dissuade la triche et maintient la confiance de la communauté.

Leçon 2 • Gestion des tours et mise en file d'attente des actions

Implémente des séquences de tour ordonnées et met en file d'attente les actions simultanées pour un traitement équitable. Une mise en file d'attente appropriée élimine les conditions de course dans les scénarios multijoueur compétitifs.

Leçon 3 • Codage des règles du jeu en tant que logique serveur

Traduit les documents de game design en fonctions de règles pures côté serveur sans aucune confiance client. La centralisation des règles garantit que tous les clients vivent un gameplay identique et équitable.

Leçon 4 • Physique et collision sur le serveur

Exécute des contrôles de physique légers côté serveur pour valider les mouvements et les revendications de collision. La physique serveur empêche les piratages de téléportation et de vitesse signalés par les clients.

Leçon 1 • Profilage des performances du serveur

Utilise des outils de profilage intégrés et tiers pour identifier les goulots d'étranglement CPU et mémoire. Profiler avant d'optimiser évite de gaspiller des efforts sur des chemins de code non critiques.

Leçon 2 • Optimisation des requêtes de base de données

Réécrit les requêtes lentes, ajoute des index et introduit le pooling de connexions pour un débit élevé. Les goulots d'étranglement de la base de données sont souvent la première contrainte d'évolutivité dans les jeux en direct.

Leçon 3 • Équilibrage de charge du trafic de jeu

Configure un répartiteur de charge pour répartir les connexions WebSocket sur les instances de serveur. Un équilibrage approprié empêche les points chauds et garantit une utilisation uniforme des ressources.

Leçon 4 • Optimisation de la boucle de jeu et de la cadence de ticks

Réduit le coût de calcul par tick grâce au traitement par lots, aux sorties précoces et au partitionnement spatial. Des ticks efficaces permettent un nombre de joueurs plus élevé sans augmenter les coûts matériels du serveur.

Leçon 1 • Métriques, tableaux de bord et alertes

Expose les métriques du serveur et construit des tableaux de bord pour visualiser le nombre de joueurs, la latence et les erreurs. Les alertes proactives détectent les régressions avant que les joueurs ne les signalent.

Leçon 2 • Mises à jour sans interruption de service et correctifs à chaud

Applique des déploiements bleu-vert et une vidange progressive pour mettre à jour les serveurs sans déconnecter les joueurs. Les opérations de jeu en direct exigent des stratégies de mise à jour qui préservent les sessions actives.

Leçon 3 • Conteneurisation du serveur de jeu

Empaquete le serveur et ses dépendances dans une image conteneur pour des déploiements cohérents. Les conteneurs éliminent les dérives d'environnement entre le développement, le préproduction et la production.

Leçon 4 • Pipeline CI/CD pour les serveurs de jeu

Automatise les étapes de construction, de test et de déploiement afin que chaque fusion de code atteigne la production en toute sécurité. Les pipelines automatisés réduisent les erreurs humaines et accélèrent la cadence de publication.