Kotlin Monster — Fiche Projet

01

Description du projet

Kotlin Monster est un jeu d'aventure en ligne de commande développé en Kotlin dans le cadre du cours de programmation orientée objet. Inspiré de l'univers Pokémon, le joueur explore différentes zones de jeu, rencontre des monstres, peut les capturer et les faire évoluer, puis les engager dans des combats stratégiques.

L'objectif pédagogique principal est la mise en pratique des concepts fondamentaux de la POO : chaque entité du jeu est modélisée par une classe (Monstre, Joueur, Zone, Combat). Le projet applique l'héritage pour créer différents types de monstres, le polymorphisme pour les attaques spéciales, et l'encapsulation pour protéger les attributs internes.

Développé avec IntelliJ IDEA, le projet est organisé en packages thématiques et documenté avec KDoc.

02

Technologies utilisées

Kotlin

IntelliJ IDEA

JVM

KDoc (documentation)

GitHub

Diagramme UML (classes)

03

Concepts POO appliqués

Héritage

Classes mère / filles

La classe abstraite Monstre est étendue par des types spécifiques (MonstreFeu, MonstреEau…) qui héritent des attributs communs (pv, niveau, nom) et surchargent les méthodes d'attaque.

Polymorphisme

Comportements différenciés

La méthode attaquer() est redéfinie dans chaque sous-classe. L'appel sur un objet de type parent invoque la version correcte selon le type réel de l'instance à l'exécution.

Encapsulation

Protection des données

Les attributs sensibles (pv, niveau, statut) sont déclarés private. L'accès est contrôlé via des getters/setters avec validation, empêchant des valeurs incohérentes (PV négatifs, niveau hors limites).

Abstraction

Interfaces & classes abstraites

Interface Combattant définissant le contrat commun à tout participant d'un combat. La classe abstraite Monstre implémente la logique commune et délègue les comportements spécifiques.

04

Architecture des classes

// Interface principale

interface Combattant {

fun attaquer(cible: Combattant): Int

fun recevoirDegats(degats: Int)

}

abstract class Monstre(val nom: String, var pv: Int) : Combattant {

var niveau: Int = 1

var estCapture: Boolean = false

abstract fun attaqueSpeciale(): Int

fun evoluer() { niveau++ }

}

class MonstreFeu(nom: String, pv: Int) : Monstre(nom, pv) {

override fun attaqueSpeciale() = lancerFlammes()

}

class Joueur(val pseudo: String) {

val equipe: MutableList<Monstre> = mutableListOf()

fun capturer(m: Monstre) { m.estCapture = true; equipe.add(m) }

}

05

Compétences BTS SIO mobilisées

Code	Compétence	Mise en œuvre dans le projet
B2.1	Exploiter les ressources du poste de travail	Utilisation d'IntelliJ IDEA, configuration du projet Kotlin, gestion des dépendances JVM.
B2.2	Concevoir une solution applicative	Diagramme de classes UML modélisant Monstre, Joueur, Zone et Combat avec leurs relations d'héritage.
B2.3	Développer, documenter et déployer	Développement en Kotlin avec héritage, polymorphisme, encapsulation, interfaces et classes abstraites. Documentation KDoc.
B2.4	Travailler en mode projet	Organisation du code en packages (models, game, utils), versionnage GitHub avec commits descriptifs.
B3.2	Gérer le patrimoine informatique	Documentation du code, structure claire du projet, versionnage permettant la traçabilité des modifications.

06

Résultats & apprentissages

🏗️

Architecture POO solide

Conception d'une hiérarchie de classes cohérente avec héritage, interfaces et classes abstraites en Kotlin.

🔒

Encapsulation maîtrisée

Protection des données internes via modificateurs private/protected, accès contrôlé via propriétés Kotlin.

🧩

Polymorphisme appliqué

Redéfinition des méthodes dans les sous-classes, appel polymorphe via le type de la classe mère.

📐

Modélisation UML

Réalisation d'un diagramme de classes UML complet avant l'implémentation pour valider l'architecture.