Compétence 1

Réaliser un développement d'applications

Élément Contenu détaillé
SAÉ concernée S1.01 – Implémentation d’un besoin client
Problématique : créer un jeu d’aventure textuelle en C ; navigation case par case, commandes textuelles (look, go, help, quit), description des lieux, gestion mémoire dynamique.
Sujet étudié Construction d’un moteur de jeu textuel :
  • Architecture modulaire (cmd, game, location, mobile, exits, stack).
  • Gestion des commandes utilisateur et affichage textuel.
  • Allocation/désallocation dynamique pour éviter les fuites mémoire.
Livrables remis 1. Code complet en C (WorldOfIUT.c et modules associés)
2. Présentation PDF de la soutenance (architecture, fonctionnalités, défis)
Équipe Groupe de 2 : Ahmed Errebache & Adam Choujaa.
Rôle personnel (Ahmed) • Conception et implémentation des modules game et location ;
• Gestion mémoire via stack.c (malloc/free) ;
• Développement du parseur de commandes (cmd.c) ;
• Tests, débogage sous Linux et rédaction de la documentation et du PDF de soutenance.
Regard critique Point fort : architecture claire et modularisée, gestion robuste de la mémoire.

Limites : difficultés de compilation sous Windows (makefile non compatible) ; Adam peu impliqué, j’ai dû porter seul l’essentiel et nous n’avons pas couvert toutes les fonctionnalités (inventaire, help étendu).

2. Apprentissages critiques (AC) mobilisés
(Compétence 1 – Implémenter des solutions logicielles)

Mobilisé : Oui   Niveau auto-évalué : Maîtrise

Commentaire :
J’ai organisé mon code en modules clairs (.c/.h) pour séparer la logique “game”, “location” et “cmd” ; cela m’a aidé à maintenir et tester chaque partie indépendamment. La structure modulaire a rendu les évolutions (ajout de nouvelles commandes) beaucoup plus rapides et sûres.

Mobilisé : Partiellement   Niveau auto-évalué : Maîtrise

Commentaire :
J’ai utilisé malloc/free pour allouer dynamiquement les structures de cases et mobiles, et j’ai ajouté des vérifications systématiques pour éviter les fuites mémoire. Toutefois, certains scénarios de libération n’étaient pas encore couverts, je dois approfondir les tests de stress.

Mobilisé : Partiellement   Niveau auto-évalué : En progrès

Commentaire :
J’ai esquissé une IHM basique en Swing pour le projet Snake (fenêtre, canvas, gestion des événements clavier), mais je manque encore de pratique sur la disposition des composants et la gestion fine du repaint().

Mobilisé : Partiellement   Niveau auto-évalué : En progrès

Commentaire :
J’ai utilisé printf(), gdb et assertions pour corriger des bugs critiques (fuites, resets intempestifs), mais je dois acquérir davantage d’expérience en tests unitaires (CUnit/JUnit) et automatisation (CI).

3. Ressources mobilisées
(Compétence 1 – Implémenter des solutions logicielles)

Semestre 1

R1.01 – Initiation au développement

Apports : Fondamentaux du C, compilation, gestion de mémoire, débogage sous Linux.

Mobilisation : Mise en place du squelette de la SAÉ textuelle, écriture et compilation des modules C.

R1.02 – Développement d’interfaces web

Apports : Structure HTML, mise en forme CSS, principes UX de base.

Mobilisation : Prototype du menu du jeu et page d’aide en HTML/CSS pour le projet textuel.

R1.10 – Anglais technique

Apports : Vocabulaire de programmation, documentation API, commentaires de code.

Mobilisation : Rédaction de la documentation C et lecture de tutoriels anglophones pour le jeu textuel.

Semestre 2

R2.01A – Initiation à la programmation objet

Apports : Concepts clés Java : classes, objets, héritage, interfaces.

Mobilisation : Conception des classes Snake, Board et Controller pour le jeu Snake.

R2.02 – Développement d’applications avec IHM

Apports : Swing : fenêtres, panneaux, écouteurs d’événements clavier.

Mobilisation : Création de l’interface graphique du Snake (JFrame, KeyListener, repaint).

R2.03 – Qualité de développement

Apports : Bonnes pratiques, revues de code, tests unitaires/assertions.

Mobilisation : Ajout de assertions et de tests manuels pour valider la logique de collision du Snake.

R2.13 – Communication en milieu professionnel

Apports : Techniques de présentation, modération, gestion des retours en équipe.

Mobilisation : Pitch du projet Snake en TP, animation de la session de questions/réponses.

4. Implication & déroulement
(Compétence 1 – Implémenter des solutions logicielles)

SAÉ S1.01 – Implémentation d'un besoin client

Pour cette SAÉ, Adam Choujaa et moi avons démarré du squelette fourni en C sur la plateforme du cours R1.01 (Initiation au développement), puis collaboré via Git et Discord. J’ai assuré l’essentiel :

  • Modularisation du code : découpage en modules game, location, cmd pour isoler la logique de déplacement et de commandes.
  • Parser de commandes : implémentation du menu textuel et du traitement des entrées clavier.
  • Représentation du monde : création d’une grille dynamique avec malloc/free pour stocker noms et descriptions des cases.

Livrables finaux :
• Fichiers source C (main.c, game.c/.h, location.c/.h, cmd.c/.h)
• Présentation PDF détaillant l’architecture modulaire et les instructions d’installation sous Linux

  • Point fort : code fortement modulaire, facilitant l’extension du jeu (nouvelles commandes, nouveaux objets).
  • Limite : compilation impossible sous Windows sans ajustements, nécessité d’un environnement Linux ; Adam s’est désengagé, j’ai donc pris en charge la quasi-totalité du projet.

5. Analyse des apprentissages
(Compétence 1 – Implémenter des solutions logicielles)

Retour réflexif sur mes apprentissages

Semestre 1 : Implémenter le jeu d’aventure textuelle m’a appris à structurer mon code en modules clairs (gestion des cases, parser de commandes, affichage). J’ai compris l’importance de la gestion dynamique de la mémoire (malloc/free) pour représenter un monde extensible, et de l’abstraction du parser pour isoler la logique métier de l’I/O.

Semestre 2 : Le projet Snake en Java Swing m’a plongé dans la programmation événementielle et l’architecture MVC. J’ai renforcé mes compétences en écoute d’événements clavier, en rafraîchissement de l’interface (repaint) et en persistance simple des scores. J’ai découvert les bonnes pratiques de découplage UI/logiciel et l’intérêt de la persistance via fichiers texte.

  • Mon point fort : modulariser un projet et définir des responsabilités nettes pour chaque composant (parser, moteur de jeu, IHM).
  • À améliorer : anticiper la portabilité (compilation croisée) et intégrer des tests unitaires systématiques pour valider chaque module avant assemblage.

Leçon tirée :
Un code robuste repose sur une architecture claire et testée module par module, ainsi que sur une gestion rigoureuse des dépendances et de la mémoire.

6. Axes d’amélioration
(Compétence 1 – Implémenter des solutions logicielles)

Observation (S1) : Difficulté à compiler le code C sous Windows, installation tardive de Linux.

Observation (S2) : Environnement Java Swing non uniformisé entre postes (versions JDK, classpath).

→ À améliorer : documenter et versionner clairement l’environnement (scripts de build, Docker ou Makefile) pour garantir une compilation homogène sur toutes les machines.

Observation (S1) : Code monolithique mêlant parser, logique métier et I/O sans séparation claire.

Observation (S2) : Classes Snake et UI fortement couplées, rendant la maintenance et l’évolution difficiles.

→ À améliorer : définir des modules distincts (Parser, GameEngine, UI), exploiter interfaces et tests unitaires pour isoler chaque composant.

Observation (S1) : Aucune suite de tests ou assertions mémoire (malloc/free) avant livraison.

Observation (S2) : Scénarios de collision et d’extension du Snake peu couverts par les tests manuels.

→ À améliorer : mettre en place des tests unitaires pour chaque fonction critique, ajouter des logs et assertions pour faciliter le débogage.

Observation (S1) : Document PDF de présentation, mais pas de README ou guide d’installation du jeu textuel.

Observation (S2) : Présentation PDF du Snake, mais absence de notice de déploiement et d’utilisation.

→ À améliorer : rédiger un README détaillé (dépendances, compilation, execution), commenter le code et fournir des exemples d’utilisation.

Observation (S1) : Adam peu actif et absence de versioning Git, rendant le suivi des modifications peu fiable.

Observation (S2) : Julien absent, code inspiré de tutoriels externes sans validation, décorrélé du cahier des charges.

→ À améliorer : instaurer un workflow Git/GitHub, définir clairement les rôles, organiser des points de synchronisation hebdomadaires et demander des clarifications régulières à l’enseignant.

7. Traces choisies
(Compétence 1 – Implémenter une solution logicielle)

Trace 1 : Projet WorldOfIUT (S1.01) (PDF)

Impossible d’afficher le PDF. Télécharger le projet WorldOfIUT.

Commentaire : Structure modulaire du code (cmd.c, game.c…), gestion de la mémoire et Makefile de compilation.

Trace 2 : Présentation Snake (S2.01) (PDF)

Impossible d’afficher le PDF. Télécharger la présentation Snake.

Commentaire : Diapositives illustrant l’architecture Java, panels Swing et gestion du score.

8. Originalité & qualité
(Compétence 1 – Développer la solution)

Synthèse de l’originalité et de la qualité
  • Approche originale (S1) :
    • Implémentation d’un moteur de jeu textuel modulaire en C : découpage du monde en cases dynamiques, fonctions de parsing des commandes et affichage conditionnel de la description longue/courte.
    • Utilisation d’un Makefile pour compiler automatiquement sous Linux, contournant les limitations de Windows et assurant portabilité et maintenance.
  • Qualité des livrables (S1) :
    • Code C commenté et structuré : chaque fonction est documentée avec ses paramètres, types de retour et invariant métier.
    • Présentation PDF détaillant l’architecture logicielle, les choix de structures de données et un guide d’utilisation pas-à-pas.
  • Approche originale (S2) :
    • Reproduction du jeu « Snake » en Java Swing sans framework externe, en s’appuyant sur un game loop maître et un gestionnaire d’événements pour les touches.
    • Auto-apprentissage via tutoriels en ligne pour implémenter la gestion des collisions et la mise à jour dynamique du score, montrant proactivité et autonomie.
  • Qualité des livrables (S2) :
    • Application Snake fonctionnelle avec écran d’accueil, liste des meilleurs scores et touches configurables.
    • Documentation PDF du code Java, diagrammes de classes et explication du game loop, facilitant l’analyse et la réutilisation.
Points forts
  • Modularité et clarté du code : séparation nette des responsabilités (affichage, logique métier, entrée utilisateur).
  • Capacité d’adaptation technique : passage rapide de C à Java, maîtrise de make/GNU tools et de Swing.
  • Livrables complets et professionnels : code commenté, PDF bien mis en forme et respect des conventions de nommage.
Axes d’amélioration
  • Ajouter des tests unitaires pour couvrir les cas d’erreur (mouvements hors grille, entrée invalide).
  • Prévoir une configuration multiplateforme (scripts Windows + Linux) pour simplifier la compilation.
  • Intégrer un mécanisme de persistance (sauvegarde JSON ou XML) pour conserver les parties en cours et scores.