Fiches de projet en programmation C/C++

TEUGUIA TADJUIDJE Séderis Rodolf

Ingénieur en Génie Informatique
Spécialité : Game Programming
teuguiasederis@[Link]
(+237) 693 761 773

27 novembre 2024
Table des matières

1 Consignes générales pour les projets 5

1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2 Structure et Approfondissement . . . . . . . . . . . . . . . . . . . . . . . 5
1.3 Choix des Projets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.4 Obligations Relatives aux Questions de Cours . . . . . . . . . . . . . . . 5
1.5 Conseils pour un Code de Qualité . . . . . . . . . . . . . . . . . . . . . . 5
1.6 Suggestions pour Enrichir Vos Projets . . . . . . . . . . . . . . . . . . . . 6
1.7 Évaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2 Gestionnaire de Réservations d’un Cinéma 7

2.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 Spécifications générales . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3 Étape 1 : Initialisation des structures de données . . . . . . . . . . . . . . 7
2.3.1 Question 1 : Déclarez une structure Siege . . . . . . . . . . . . . 7
2.3.2 Question 2 : Déclarez une structure Salle . . . . . . . . . . . . . 8
2.3.3 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.4 Étape 2 : Gestion des réservations . . . . . . . . . . . . . . . . . . . . . . 8
2.4.1 Question 1 : Réserver plusieurs sièges . . . . . . . . . . . . . . . . 8
2.4.2 Question 2 : Vérification des sièges . . . . . . . . . . . . . . . . . 8
2.4.3 Question 3 : Récapitulatif de réservation . . . . . . . . . . . . . . 8
2.5 Étape 3 : Paiement et confirmation . . . . . . . . . . . . . . . . . . . . . 8
2.5.1 Question 1 : Confirmer une réservation . . . . . . . . . . . . . . . 8
2.5.2 Question 2 : Annuler une réservation . . . . . . . . . . . . . . . . 8
2.6 Étape 4 : Gestion financière . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.6.1 Question 1 : Structure des revenus . . . . . . . . . . . . . . . . . 9
2.6.2 Question 2 : Calcul des revenus . . . . . . . . . . . . . . . . . . . 9
2.7 Étape 5 : Menu principal et boucle d’application . . . . . . . . . . . . . . 9
2.7.1 Question 1 : Menu principal . . . . . . . . . . . . . . . . . . . . . 9
2.7.2 Question 2 : Boucle d’application . . . . . . . . . . . . . . . . . . 9
2.8 Étape 6 : Extensions optionnelles . . . . . . . . . . . . . . . . . . . . . . 9
2.9 Consignes pour les étudiants . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.10 Critères d’évaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

3 Jeu de Simulation de Combat : Battle Arena 11

3.1 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.2 Spécifications générales . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.2.1 Personnages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.2.2 Système de combat . . . . . . . . . . . . . . . . . . . . . . . . . . 11

1
 3.3 Étape 1 : Initialisation des structures de données . . . . . . . . . . . . . . 12
3.3.1 Question 1 : Déclarez une structure Personnage . . . . . . . . . . 12
3.3.2 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.4 Étape 2 : Choix des personnages . . . . . . . . . . . . . . . . . . . . . . . 12
3.4.1 Question 1 : Liste des personnages disponibles . . . . . . . . . . . 12
3.4.2 Question 2 : Sélection des personnages . . . . . . . . . . . . . . . 12
3.5 Étape 3 : Mécanique du combat . . . . . . . . . . . . . . . . . . . . . . . 12
3.5.1 Question 1 : Déterminez le premier joueur . . . . . . . . . . . . . 12
3.5.2 Question 2 : Actions possibles . . . . . . . . . . . . . . . . . . . . 12
3.6 Étape 4 : IA simple pour l’adversaire . . . . . . . . . . . . . . . . . . . . 13
3.6.1 Question 1 : Stratégie de l’IA . . . . . . . . . . . . . . . . . . . . 13
3.6.2 Question 2 : Affichage des actions de l’IA . . . . . . . . . . . . . . 13
3.7 Étape 5 : Boucle principale . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.7.1 Question 1 : Structure de la boucle . . . . . . . . . . . . . . . . . 13
3.8 Étape 6 : Extensions optionnelles . . . . . . . . . . . . . . . . . . . . . . 13
3.9 Exemple de menu principal . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.10 Consignes pour les étudiants . . . . . . . . . . . . . . . . . . . . . . . . . 14

4 Gestionnaire de Bibliothèque Virtuelle 15

4.1 Spécifications générales . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.1.1 Structure des données . . . . . . . . . . . . . . . . . . . . . . . . 15
4.1.2 Fonctionnalités principales . . . . . . . . . . . . . . . . . . . . . . 15
4.1.3 Menu principal . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.2 Étape 1 : Définition des structures et initialisation . . . . . . . . . . . . . 15
4.3 Étape 2 : Ajouter un livre . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.4 Étape 3 : Afficher les livres . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.5 Étape 4 : Rechercher un livre . . . . . . . . . . . . . . . . . . . . . . . . 17
4.6 Étape 5 : Emprunter et rendre un livre . . . . . . . . . . . . . . . . . . . 17
4.7 Étape 6 : Sauvegarde et chargement des données . . . . . . . . . . . . . . 17
4.8 Étape 7 : Boucle principale et menu interactif . . . . . . . . . . . . . . . 18
4.9 Extensions optionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

5 Implémentation d’un Réseau de Neurones de Base en C++ 19

5.1 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
5.2 Concepts couverts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
5.3 Étape 1 : Définir les structures de base . . . . . . . . . . . . . . . . . . . 19
5.3.1 Question 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
5.3.2 Question 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
5.3.3 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.4 Étape 2 : Définir le réseau de neurones . . . . . . . . . . . . . . . . . . . 20
5.4.1 Question 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.4.2 Question 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.4.3 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.5 Étape 3 : Implémenter la propagation avant . . . . . . . . . . . . . . . . 20
5.5.1 Question 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.6 Étape 4 : Implémenter la rétropropagation . . . . . . . . . . . . . . . . . 21
5.6.1 Question 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.6.2 Question 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

2
 5.7 Étape 5 : Entraîner le réseau sur le problème XOR . . . . . . . . . . . . 21
5.7.1 Question 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.7.2 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.8 Étape 6 : Sauvegarde et chargement du modèle . . . . . . . . . . . . . . 22
5.8.1 Question 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
5.8.2 Question 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
5.9 Étape 7 : Tester le réseau . . . . . . . . . . . . . . . . . . . . . . . . . . 22
5.10 Extensions optionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
5.11 Critères d’évaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

6 Projet : Implémentation d’un Réseau de Neurones de Base en C++ 23

6.1 Étape 1 : Définir les structures de base . . . . . . . . . . . . . . . . . . . 23
6.2 Étape 2 : Définir le réseau de neurones . . . . . . . . . . . . . . . . . . . 24
6.3 Étape 3 : Implémenter la propagation avant . . . . . . . . . . . . . . . . 24
6.4 Étape 4 : Implémenter la rétropropagation . . . . . . . . . . . . . . . . . 25
6.5 Étape 5 : Entraîner le réseau sur le problème XOR . . . . . . . . . . . . 25
6.6 Étape 6 : Sauvegarde et chargement du modèle . . . . . . . . . . . . . . 26
6.7 Étape 7 : Tester le réseau . . . . . . . . . . . . . . . . . . . . . . . . . . 26

7 Jeu de Puzzle Numérique - Résoudre un Sudoku 27

7.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
7.2 Étape 1 : Représentation du Sudoku . . . . . . . . . . . . . . . . . . . . 27
7.2.1 Structure de données . . . . . . . . . . . . . . . . . . . . . . . . . 27
7.2.2 Initialisation de la grille . . . . . . . . . . . . . . . . . . . . . . . 27
7.2.3 Affichage de la grille . . . . . . . . . . . . . . . . . . . . . . . . . 28
7.3 Étape 2 : Générer un puzzle Sudoku . . . . . . . . . . . . . . . . . . . . . 28
7.3.1 Génération du puzzle . . . . . . . . . . . . . . . . . . . . . . . . . 28
7.4 Étape 3 : Interaction avec l’utilisateur . . . . . . . . . . . . . . . . . . . . 28
7.4.1 Entrée de l’utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . 28
7.5 Étape 4 : Résolution automatique avec Backtracking . . . . . . . . . . . 29
7.5.1 Algorithme de backtracking . . . . . . . . . . . . . . . . . . . . . 29
7.6 Étape 5 : Validation des entrées utilisateur . . . . . . . . . . . . . . . . . 29
7.6.1 Validation des entrées . . . . . . . . . . . . . . . . . . . . . . . . 29
7.7 Étape 6 : Sauvegarde et chargement du puzzle . . . . . . . . . . . . . . . 29
7.7.1 Sauvegarde du puzzle . . . . . . . . . . . . . . . . . . . . . . . . . 29
7.8 Étape 7 : Boucle du jeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
7.8.1 Menu du jeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
7.9 Étape 8 : Extensions optionnelles . . . . . . . . . . . . . . . . . . . . . . 30
7.9.1 Mode chronométré . . . . . . . . . . . . . . . . . . . . . . . . . . 30
7.9.2 Niveaux de difficulté . . . . . . . . . . . . . . . . . . . . . . . . . 30
7.9.3 Interface graphique . . . . . . . . . . . . . . . . . . . . . . . . . . 30
7.10 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

8 Jeu de Gestion de Ville (CityBuilder) 31

8.1 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
8.2 Étape 1 : Représentation des bâtiments et des ressources . . . . . . . . . 31
8.2.1 Question 1 : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
8.2.2 Exercice : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
8.3 Étape 2 : Gestion des ressources . . . . . . . . . . . . . . . . . . . . . . . 32

3
 8.3.1 Question 2 : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
8.3.2 Exercice : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
8.4 Étape 3 : Construction des bâtiments . . . . . . . . . . . . . . . . . . . . 32
8.4.1 Question 3 : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
8.4.2 Exercice : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
8.5 Étape 4 : Boucle de jeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
8.5.1 Question 4 : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
8.5.2 Exercice : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
8.6 Étape 5 : Victoire et défaite . . . . . . . . . . . . . . . . . . . . . . . . . 33
8.6.1 Question 5 : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
8.6.2 Exercice : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
8.7 Étape 6 : Extensions optionnelles . . . . . . . . . . . . . . . . . . . . . . 34
8.7.1 1. Événements aléatoires : . . . . . . . . . . . . . . . . . . . . . . 34
8.7.2 Exercice : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
8.7.3 2. Gestion des taxes et des politiques : . . . . . . . . . . . . . . . 34
8.7.4 Exercice : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
8.7.5 3. Gestion avancée : . . . . . . . . . . . . . . . . . . . . . . . . . . 34
8.8 Objectifs pédagogiques : . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

9 Jeu du Démineur 35
9.1 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
9.2 Étape 1 : Représentation du terrain . . . . . . . . . . . . . . . . . . . . . 35
9.2.1 Question 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
9.2.2 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
9.3 Étape 2 : Initialisation du terrain . . . . . . . . . . . . . . . . . . . . . . 36
9.3.1 Question 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
9.3.2 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
9.4 Étape 3 : Interaction avec le joueur . . . . . . . . . . . . . . . . . . . . . 36
9.4.1 Question 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
9.4.2 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
9.5 Étape 4 : Boucle de jeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
9.5.1 Question 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
9.5.2 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
9.6 Étape 5 : Conditions de victoire et défaite . . . . . . . . . . . . . . . . . 37
9.6.1 Question 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
9.6.2 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
9.7 Étape 6 : Extensions optionnelles . . . . . . . . . . . . . . . . . . . . . . 38
9.7.1 1. Niveau de difficulté . . . . . . . . . . . . . . . . . . . . . . . . 38
9.7.2 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
9.7.3 2. Chronomètre . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
9.7.4 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
9.7.5 3. Sauvegarde et reprise . . . . . . . . . . . . . . . . . . . . . . . 38
9.7.6 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
9.8 Objectifs pédagogiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

4
Chapitre 1

Consignes générales pour les projets

1.1 Introduction
Ce document présente les consignes générales pour la réalisation des projets. Il est
important de suivre ces recommandations afin de garantir la qualité et la pertinence de
votre travail.

1.2 Structure et Approfondissement

Les étudiants sont encouragés à enrichir chaque projet en intégrant des structures de
données, des énumérations ou des unions qui peuvent approfondir leur compréhen-
sion des concepts abordés. L’ajout de fonctionnalités supplémentaires est également
recommandé pour rendre le projet plus complet et adapté à des cas pratiques.

1.3 Choix des Projets

Un seul projet parmi ceux proposés est obligatoire. Cependant, il est fortement
conseillé de réaliser plusieurs projets pour renforcer vos compétences et diversifier vos
expériences. Cela vous permettra d’explorer différentes facettes de la programmation.

1.4 Obligations Relatives aux Questions de Cours

Les questions de cours associées à chaque étape de chaque projet sont obligatoires
pour tous les étudiants, même si le projet correspondant n’est pas réalisé. Ces questions
visent à vérifier votre compréhension des concepts et outils nécessaires à la mise en œuvre
des projets.

1.5 Conseils pour un Code de Qualité

• Modularité : Structurez votre code de manière modulaire. Divisez votre pro-
gramme en fonctions et classes bien définies, chaque module ayant une responsabi-
lité claire.
• Clarté et Lisibilité : Privilégiez la clarté au détriment de la complexité. Évitez
les constructions trop condensées et optez pour une syntaxe simple et explicite.

5
 • Nomination des Variables et Fonctions : Utilisez des noms explicites pour
vos variables et fonctions. Par exemple, préférez ‘compteur‘ à ‘x‘, afin de clarifier
leur rôle.
• Commentaires : Commentez votre code de manière judicieuse, en expliquant le
pourquoi des choix faits, plutôt que le quoi.
• Gestion des Erreurs : Implémentez une gestion des erreurs adéquate pour ga-
rantir la stabilité de votre programme face à des entrées inattendues.
• Optimisation : Bien que la lisibilité soit primordiale, gardez à l’esprit l’optimisa-
tion de votre code lorsque cela est nécessaire. La simplicité peut souvent améliorer
les performances.

1.6 Suggestions pour Enrichir Vos Projets

• Ajoutez des fonctionnalités inédites pour résoudre des problèmes connexes ou al-
ternatifs.
• Documentez vos choix dans un rapport expliquant les ajouts ou modifications ap-
portés, en justifiant leur impact sur l’amélioration du projet.

1.7 Évaluation
L’évaluation prendra en compte la qualité des implémentations, la gestion des res-
sources (mémoire, complexité) et la clarté du code. Des points supplémentaires seront
attribués pour les enrichissements pertinents et la résolution de projets supplémentaires.

6
Chapitre 2

Gestionnaire de Réservations d’un

Cinéma

2.1 Objectif
Créer une application en console permettant de gérer les réservations de places dans
une salle de cinéma. L’application devra inclure :
— La gestion des sièges.
— La prise en compte des catégories de films.
— La facturation des clients.

2.2 Spécifications générales

— Une salle de cinéma contient 10 rangées de 12 sièges chacune.
— Chaque siège peut être dans l’un des états suivants : Disponible, Réservé, ou
Occupé.
— Trois catégories de films sont disponibles :
— Standard : 5 000 FCFA.
— Premium : 7 500 FCFA.
— VIP : 10 000 FCFA.
— Une réservation permet de sélectionner plusieurs sièges en une seule opération.
— Les revenus totaux générés doivent pouvoir être affichés.
— Une boucle d’application permettra à l’utilisateur d’exécuter plusieurs actions jus-
qu’à ce qu’il décide de quitter.

2.3 Étape 1 : Initialisation des structures de données

2.3.1 Question 1 : Déclarez une structure Siege
Cette structure doit contenir :
— Son numéro unique (entier : numéro de rangée et numéro dans la rangée).
— Son état (Disponible, Réservé, ou Occupé).
— Un indicateur de catégorie (Standard, Premium, ou VIP).

7
2.3.2 Question 2 : Déclarez une structure Salle
Cette structure doit contenir :
— Un tableau bidimensionnel de Siege représentant les 10 rangées et 12 sièges.
— Une méthode d’initialisation qui affecte aléatoirement une catégorie à chaque siège.

2.3.3 Exercice
1. Écrivez une fonction pour initialiser la salle avec les catégories aléatoires.
2. Affichez en console une représentation de la salle avec l’état des sièges sous forme
de grille (D pour disponible, R pour réservé, O pour occupé).

2.4 Étape 2 : Gestion des réservations

2.4.1 Question 1 : Réserver plusieurs sièges
Écrivez une fonction permettant à un utilisateur de réserver plusieurs sièges en entrant
une liste de numéros (exemple : 1-1, 1-2 pour la rangée 1, sièges 1 et 2).

2.4.2 Question 2 : Vérification des sièges

Avant de marquer un siège comme réservé, vérifiez si ce dernier est déjà réservé ou
occupé.

2.4.3 Question 3 : Récapitulatif de réservation

Affichez un récapitulatif de la réservation, incluant :
— Le nombre de sièges réservés.
— Le coût total.

2.5 Étape 3 : Paiement et confirmation

2.5.1 Question 1 : Confirmer une réservation
Ajoutez une fonction permettant de confirmer une réservation. Une fois confirmés, les
sièges réservés passent à l’état Occupé. Demandez une confirmation explicite à l’utilisa-
teur.

2.5.2 Question 2 : Annuler une réservation

Ajoutez une fonction permettant d’annuler une réservation avant confirmation, re-
mettant les sièges dans l’état Disponible.

8
2.6 Étape 4 : Gestion financière
2.6.1 Question 1 : Structure des revenus
Ajoutez une structure pour suivre les revenus générés par catégorie (Standard, Pre-
mium, VIP).

2.6.2 Question 2 : Calcul des revenus

Écrivez une fonction pour afficher les revenus totaux générés par la salle, classés par
catégorie. Utilisez la formule suivante :
X
Revenustotaux = (P rixcatgorie × N ombredesigesoccups)
catgories

2.7 Étape 5 : Menu principal et boucle d’application

2.7.1 Question 1 : Menu principal
Implémentez un menu avec les options suivantes :
1. Afficher la salle de cinéma.
2. Réserver des sièges.
3. Confirmer une réservation.
4. Annuler une réservation.
5. Afficher les revenus totaux.
6. Quitter.

2.7.2 Question 2 : Boucle d’application

Ajoutez une boucle permettant à l’utilisateur de naviguer dans le menu jusqu’à ce
qu’il choisisse de quitter.

2.8 Étape 6 : Extensions optionnelles

— Gestion des utilisateurs : Ajoutez une structure Utilisateur pour enregistrer
les détails des clients (nom, numéro de téléphone).
— Recherche avancée : Implémentez une recherche pour trouver des sièges dispo-
nibles par catégorie ou rangée.
— Sauvegarde : Permettez de sauvegarder l’état de la salle dans un fichier et de le
recharger au démarrage.

2.9 Consignes pour les étudiants

— Respectez les noms de fonctions et structures proposés pour une meilleure lisibilité.
— Commentez votre code pour expliquer vos choix.
— Testez chaque étape avant de passer à la suivante.

9
2.10 Critères d’évaluation
1. Fonctionnalité : Les fonctions respectent les spécifications.
2. Organisation : Utilisation de structures et modularité du code.
3. Clarté : Noms de variables significatifs, commentaires et lisibilité.
4. Gestion des erreurs : Validation des entrées utilisateur et gestion des cas excep-
tionnels.

10
Chapitre 3

Jeu de Simulation de Combat : Battle

Arena

3.1 Résumé
Le but est de créer un jeu où deux personnages s’affrontent dans une arène. Chaque
personnage a des points de vie, de mana (énergie magique), des attaques de base et des
capacités spéciales. Les joueurs choisissent leurs actions tour par tour jusqu’à ce qu’un
gagnant soit déclaré.

3.2 Spécifications générales

3.2.1 Personnages
Chaque personnage a :
— Un nom.
— Des points de vie (HP).
— Des points de mana (MP).
— Une attaque de base (dégâts fixes).
— Une capacité spéciale consommant du mana.
— Une vitesse (détermine qui joue en premier).

3.2.2 Système de combat

— Tour par tour : Les joueurs choisissent une action (attaquer, utiliser une capacité
spéciale, se défendre). Le tour se termine après l’action de chaque joueur.
— Les actions doivent être affichées à l’écran pour informer les joueurs.
— IA : Si le joueur choisit de jouer contre l’ordinateur, l’IA sélectionne une action en
fonction de l’état du jeu.
— Victoire : Le jeu se termine quand un personnage a 0 HP.

11
3.3 Étape 1 : Initialisation des structures de données
3.3.1 Question 1 : Déclarez une structure Personnage
Cette structure doit contenir :
— nom : chaîne de caractères (nom du personnage).
— hp : entier (points de vie).
— mp : entier (points de mana).
— attaque_base : entier (dégâts de l’attaque de base).
— capacite_speciale : entier (dégâts de la capacité spéciale).
— mana_special : entier (mana requis pour la capacité spéciale).
— vitesse : entier (détermine qui joue en premier).

3.3.2 Exercice
1. Implémentez une fonction pour initialiser un personnage avec des valeurs prédéfi-
nies.
2. Affichez en console les caractéristiques du personnage (format clair et lisible).

3.4 Étape 2 : Choix des personnages

3.4.1 Question 1 : Liste des personnages disponibles
Créez une fonction pour afficher une liste de personnages disponibles (par exemple, 3
personnages prédéfinis) avec leurs caractéristiques.

3.4.2 Question 2 : Sélection des personnages

Implémentez une fonction permettant à chaque joueur de choisir un personnage à
partir de la liste.

3.5 Étape 3 : Mécanique du combat

3.5.1 Question 1 : Déterminez le premier joueur
Ajoutez une fonction pour calculer qui commence le tour en fonction de la vitesse des
personnages.

3.5.2 Question 2 : Actions possibles

Implémentez les actions possibles dans un tour :
— Attaquer : Inflige les dégâts de l’attaque de base à l’adversaire.
— Utiliser la capacité spéciale :
— Réduit le mana du personnage.
— Inflige des dégâts importants à l’adversaire si le mana est suffisant.

12
 — Si le mana est insuffisant, afficher un message d’erreur.
— Se défendre : Réduit les dégâts reçus au prochain tour de moitié.
Ajoutez une variable booléenne defense_active dans la structure Personnage pour gérer
cet état.

3.6 Étape 4 : IA simple pour l’adversaire

3.6.1 Question 1 : Stratégie de l’IA
Si le joueur choisit de jouer contre l’ordinateur, implémentez une IA basique :
— Si le mana est suffisant, l’IA utilise la capacité spéciale.
— Sinon, l’IA attaque de base.
— Si l’IA a moins de 30 % de ses HP, elle choisit de se défendre une fois sur deux.

3.6.2 Question 2 : Affichage des actions de l’IA

Ajoutez une fonction pour afficher les actions de l’IA dans la console.

3.7 Étape 5 : Boucle principale

3.7.1 Question 1 : Structure de la boucle
Implémentez une boucle principale pour le jeu :
— Affichez les statistiques des personnages à chaque début de tour.
— Laissez le joueur (ou l’IA) choisir une action.
— Appliquez les conséquences de l’action sur les personnages.
— Déterminez si un personnage est mort (HP 0). Si oui, affichez le vainqueur et
terminez le jeu.

3.8 Étape 6 : Extensions optionnelles

— Capacités spéciales uniques :
— "Coup critique" : double les dégâts d’une attaque de base (nécessite du mana).
— "Régénération" : restaure une partie des HP.
— "Bouclier magique" : annule complètement les dégâts d’un tour.
— Personnalisation des personnages : Permettre au joueur de créer son propre
personnage en entrant ses caractéristiques (sous certaines limites pour l’équilibrage).
— Statistiques après le combat : Afficher le nombre total de tours joués, les dégâts
infligés par chaque personnage, et les actions les plus utilisées.

13
3.9 Exemple de menu principal
1. Jouer contre un autre joueur.
2. Jouer contre l’ordinateur.
3. Quitter le jeu.

3.10 Consignes pour les étudiants

— Respectez la modularité en séparant les différentes fonctionnalités dans des fonctions
ou fichiers distincts.
— Commentez le code pour expliquer les choix d’implémentation.
— Gérez les erreurs (entrées invalides, etc.).

14
Chapitre 4

Gestionnaire de Bibliothèque Virtuelle

Résumé
L’objectif est de créer un programme en console qui permet de gérer une bibliothèque
virtuelle. L’utilisateur peut ajouter des livres, consulter la liste des livres disponibles,
rechercher un livre par différents critères, emprunter et rendre des livres.

4.1 Spécifications générales

4.1.1 Structure des données
Chaque livre est représenté par une structure contenant des informations comme le
titre, l’auteur, le genre, l’année de publication, un identifiant unique, et un indicateur
pour savoir s’il est emprunté ou disponible.

4.1.2 Fonctionnalités principales

— Ajouter un nouveau livre.
— Afficher la liste des livres (avec possibilité de tri).
— Rechercher un livre par titre, auteur, genre ou année.
— Emprunter un livre.
— Rendre un livre.
— Sauvegarder la bibliothèque dans un fichier et la charger depuis un fichier.

4.1.3 Menu principal

L’application doit offrir un menu interactif pour naviguer entre les différentes fonc-
tionnalités.

4.2 Étape 1 : Définition des structures et initialisation

Question 1
Déclarez une structure Livre contenant les champs suivants :

15
 — id : entier unique pour identifier chaque livre.
— titre : chaîne de caractères.
— auteur : chaîne de caractères.
— genre : chaîne de caractères.
— annee : entier.
— disponible : booléen (indique si le livre est disponible ou emprunté).

Exercice
— Implémentez une fonction pour initialiser un livre avec des données saisies par
l’utilisateur.
— Créez une structure Bibliotheque contenant un tableau de livres et un entier
représentant le nombre de livres.

4.3 Étape 2 : Ajouter un livre

Question 1
Implémentez une fonction pour ajouter un nouveau livre dans la bibliothèque. Cette
fonction doit :
— Vérifier que l’identifiant du livre est unique.
— Ajouter le livre au tableau de livres de la bibliothèque.

Exercice
— Affichez un message indiquant si le livre a été ajouté avec succès.
— Gérez le cas où la bibliothèque est pleine.

4.4 Étape 3 : Afficher les livres

Question 1
Implémentez une fonction pour afficher tous les livres de la bibliothèque. Chaque livre
doit être affiché sous une forme lisible, par exemple :

ID: 1 | Titre: "Le Petit Prince" | Auteur: Antoine de Saint-Exupéry |

Genre: Fiction | Année: 1943 | Disponible: Oui

Question 2
Ajoutez une option pour trier les livres avant de les afficher :
— Par titre (ordre alphabétique).
— Par auteur (ordre alphabétique).
— Par année (ordre croissant).

16
4.5 Étape 4 : Rechercher un livre
Question 1
Implémentez une fonction pour rechercher un livre en fonction d’un critère :
— Par titre.
— Par auteur.
— Par genre.
— Par année.

Exercice
— Affichez les résultats de la recherche ou un message si aucun livre ne correspond.
— Permettez à l’utilisateur de rechercher plusieurs fois sans quitter le menu.

4.6 Étape 5 : Emprunter et rendre un livre

Question 1
Implémentez une fonction pour emprunter un livre. Cette fonction doit :
— Demander à l’utilisateur l’identifiant du livre.
— Vérifier si le livre est disponible.
— Si oui, changer son état à disponible = false et afficher un message de confir-
mation.
— Si non, afficher un message indiquant que le livre est déjà emprunté.

Question 2
Ajoutez une fonction pour rendre un livre :
— Demandez l’identifiant du livre.
— Vérifiez si le livre est actuellement emprunté.
— Si oui, changez son état à disponible = true et affichez un message de confirma-
tion.

4.7 Étape 6 : Sauvegarde et chargement des données

Question 1
Implémentez une fonction pour sauvegarder les livres dans un fichier texte. Chaque
ligne doit contenir les informations d’un livre, séparées par un caractère spécial comme
;:

1;Le Petit Prince;Antoine de Saint-Exupéry;Fiction;1943;1

17
Question 2
Implémentez une fonction pour charger les livres depuis un fichier texte.

4.8 Étape 7 : Boucle principale et menu interactif

Question 1
Créez une boucle principale qui affiche un menu interactif avec des options comme
suit :

=== Gestionnaire de Bibliothèque ===

1. Ajouter un livre
2. Afficher la liste des livres
3. Rechercher un livre
4. Emprunter un livre
5. Rendre un livre
6. Sauvegarder et quitter
7. Charger depuis un fichier
Entrez votre choix :

4.9 Extensions optionnelles

— Statistiques : Affichez le nombre total de livres, disponibles et empruntés.
— Catégories : Permettez la gestion de catégories de livres.
— Système de recommandation : Recommandez des livres.
— Authentification : Ajoutez un système simple pour différencier administrateurs et
utilisateurs.

18
Chapitre 5

Implémentation d’un Réseau de

Neurones de Base en C++

5.1 Résumé
L’objectif est de construire un réseau de neurones simple en C++, en définissant les
éléments de base (neurones, couches, réseau), puis d’entraîner ce réseau sur un jeu de
données simple, comme la résolution du problème logique XOR.

5.2 Concepts couverts

— Structures, tableaux et pointeurs.
— Programmation modulaire.
— Gestion des fichiers pour les poids et les biais.
— Calculs mathématiques (fonction sigmoïde, propagation).
— Boucles et conditionnelles.

5.3 Étape 1 : Définir les structures de base

5.3.1 Question 1
Définissez une structure Neuron avec les champs suivants :
— float *poids : un tableau dynamique représentant les poids des connexions vers
ce neurone.
— float biais : le biais du neurone.
— float sortie : la sortie calculée du neurone lors d’une propagation avant.

5.3.2 Question 2
Déclarez une structure Couche contenant :
— int nombre_neurones : nombre de neurones dans cette couche.
— Neuron *neurones : un tableau dynamique de neurones.

19
5.3.3 Exercice
1. Implémentez une fonction pour initialiser une couche en allouant dynamiquement
les neurones et leurs poids. Les poids et les biais doivent être initialisés aléatoirement
entre −1 et 1.
2. Implémentez une fonction pour libérer la mémoire d’une couche.

5.4 Étape 2 : Définir le réseau de neurones

5.4.1 Question 1
Déclarez une structure ReseauDeNeurones avec les champs suivants :
— int nombre_couches : le nombre total de couches (y compris l’entrée et la sortie).
— Couche *couches : un tableau dynamique contenant toutes les couches du réseau.

5.4.2 Question 2
Créez une fonction pour initialiser un réseau de neurones avec les paramètres suivants :
— Nombre de neurones dans chaque couche (tableau passé en paramètre).
— Nombre total de couches.

5.4.3 Exercice
1. Implémentez une fonction pour afficher les poids et biais de chaque neurone.
2. Libérez correctement la mémoire allouée pour les couches et le réseau.

5.5 Étape 3 : Implémenter la propagation avant

5.5.1 Question 1
Créez une fonction pour effectuer une propagation avant à travers le réseau :
N
!
(5.1)
X
sortie = f poids[i] · entree[i] + biais
i=1

Où f (x) est la fonction d’activation sigmoïde :

1
f (x) = (5.2)
1 + e−x
Passez les sorties de la couche actuelle comme entrées pour la couche suivante.

20
5.6 Étape 4 : Implémenter la rétropropagation
5.6.1 Question 1
Ajoutez une fonction pour calculer l’erreur quadratique moyenne (Mean Squared Er-
ror, MSE) :
N
1 X
M SE = (yi − ŷi )2 (5.3)
N i=1
où yi est la sortie réelle et ŷi est la sortie prédite.

5.6.2 Question 2
Implémentez la rétropropagation pour ajuster les poids et les biais :
— Calculez l’erreur pour chaque neurone dans la couche de sortie :

δ = (ŷ − y) · f ′ (x) (5.4)

Où f ′ (x) = f (x) · (1 − f (x)).

— Propager l’erreur vers les couches précédentes :

δ l−1 = (δ l · poidslT ) · f ′ (sortiel−1 ) (5.5)

— Mettez à jour les poids et les biais : poids[i] ← poids[i] − η · δ · entree[i]

biais ← biais − η · δ Où η est le taux d’apprentissage.

5.7 Étape 5 : Entraîner le réseau sur le problème XOR

5.7.1 Question 1
Le problème XOR consiste à résoudre une table de vérité où la sortie est uniquement
1 si les deux entrées sont différentes :
— Entrées : (0, 0) → Sortie : 0
— Entrées : (0, 1) → Sortie : 1
— Entrées : (1, 0) → Sortie : 1
— Entrées : (1, 1) → Sortie : 0
Initialisez un réseau avec 3 couches :
— Une couche d’entrée avec 2 neurones.
— Une couche cachée avec 2 neurones.
— Une couche de sortie avec 1 neurone.
Utilisez la propagation avant et la rétropropagation pour entraîner le réseau sur ce pro-
blème.

5.7.2 Exercice
— Affichez l’erreur quadratique moyenne après chaque itération.
— Arrêtez l’entraînement lorsque l’erreur descend en dessous de 0, 01.

21
5.8 Étape 6 : Sauvegarde et chargement du modèle
5.8.1 Question 1
Ajoutez une fonction pour sauvegarder les poids et biais dans un fichier texte :
— Chaque ligne doit contenir les poids et le biais d’un neurone.

5.8.2 Question 2
Ajoutez une fonction pour charger un modèle depuis un fichier, en remplaçant les
poids et biais existants.

5.9 Étape 7 : Tester le réseau

Testez le réseau entraîné sur les entrées suivantes : (0, 0), (0, 1), (1, 0), (1, 1). Comparez
les sorties du réseau avec les résultats attendus.

5.10 Extensions optionnelles

— Ajout d’autres fonctions d’activation : ReLU, Tanh.
— Entraînez le réseau sur un autre problème, comme la reconnaissance de chiffres
(MNIST).
— Visualisation de l’apprentissage : affichez l’évolution de l’erreur quadratique moyenne
sur un graphique.

5.11 Critères d’évaluation

— Compréhension des concepts (propagation avant, rétropropagation).
— Modularité et clarté du code.
— Gestion correcte des ressources (allocation dynamique).
— Fonctionnalités supplémentaires ajoutées.

22
Chapitre 6

Projet : Implémentation d’un Réseau

de Neurones de Base en C++

Résumé
L’objectif est de construire un réseau de neurones simple en C++, en définissant les
éléments de base (neurones, couches, réseau), puis d’entraîner ce réseau sur un jeu de
données simple, comme la résolution du problème logique XOR.

Concepts couverts
— Structures, tableaux et pointeurs.
— Programmation modulaire.
— Gestion des fichiers pour les poids et les biais.
— Calculs mathématiques (fonction sigmoïde, propagation).
— Boucles et conditionnelles.

6.1 Étape 1 : Définir les structures de base

Question 1
Définissez une structure Neuron avec les champs suivants :
— float *poids : un tableau dynamique représentant les poids des connexions vers
ce neurone.
— float biais : le biais du neurone.
— float sortie : la sortie calculée du neurone lors d’une propagation avant.

Question 2
Déclarez une structure Couche contenant :
— int nombre_neurones : nombre de neurones dans cette couche.
— Neuron *neurones : un tableau dynamique de neurones.

23
Exercice
1. Implémentez une fonction pour initialiser une couche en allouant dynamiquement
les neurones et leurs poids. Les poids et les biais doivent être initialisés aléatoirement
entre −1 et 1.
2. Implémentez une fonction pour libérer la mémoire d’une couche.

6.2 Étape 2 : Définir le réseau de neurones

Question 1
Déclarez une structure ReseauDeNeurones avec les champs suivants :
— int nombre_couches : le nombre total de couches (y compris l’entrée et la sortie).
— Couche *couches : un tableau dynamique contenant toutes les couches du réseau.

Question 2
Créez une fonction pour initialiser un réseau de neurones avec les paramètres suivants :
— Nombre de neurones dans chaque couche (tableau passé en paramètre).
— Nombre total de couches.

Exercice
1. Implémentez une fonction pour afficher les poids et biais de chaque neurone.
2. Libérez correctement la mémoire allouée pour les couches et le réseau.

6.3 Étape 3 : Implémenter la propagation avant

Question 1
Créez une fonction pour effectuer une propagation avant à travers le réseau :
N
!
(6.1)
X
sortie = f poids[i] · entree[i] + biais
i=1

Où f (x) est la fonction d’activation sigmoïde :

1
f (x) = (6.2)
1 + e−x
Passez les sorties de la couche actuelle comme entrées pour la couche suivante.

24
6.4 Étape 4 : Implémenter la rétropropagation
Question 1
Ajoutez une fonction pour calculer l’erreur quadratique moyenne (Mean Squared Er-
ror, MSE) :
N
1 X
M SE = (yi − ŷi )2 (6.3)
N i=1
où yi est la sortie réelle et ŷi est la sortie prédite.

Question 2
Implémentez la rétropropagation pour ajuster les poids et les biais :
— Calculez l’erreur pour chaque neurone dans la couche de sortie :

δ = (ŷ − y) · f ′ (x) (6.4)

Où f ′ (x) = f (x) · (1 − f (x)).

— Propager l’erreur vers les couches précédentes :

δ l−1 = (δ l · poidslT ) · f ′ (sortiel−1 ) (6.5)

— Mettez à jour les poids et les biais : poids[i] ← poids[i] − η · δ · entree[i]

biais ← biais − η · δ Où η est le taux d’apprentissage.

6.5 Étape 5 : Entraîner le réseau sur le problème XOR

Question 1
Le problème XOR consiste à résoudre une table de vérité où la sortie est uniquement
1 si les deux entrées sont différentes :
— Entrées : (0, 0) → Sortie : 0
— Entrées : (0, 1) → Sortie : 1
— Entrées : (1, 0) → Sortie : 1
— Entrées : (1, 1) → Sortie : 0
Initialisez un réseau avec 3 couches :
— Une couche d’entrée avec 2 neurones.
— Une couche cachée avec 2 neurones.
— Une couche de sortie avec 1 neurone.
Utilisez la propagation avant et la rétropropagation pour entraîner le réseau sur ce pro-
blème.

Exercice
— Affichez l’erreur quadratique moyenne après chaque itération.
— Arrêtez l’entraînement lorsque l’erreur descend en dessous de 0, 01.

25
6.6 Étape 6 : Sauvegarde et chargement du modèle
Question 1
Ajoutez une fonction pour sauvegarder les poids et biais dans un fichier texte :
— Chaque ligne doit contenir les poids et le biais d’un neurone.

Question 2
Ajoutez une fonction pour charger un modèle depuis un fichier, en remplaçant les
poids et biais existants.

6.7 Étape 7 : Tester le réseau

Testez le réseau entraîné sur les entrées suivantes : (0, 0), (0, 1), (1, 0), (1, 1). Comparez
les sorties du réseau avec les résultats attendus.

Extensions optionnelles
— Ajout d’autres fonctions d’activation : ReLU, Tanh.
— Entraînez le réseau sur un autre problème, comme la reconnaissance de chiffres
(MNIST).
— Visualisation de l’apprentissage : affichez l’évolution de l’erreur quadratique moyenne
sur un graphique.

Critères d’évaluation
— Compréhension des concepts (propagation avant, rétropropagation).
— Modularité et clarté du code.
— Gestion correcte des ressources (allocation dynamique).
— Fonctionnalités supplémentaires ajoutées.

26
Chapitre 7

Jeu de Puzzle Numérique - Résoudre

un Sudoku

Ce projet consiste à développer un jeu de puzzle basé sur les règles du Sudoku, avec
un algorithme de résolution automatique. Le jeu se déroulera en plusieurs étapes, allant
de la génération du puzzle à la sauvegarde et au chargement du jeu. Le projet couvre
des concepts comme les tableaux 2D, les algorithmes de backtracking, la validation des
entrées et la gestion de fichiers.

7.1 Introduction
Le jeu de Sudoku est un puzzle logique qui consiste à remplir une grille de 9x9 cases
avec des chiffres de 1 à 9, tout en respectant certaines règles : chaque ligne, chaque colonne,
et chaque région de 3x3 cases doivent contenir les chiffres de 1 à 9 sans répétition. Ce
projet a pour but de créer un jeu de Sudoku en console, avec un solveur automatique
basé sur l’algorithme de backtracking.

7.2 Étape 1 : Représentation du Sudoku

7.2.1 Structure de données
Nous définissons une structure pour représenter la grille de Sudoku. Cette structure
contient un tableau 9x9 représentant les cases du jeu, où chaque case peut contenir un
nombre entre 1 et 9, ou être vide (représentée par 0).
struct Sudoku {
int g r i l l e [ 9 ] [ 9 ] ; // La g r i l l e de Sudoku 9 x9
};

7.2.2 Initialisation de la grille

Nous implémentons une fonction pour initialiser la grille avec des zéros, ce qui repré-
sente un puzzle vide.
void i n i t i a l i s e r S u d o k u ( Sudoku& sudoku ) {
for ( int i = 0 ; i < 9 ; ++i ) {

27
 for ( int j = 0 ; j < 9 ; ++j ) {
sudoku . g r i l l e [ i ] [ j ] = 0 ;
}
}
}

7.2.3 Affichage de la grille

Nous créons une fonction pour afficher la grille de manière lisible pour l’utilisateur,
avec des lignes séparées par des tirets.
void a f f i c h e r S u d o k u ( const Sudoku& sudoku ) {
for ( int i = 0 ; i < 9 ; ++i ) {
for ( int j = 0 ; j < 9 ; ++j ) {
s t d : : cout << sudoku . g r i l l e [ i ] [ j ] << "␣" ;
}
s t d : : cout << s t d : : e n d l ;
}
}

7.3 Étape 2 : Générer un puzzle Sudoku

7.3.1 Génération du puzzle
Nous générons un puzzle valide en remplissant la grille avec un solveur, puis en sup-
primant un certain nombre de chiffres pour créer un puzzle.
void g e n e r e r P u z z l e ( Sudoku& sudoku ) {
// Remplir l a g r i l l e avec un s o l v e u r
// E n l e v e r un c e r t a i n nombre de c h i f f r e s pour g n r e r un p u z z l e
}

7.4 Étape 3 : Interaction avec l’utilisateur

7.4.1 Entrée de l’utilisateur
Nous ajoutons une fonction permettant à l’utilisateur de remplir une case vide. La
fonction vérifie que la valeur entrée est valide et que la case n’est pas déjà remplie.
void e n t r e r V a l e u r ( Sudoku& sudoku , int l i g n e , int co lon ne , int v a l e u r ) {
i f ( valeur < 1 | | valeur > 9) {
s t d : : cout << " Valeur ␣ i n v a l i d e . ␣ Entrez ␣un␣nombre␣ e n t r e ␣1␣ e t ␣ 9 . " << s
return ;
}
i f ( sudoku . g r i l l e [ l i g n e ] [ c o l o n n e ] != 0 ) {
s t d : : cout << " Cette ␣ c a s e ␣ e s t ␣ d j ␣ r e m p l i e . " << s t d : : e n d l ;
return ;
}

28
 sudoku . g r i l l e [ l i g n e ] [ c o l o n n e ] = v a l e u r ;
}

7.5 Étape 4 : Résolution automatique avec Backtra-

cking
7.5.1 Algorithme de backtracking
Nous implémentons un algorithme de backtracking pour résoudre automatiquement
le puzzle.
bool resoudreSudoku ( Sudoku& sudoku ) {
// I m p l m e n t e r l e b a c k t r a c k i n g pour r s o u d r e l e p u z z l e
return true ;
}

7.6 Étape 5 : Validation des entrées utilisateur

7.6.1 Validation des entrées
Nous ajoutons une fonction pour vérifier si l’entrée de l’utilisateur respecte les règles
du Sudoku : la valeur doit être entre 1 et 9 et ne doit pas apparaître dans la même ligne,
colonne ou région 3x3.
bool e s t V a l i d e ( Sudoku& sudoku , int l i g n e , int co lon ne , int v a l e u r ) {
// V r i f i e r que l a v a l e u r e s t v a l i d e
return true ;
}

7.7 Étape 6 : Sauvegarde et chargement du puzzle

7.7.1 Sauvegarde du puzzle
Nous implémentons des fonctions pour sauvegarder et charger l’état du puzzle à partir
de fichiers texte.
void sauvegarderSudoku ( Sudoku& sudoku , const char∗ nomFichier ) {
// S a u v e g a r d e r l a g r i l l e dans un f i c h i e r
}

bool chargerSudoku ( Sudoku& sudoku , const char∗ nomFichier ) {

// Charger l a g r i l l e p a r t i r d ’ un f i c h i e r
return true ;
}

29
7.8 Étape 7 : Boucle du jeu
7.8.1 Menu du jeu
Le menu permet à l’utilisateur de choisir différentes actions : démarrer un nouveau
jeu, résoudre le puzzle automatiquement, sauvegarder ou charger une partie.
void a f f i c h e r M e n u ( ) {
s t d : : cout << " Bienvenue ␣ dans ␣ l e ␣ Jeu ␣ de ␣Sudoku␣ ! " << s t d : : e n d l ;
s t d : : cout << " 1 . ␣Nouveau␣ j e u " << s t d : : e n d l ;
s t d : : cout << " 2 . ␣ R s o u d r e ␣ automatiquement " << s t d : : e n d l ;
s t d : : cout << " 3 . ␣ S a u v e g a r d e r ␣ l e ␣ j e u " << s t d : : e n d l ;
s t d : : cout << " 4 . ␣ Charger ␣ l e ␣ j e u ␣ s a u v e g a r d " << s t d : : e n d l ;
s t d : : cout << " 5 . ␣ Q u i t t e r " << s t d : : e n d l ;
}

7.9 Étape 8 : Extensions optionnelles

7.9.1 Mode chronométré
Ajoutez un chronomètre pour mesurer le temps que l’utilisateur prend pour résoudre
le puzzle.

7.9.2 Niveaux de difficulté

Permettez à l’utilisateur de choisir le niveau de difficulté du puzzle en fonction du
nombre d’indices donnés.

7.9.3 Interface graphique

Utilisez une bibliothèque comme SFML ou SDL pour créer une interface graphique
pour le Sudoku.

7.10 Conclusion
Ce projet implémente un jeu de Sudoku complet avec des fonctionnalités de généra-
tion, de résolution automatique, de validation des entrées, ainsi que de sauvegarde et de
chargement des puzzles. L’interface utilisateur est en mode texte, mais des extensions
graphiques peuvent être ajoutées pour une expérience utilisateur enrichie.

30
Chapitre 8

Jeu de Gestion de Ville (CityBuilder)

8.1 Résumé
Dans ce projet, vous allez créer un jeu de gestion de ville en mode console. Le joueur
incarne un maire chargé de développer une ville en équilibrant les ressources, la croissance
démographique et la gestion des infrastructures. L’objectif est de prendre des décisions
stratégiques pour faire prospérer la ville tout en évitant la faillite ou la famine.
Ce projet met en œuvre :
— Des structures complexes pour représenter des entités comme les bâtiments, les
ressources, etc.
— Une boucle de jeu avec des choix interactifs pour le joueur.
— La gestion des ressources (argent, nourriture, population).
— Des événements aléatoires et des mécanismes de gestion de la ville.
Concepts couverts :
— Structures et gestion de listes.
— Programmation modulaire avec fonctions.
— Boucles de simulation avec interactions dynamiques.
— Utilisation des énumérations et gestion des états.
— Gestion des événements et de l’historique des actions.

8.2 Étape 1 : Représentation des bâtiments et des res-

sources
8.2.1 Question 1 :
Définir une structure pour représenter un bâtiment avec les attributs suivants :
— Nom du bâtiment.
— Coût de construction.
— Coût d’entretien.
— Capacité en population (si applicable).
— Production de nourriture (si applicable).
— Effets sur le bonheur ou l’économie (si applicable).

31
8.2.2 Exercice :
Créez une structure Batiment pour représenter un bâtiment. Définissez une liste de
bâtiments de base (par exemple, Maison, Ferme, École, Usine). Implémentez une fonction
qui affiche les bâtiments disponibles avec leurs détails.
struct Batiment {
s t d : : s t r i n g nom ;
int c o u t C o n s t r u c t i o n ;
int c o u t E n t r e t i e n ;
int c a p a c i t e P o p u l a t i o n ;
int p r o d u c t i o n N o u r r i t u r e ;
int e f f e t B o n h e u r ; // Exemple : e f f e t p o s i t i f s u r l e bonheur
};

8.3 Étape 2 : Gestion des ressources

8.3.1 Question 2 :
Créez une structure Ressources pour gérer les ressources de la ville, avec les attributs
suivants :
— Argent.
— Nourriture.
— Population.
— Bonheur (échelle de 0 à 100).

8.3.2 Exercice :
Implémentez une fonction qui initialise les ressources de départ. Créez une fonction
pour afficher les ressources actuelles du joueur à chaque tour.
struct R e s s o u r c e s {
int a r g e n t ;
int n o u r r i t u r e ;
int p o p u l a t i o n ;
int bonheur ;
};

8.4 Étape 3 : Construction des bâtiments

8.4.1 Question 3 :
Ajoutez la possibilité de construire un bâtiment :
— Affichez la liste des bâtiments disponibles.
— Demandez au joueur de choisir un bâtiment à construire.
— Vérifiez si le joueur dispose de suffisamment d’argent pour construire le bâtiment
choisi.

32
 — Ajoutez le bâtiment à la liste des bâtiments actifs.
— Mettez à jour les ressources de la ville en fonction du bâtiment construit.

8.4.2 Exercice :
Implémentez une fonction construireBatiment() qui permet de :
— Afficher la liste des bâtiments disponibles.
— Demander au joueur de choisir un bâtiment.
— Vérifier la possibilité de construction (solde suffisant d’argent).
— Ajouter le bâtiment et ses effets dans la ville.

8.5 Étape 4 : Boucle de jeu

8.5.1 Question 4 :
Implémentez la boucle principale du jeu où, chaque tour, vous :
— Récoltez les ressources des bâtiments (argent, nourriture).
— Déduisez les coûts d’entretien des bâtiments.
— Déduisez la nourriture consommée par la population (1 unité par habitant).
— Vérifiez les conditions de défaite (argent < 0, nourriture < 0).
— Permettez au joueur de choisir une action (construire un bâtiment, passer au tour
suivant, consulter l’état des bâtiments).

8.5.2 Exercice :
Implémentez un menu avec les options suivantes à chaque tour :

Tour 1 :
Ressources :
Argent : 500, Nourriture : 100, Population : 5, Bonheur : 50
Actions :
1. Construire un bâtiment
2. Passer au tour suivant
3. Afficher les bâtiments actuels
4. Quitter

8.6 Étape 5 : Victoire et défaite

8.6.1 Question 5 :
Définissez des conditions de victoire et de défaite basées sur les ressources de la ville :
— Victoire :
— Si la population atteint 50 : “Votre ville prospère, vous gagnez !”
— Si l’argent atteint 1000 : “Votre économie est florissante, vous gagnez !”

33
 — Défaite :
— Si la nourriture < 0 pendant 3 tours consécutifs : “Votre population est morte
de faim, vous perdez.”
— Si l’argent < 0 pendant 3 tours consécutifs : “Votre ville est en faillite, vous
perdez.”

8.6.2 Exercice :
Implémentez une logique de victoire et défaite avec des messages correspondants.

8.7 Étape 6 : Extensions optionnelles

8.7.1 1. Événements aléatoires :
Chaque tour peut déclencher des événements imprévus :
— Un incendie détruit un bâtiment.
— Un investisseur offre de l’argent à la ville.
— Une sécheresse réduit la production de nourriture.

8.7.2 Exercice :
Implémentez une fonction qui génère un événement aléatoire chaque tour, avec des
effets positifs ou négatifs.

8.7.3 2. Gestion des taxes et des politiques :

Permettez au joueur de définir des politiques fiscales et sociales :
— Taxes élevées : Augmentent l’argent mais diminuent le bonheur.
— Taxes faibles : Augmentent le bonheur mais diminuent l’argent.

8.7.4 Exercice :
Ajoutez une fonction qui permet au joueur de définir les taux de taxation et d’observer
les effets sur l’économie et le bonheur.

8.7.5 3. Gestion avancée :

Créez un tableau historique pour suivre les changements dans les ressources au fil des
tours. Implémentez une carte de la ville avec l’emplacement des bâtiments.

8.8 Objectifs pédagogiques :

— Appliquer les principes de programmation orientée objet avec des structures.
— Comprendre la gestion dynamique des ressources dans un jeu.
— Implémenter des interactions avec l’utilisateur dans un contexte de simulation.
— Travailler sur des algorithmes de gestion d’événements et de conditions dynamiques.

34
Chapitre 9

Jeu du Démineur

9.1 Résumé
Dans ce projet, vous allez implémenter un jeu du démineur en mode console. Le joueur
devra découvrir les cases du terrain sans déclencher de mines. Chaque case peut contenir
une mine ou un nombre indiquant le nombre de mines dans les cases adjacentes. Le but
est de révéler toutes les cases sûres sans toucher les mines.
Ce projet implique :
— La gestion d’une grille.
— Des structures pour représenter les cases et l’état du jeu.
— Une boucle de jeu avec des interactions utilisateurs.
— Des algorithmes pour vérifier les cases adjacentes et gérer les mines.
Concepts couverts :
— Structures et tableaux multidimensionnels.
— Gestion des entrées et sorties utilisateur.
— Logique de jeu (vérification des cases adjacentes, conditions de victoire et défaite).
— Boucle de jeu avec mise à jour de l’état.

9.2 Étape 1 : Représentation du terrain

9.2.1 Question 1
Définissez une structure pour représenter chaque case du terrain avec les attributs
suivants :
— EstMine : un booléen pour savoir si la case contient une mine.
— NombreMinesAdjacentes : le nombre de mines dans les cases voisines.
— EstRévélée : un booléen pour savoir si la case a été découverte par le joueur.
— EstMarquée : un booléen pour savoir si la case a été marquée par le joueur (dra-
peau).

35
9.2.2 Exercice
Créez une structure Case pour représenter chaque case du terrain. Implémentez un
tableau 2D pour stocker l’état du terrain. Affichez la grille au début du jeu, avec des cases
non révélées.
struct Case {
bool estMine; // Indique si la case contient une mine
int nombreMinesAdjacentes; // Nombre de mines adjacentes
bool estRévélée; // Si la case est déjà découverte
bool estMarquée; // Si le joueur a mis un drapeau
};

9.3 Étape 2 : Initialisation du terrain

9.3.1 Question 2
Créez une fonction pour initialiser le terrain de jeu :
— Placez aléatoirement les mines dans la grille.
— Calculez le nombre de mines adjacentes pour chaque case.
— Affichez la grille de jeu avec des cases cachées.

9.3.2 Exercice
Implémentez une fonction initialiserTerrain() pour :
— Placer les mines aléatoirement.
— Calculer le nombre de mines adjacentes pour chaque case.
— Afficher la grille initiale avec les cases non révélées.

9.4 Étape 3 : Interaction avec le joueur

9.4.1 Question 3
Permettez au joueur d’interagir avec le jeu :
— Révéler une case (révèle la case et ses adjacentes si nécessaire).
— Marquer une case avec un drapeau (pour indiquer une mine potentielle).
— Vérifier si le joueur a gagné ou perdu.

9.4.2 Exercice
Implémentez une fonction révélerCase(x, y) qui :
— Révèle une case.
— Si la case est vide (pas de mine ni d’indication de mines adjacentes), révéler aussi
les cases adjacentes.
Implémentez une fonction marquerCase(x, y) pour permettre de marquer une case
avec un drapeau. Créez une fonction afficherTerrain() qui affiche l’état actuel de la
grille avec les cases découvertes, les cases marquées, et les cases non révélées.

36
9.5 Étape 4 : Boucle de jeu
9.5.1 Question 4
Ajoutez une boucle de jeu principale où le joueur peut choisir ses actions :
— Révéler une case.
— Marquer une case.
— Vérifier les conditions de victoire (toutes les cases sûres sont révélées).
— Vérifier les conditions de défaite (toucher une mine).

9.5.2 Exercice
Implémentez une boucle de jeu qui :
— Affiche le terrain à chaque tour.
— Demande à l’utilisateur s’il souhaite révéler ou marquer une case.
— Vérifie si le joueur a perdu (révélation d’une mine).
— Vérifie si le joueur a gagné (révélation de toutes les cases sûres).

while (!jeuTerminé) {
afficherTerrain();
demanderAction(); // Révéler ou marquer
if (conditionDePerte()) {
afficherMessage("Vous avez perdu !");
jeuTerminé = true;
}
if (conditionDeVictoire()) {
afficherMessage("Vous avez gagné !");
jeuTerminé = true;
}
}

9.6 Étape 5 : Conditions de victoire et défaite

9.6.1 Question 5
Ajoutez des conditions pour déterminer si le joueur a gagné ou perdu :
— Perte : Si une case contenant une mine est révélée, le joueur perd.
— Victoire : Si toutes les cases sans mines sont révélées, le joueur gagne.

9.6.2 Exercice
Implémentez la fonction conditionDePerte() qui vérifie si le joueur a cliqué sur une
mine. Implémentez la fonction conditionDeVictoire() qui vérifie si toutes les cases
sûres ont été révélées.

37
9.7 Étape 6 : Extensions optionnelles
9.7.1 1. Niveau de difficulté
Permettez au joueur de choisir la taille du terrain et le nombre de mines avant de
commencer :
— Facile : Terrain de 5x5 avec 5 mines.
— Moyenne : Terrain de 8x8 avec 15 mines.
— Difficile : Terrain de 10x10 avec 25 mines.

9.7.2 Exercice
Ajoutez un menu pour choisir la difficulté du jeu et ajustez la taille du terrain et le
nombre de mines en conséquence.

9.7.3 2. Chronomètre
Ajoutez un chronomètre pour mesurer le temps que prend le joueur pour finir le jeu.

9.7.4 Exercice
Implémentez un chronomètre qui se déclenche au début du jeu et qui affiche le temps
écoulé une fois que le joueur gagne ou perd.

9.7.5 3. Sauvegarde et reprise

Permettez au joueur de sauvegarder son jeu et de le reprendre plus tard.

9.7.6 Exercice
Implémentez une fonction de sauvegarde qui enregistre l’état actuel du jeu dans un
fichier et permet de le charger.

9.8 Objectifs pédagogiques

— Apprendre à manipuler des tableaux multidimensionnels (grilles).
— Implémenter des algorithmes pour vérifier les cases adjacentes et gérer la logique
du jeu.
— Gérer les entrées utilisateur et la boucle de jeu.
— Travailler sur des conditions de victoire et de défaite.
— Créer un jeu interactif avec un retour visuel sur l’état du jeu.

38