```plantuml

@startuml

enum Couleur {
  ROUGE
  VERT
  BLEU
  JAUNE
  NOIR
  BLANC
}

enum Indicateur {
  BONNEPLACE
  BONNECOULEUR
}

class Jeton {
  +Jeton(couleur: Couleur)
}

Jeton *--> Couleur: +Couleur: Couleur

class Code {
  +Code(tailleCode: int)
  +Code(jetons: Jeton?[])
  +AjouterJeton(jeton: Jeton): void
  +SupprimerDernierJeton(): void
  +RecupererJeton(indice: int): void
  +Jetons(): Jeton?[]
  +EstComplet(): bool
  +TailleMaximale(): int
  +Comparer(autreCode: Code): Indicateur[]

  +NbJetons: int = 0
}

Code o--> Jeton: -lesJeton: Jeton?[]

class Plateau {
  -random: Random
  -tailleCode: int

  +Plateau(tailleCode: int, tailleGrille: int)
  +GenererCodeAleatoire(): void
  +EstComplet(): bool
  +AjouterCode(code: Code): void
  +EstBonCode(code: Code): bool
  +Grille(): Jeton?[][]
  +Indicateurs(): Indicateur[][]

  +Victoire: bool = false
  +Tour: int = 1
}

Plateau *--> Code: -codeSecret: Code
Plateau *--> Code: -grille: Code?[]
Plateau *--> Indicateur: -indicateurs: Indicateur[][]


class Joueur {
  +Joueur(nom: string, plateau: Plateau)

  +Nom: string
}

Joueur *--> Plateau: +Plateau: Plateau


interface IRegles {
  +AjouterJoueur(joueur: string): void
  +JoueurCourant(): Joueur
  +PasserLaMain(): void
  +GenererCode(): Code
  +CommencerLaPartie(): void
  +EstTerminee(): bool
  +Gagnants(): Joueur[]
  +Perdants(): Joueur[]

  +Nom: string
  +TourMaximum: int
  +TailleCodeMaximum: int
  +NbJoueurs: int
  +NbJoueursMaximum: int
}


class ReglesClassiques {
  +nbJoueurs: int = 0
  +joueurCourant: int?
  +joueurs: Joueur[]
  
  +ReglesClassiques()
  
  +Nom: string = "Règles classiques"
  +TourMaximum: int = 12
  +TailleCodeMaximum: int = 4
  +NbJoueurs: int
  +NbJoueursMaximum: int = 2
}

ReglesClassiques ..|> IRegles

@enduml

```