= Analyse du domaine




*Composante Carte :*

La composante Carte définit tout simplement une carte dans le jeu. Il y a 3 types de cartes, les cartes Lieu, Traque et Survie.
Une carte est composée d'un nom et d'un pouvoir peut importe son type.
Chaques types de cartes possèdent des attributs supplémentaires, spécifiques à chaque type de cartes.
    Les cartes Lieu possèdent, en plus d'un nom et d'un pouvoir, un numéro de 1 à 10. La planète est composée de 10 cartes Lieu différentes.
    Les cartes Traque possèdent une phase et un symbole.
    Les cartes Survie ne possèdent rien d'autre qu'un nom et un pouvoir.

*La classe Carte :*
[plantuml, Composante-Carte, png]
....
hide circle
skinparam monochrome true

class Carte {
    nom : String
    pouvoir : ...
}

class CarteLieu {
    numero : Integer
}

class CarteSurvie {
    phase : Integer
    symbole : String
}

class CarteTraque {
    symbole : Jeton
}

Carte <|-- CarteLieu : \t\t
Carte <|-- CarteSurvie : \t\t
Carte <|-- CarteTraque : \t\t

....

Les différentes Carte Lieu :

[plantuml, CarteLieu, png]
....
hide circle
skinparam monochrome true

class CarteLieu {
}

class CarteLieu1 {
    nom = "L'ANTRE"
    numero = 1
}

class CarteLieu2 {
    nom = "LA JUNGLE"
    numero = 2
}

class CarteLieu3 {
    nom = "LA RIVIERE"
    numero = 3
}

class CarteLieu4 {
    nom = "LA PLAGE"
    numero = 4
}

class CarteLieu5 {
    nom = "LE ROVER"
    numero = 5
}

class CarteLieu6 {
    nom = "LE MARAIS"
    numero = 6
}

class CarteLieu7 {
    nom = "L'ABRI"
    numero = 7
}

class CarteLieu8 {
    nom = "L'EPAVE"
    numero = 8
}

class CarteLieu9 {
    nom = "LA SOURCE"
    numero = 9
}

class CarteLieu10 {
    nom = "L'ARTEFACT"
    numero = 10
}

CarteLieu --> CarteLieu1 : \t\t
CarteLieu --> CarteLieu2 : \t\t
CarteLieu --> CarteLieu3 : \t\t
CarteLieu --> CarteLieu4 : \t\t
CarteLieu --> CarteLieu5 : \t\t
CarteLieu --> CarteLieu6 : \t\t
CarteLieu --> CarteLieu7 : \t\t
CarteLieu --> CarteLieu8 : \t\t
CarteLieu --> CarteLieu9 : \t\t
CarteLieu --> CarteLieu10 : \t\t

....

*Composante Jeton :*

La composante Jeton définit les jetons Traque. Il y a 3 types de jetons dans le jeu : le jeton Créature, le jeton Cible et le jeton Artemia
Un jeton possède un nom et un état. L'état indique si le jeton est présent sur une carte.

_La classe Jeton_
[plantuml, Composante-Jeton, png]
....
hide circle
skinparam monochrome true

class Jeton {
    ArrayList<CarteLieu> position;
}

class JetonCible {
}

class JetonArtemia {
}

class JetonCreature {
}

Jeton <|-- JetonCreature : \t\t
Jeton <|-- JetonCible : \t\t
Jeton <|-- JetonAtemia : \t\t
....



*Composante Joueur :*

La composante Joueur, définit un joueur dans le jeu.
Soit le joueur est la créature, soit il incarne un traqué.
Chaque joueur possède un nom.
    Le joueur Créature a en plus les 3 jetons Traque et des carte Traque.
    Le joueur Traque a lui 5 cartes Lieu, 1 carte Survie et 3 pions Volonté.

_La classe Joueur :_
[plantuml, Composante-Joueur, png]
....
hide circle
skinparam monochrome true

class Joueur {
    nom : String
}

class Creature {
    jetonCreature : Jeton
    jetonCible : Jeton
    jetonArtemia : Jeton
    carteTraque : ArrayList<Carte>
}

class Traque {
    pionVolonte : Integer
    carteLieu : ArrayList<Carte>
    carteSurvie : ArrayList<Carte>
}

Joueur <|-- Creature : \t\t
Joueur <|-- Traque : \t\t

....

*Composante Pion :*

La composante Pion, définit un pion dans le jeu.
Il y a plusieurs type de pions : Secours et Assimilation

_La classe Pion :_
[plantuml, Composante-Pion, png]
....
hide circle
skinparam monochrome true

class Pion {
    position : Integer
}

class PionSecours {
}

class PionAssimilation {
}

Pion <|-- PionSecours : \t\t
Pion <|-- PionAssimilation : \t\t

....


*Composante Plateau :*

La composante Plateau, définit le plateau du jeu.
Le plateau possède un pion Secours et un pion Assimilation.
L'entier position du pion correspond à sa distance de la case Victoire sur le plateau.

_La classe Plateau :_
[plantuml, Composante-Plateau, png]
....
hide circle
skinparam monochrome true

class Plateau {
    pionSecours : PionSecours
    pionAssimilation : PionAssimilation
}

....


*Définir les actions :*

_resister(entier perdrePion)_ : Résister fait perdre au Traqué 1 ou 2 pions Volonté (valeur passé en paramètre) pour reprendre en main respectivement 2 ou 4 cartes Lieu au choix de sa défausse.
Si par cette action un Traqué perd son troisième pion Volonté, il doit lacherPrise.

exemple :
avant éxécution
[plantuml, exemple-avant-resister, png]
....
hide circle
skinparam monochrome true

class Traque {
    nom = "Trinity"
    pions = 2
}

class CarteLieu1 {
    nom = "LA PLAGE"
    numero = 4
}

class CarteLieu2 {
    nom = "LA JUNGLE"
    numero = 2
}

class CarteLieu3 {
    nom = "LA RIVIERE"
    numero = 3
}

class CarteLieu4 {
    nom = "L'ANTRE"
    numero = 1
}

Traque -> "main     " CarteLieu1 : \t\t
Traque --> "deffausse   " CarteLieu2 : \t\t
Traque --> "deffausse   " CarteLieu3 : \t\t
Traque --> "deffausse   " CarteLieu4 : \t\t

....

après éxécution

[plantuml, exemple-apres-resister, png]
....
hide circle
skinparam monochrome true

class Traque {
    nom = "Trinity"
    pions = 1
}

class CarteLieu1 {
    nom = "LA PLAGE"
    numero = 4
}

class CarteLieu2 {
    nom = "LA JUNGLE"
    numero = 2
}

class CarteLieu3 {
    nom = "LA RIVIERE"
    numero = 3
}

class CarteLieu4 {
    nom = "L'ANTRE"
    numero = 1
}

Traque -> "main     " CarteLieu1 : \t\t
Traque --> "deffausse   " CarteLieu2 : \t\t
Traque --> "main   " CarteLieu3 : \t\t
Traque --> "main   " CarteLieu4 : \t\t

....

Donc on peut en déduire un lien entre la classe Traque et CarteLieu,

[plantuml, diagramme-Traque-CarteLieu, png]
....
hide circle
skinparam monochrome true

class Traque {
    nom : String
    pions : Integer
}

class CarteLieu {
    nom : String
    numero : Integer
}

Traque - "main [0-10]" CarteLieu : \t\t
Traque - "defausse [0-10]" CarteLieu : \t\t

....

_lacherPrise()_ : Le traqué récupère ses pions Volonté et reprends en main toutes ses cartes Lieu défaussées.
Mais cet abandon de soi accélère l'assimilation.

Exemple :
avant éxécution
[plantuml, exemple-avant-lacherPrise, png]
....
hide circle
skinparam monochrome true

class Plateau {
    assimilation = 4
}

class Traque {
    nom = "Trinity"
    pions = 1
}

class CarteLieu1 {
    nom = "LA PLAGE"
    numero = 4
}

class CarteLieu2 {
    nom = "LA JUNGLE"
    numero = 2
}

class CarteLieu3 {
    nom = "LA RIVIERE"
    numero = 3
}

class CarteLieu4 {
    nom = "L'ANTRE"
    numero = 1
}

Traque -> "main     " CarteLieu1 : \t\t
Traque --> "deffausse   " CarteLieu2 : \t\t
Traque --> "deffausse   " CarteLieu3 : \t\t
Traque --> "deffausse   " CarteLieu4 : \t\t

....

après éxécution

[plantuml, exemple-apres-lacherPrise, png]
....
hide circle
skinparam monochrome true

class Plateau {
    assimilation = 5
}

class Traque {
    nom = "Trinity"
    pions = 3
}

class CarteLieu1 {
    nom = "LA PLAGE"
    numero = 4
}

class CarteLieu2 {
    nom = "LA JUNGLE"
    numero = 2
}

class CarteLieu3 {
    nom = "LA RIVIERE"
    numero = 3
}

class CarteLieu4 {
    nom = "L'ANTRE"
    numero = 1
}

Traque -> "main     " CarteLieu1 : \t\t
Traque --> "main   " CarteLieu2 : \t\t
Traque --> "main   " CarteLieu3 : \t\t
Traque --> "main   " CarteLieu4 : \t\t

....

Le diagramme global :

[plantuml, diagramme-global, png]
....
hide circle
skinparam monochrome true

class Plateau
class Partie
class Joueur
class Traque
class Creature
class Carte
class CarteLieu
class CarteSurvie
class CarteTraque
class Pion
class PionSecours
class PionAssimilation
class Jeton
class JetonCreature
class JetonCible
class JetonArtemia



....

include::./use-cases/use-cases.adoc[]