conception.adoc

= Conception détaillée

== Proposition :

- Transformer l'actuel objet Game en objet Room et l'objet GameController en Game
- Ajouter des méthodes dans Thrift pour ce faire
- Transformer les void de l'interface Game en Response

== Game

[plantuml]
....
class Room{
    - requests : BlockingQueue<GameRequest>
    - numberPlayers : AtomicInteger
    - roomId : String
    - roomCreatorId : String
    - players : Map<String, Integer>
    - room : Game
    - isStart : Boolean
    - isClose : Boolean
    - play : Thread
    - game : Game
    - static(MAX_PLAYER : int)
    - static(MIN_PLAYER : int)
    + getRoomId() : String
    + getNumberPlayers() : AtomicInteger
    + isCreator(playerId : String) : Boolean
    + join(playerId : String) : Response
    + start(playerId : String, planet : Planet, board : Board, creatureNumber : Integer) : Response
    - requestManagement()
    - handleRequest(request : GameRequest)
}



    interface GameInterface{
    + isFinish() : Boolean
    + playerHasFinished(playerId : Integer, phase : Phase)
    + phaseIsFinish() : Boolean
    + playerPlayCard(playerId : Integer, card : Card) :  Response
    + playerPlayCard(playerId : Integer, cards : Card[*]) :  Response

    + playerPlaceJeton(playerId : Integer, jeton : PlacedJeton) : Response
    + playerPlaceJeton(playerId : Integer, jetons : PlacedJeton[*])  : Response

    + playerResist(playerId : Integer, number : Integer) : Response
    + playerGiveUp(playerId : Integer): Response
    + playerChooseAction(playerId : Integer, action : Action): Response
    + askAction(inGameIdPlayer : Integer, askedAction : TAskAction): Action
    - sendActionWithoutExpectedResponse(inGameIdPlayer : Integer, askedAction : TAskAction)
    - sendFirstRoundStart()
    - sendStartPhase()
    - sendDescription()
    - sendGameIsEnd()
    }

    class Game{
        - planet : Planet
        - reserve : Reserve
        - survivalCardPioche : Pioche<SurvivalCard>
        - trackingCardPioche : Pioche<TrackingCard>
        - board : Board
        - database : NotAloneDatabase
        - creature : Creature
        - traques : Traque[*]
        - playersMap : Map<Integer, Player>
        - state : Phase
        - room : Room
        - currentActivatePowers : PowerContainer[*]
        - nextRoundPowers : PowerContainer[*]
        - gameRoundVariables : GameRoundVariables
        - playerServiceHandler : GameClientHandler

        - initializePlayer(creatureId : Integer, playerNumber : Integer)
        - initializeReserve(playerNumber : Integer)
        - initializeSurvivalCardPioche()
        - initializeTrackingCardPioche()
        - initializeCardsOfPlayers()
        - sendFirstRoundStart()

        + getCurrentActivatePowers() : Power[*]
        + getNextRoundPowers() : Power[*]
        + getPlanet() : Planet
        + getReserve() : Reserve
        + getSurvivalCardPioche() : Pioche<SurvivalCard>
        + getTrackingCardPioche() : Pioche<TrackingCard>
        + getBoard() : Board
        + getCreature() : Creature
        + getTraques() : Traque[*]
        + getPlayersMap() : Map<Integer, Player>
        + getPlayer(idPlayer : Integer) : Player
        + getGameRoundVariables() : GameRoundVariables
        + getState() : Phase
        + getRoom() : Room
        + isJetonArtemiaIsActive() : boolean
        + getNumberWillingnessDecrementByJetonCreature() : Integer
        + traqueCanResist() : boolean
        + getIdPlayerTargetByTrackingCardAnticipation() : Integer
        + traqueCanPickSurvivalCards() :  boolean
        - addPowerForNextRound(power : Power)
        - disableJetonArtemia()
        - enableJetonArtemia()
        - setNumberWillingnessDecrementByJetonCreature( number : Integer)
        - addNumberWillingnessByJetonCreature()
        - setTraqueCanResist()
        - setIdPlayerTargetByTrackingCardAnticipation(idPlayerTargetByJetonCreature : Integer)
        - setTraqueCanPickSurvivalCards(traqueCanPickSurvivalCards : Boolean)

        + isFinish() : Boolean

        + playerHasFinished(playerId : Integer, phase : Phase) : Response
        + creatureHasFinished(creature : Creature, phase : Phase) : Response
        + boolean traqueHasFinished(traque : Traque, phase : Phase )
        + Response phaseIsFinish(phase : Phase)
        + playerPlayCard(playerId : Integer, card : Card) : Response
        + playerPlayCard(playerId : Integer, cards : Card[*]) : Response

        + playerPlaceJeton(playerId : Integer, jeton : PlacedJeton) : Response
        + playerPlaceJeton(playerId : Integer, jetons : PlacedJeton[*]) : Response

        + playerResist(playerId : Integer) : Response
        + playerGiveUp(playerId : Integer) : Response
        + playerChooseAction(playerId : Integer, action : Action) : Response
        + askAction(inGameIdPlayer : Integer, action : TAskAction) : Action
        - sendActionWithoutExpectedResponse(inGameIdPlayer : Integer, askedAction : TAskAction)
        - sendStartPhase()
        - sendDescription()
        - sendGameIsEnd()
        + playerPlayPlayerCard(player : Player, card : Card ) : Response
        + playerPlayPlayerCard(player : Player, cards : Card[*] ) : Response
        + creaturePlayTrackingCard(creature : Creature, trackingCard : TrackingCard ) : Response
        + creaturePlayTrackingCard(creature : Creature, trackingCards : TrackingCard[*] ) : Response
        - applyCreaturePlayTrackingCard(creature : Creature, trackingCard : TrackingCard )
        + creatureCanPlayThisTrackingCards(creature : Creature, trackingCard : TrackingCard ) : boolean
        + creatureCanPlayThisTrackingCards(creature : Creature, trackingCard : TrackingCard[*] ) : boolean
        + traquePlaySurvivalCard(traque : Traque, survivalCard : SurvivalCard) : Response
        + traquePlaySurvivalCard(traque : Traque, survivalCard : SurvivalCard[*]) : Response
        - applyTraquePlaySurvivalCard( traque : Traque, survivalCard : SurvivalCard)
        + traqueCanPlayThisSurvivalCards( traque : Traque, survivalCard : SurvivalCard) : boolean
        + traqueCanPlayThisSurvivalCards( traque : Traque, survivalCards : SurvivalCard[*]) : boolean
        + traquePlayPlaceCard( traque : Traque, placeCard PlaceCard) : Response
        + traquePlayPlaceCard( traque : Traque, placeCard PlaceCard[*]) : Response
        + playerCardsPlayedPhaseAndAppliedPhaseDifferent( playerCard : PlayerCard) : boolean
        + creaturePlaceAJeton( creature : Creature, placedJeton : PlacedJeton) : Response
        + nextPhase(phase : Phase) : Phase
        + allPlayersHasFinishedCurrentPhase() : boolean
        - startNextPhase()
        - managePhase3()
        + choosePlaceCardsToReveal(traque : Traque) : PlaceCard[*]
        - managePhase4()
        - nextRound()
        - applyNextRoundPowers()
        - applyModificatorPower(power : PowerModificator)
        - useWillingnessOnBoard()
        + choosePlaceCardsAction(idPlayer : Integer, max : Integer, placesCards : PlaceCard[*]) : PlaceCard[*]
        + chooseSurvivalCardsAction(idPlayer : Integer, max : Integer, survivalCards : SurvivalCard[*]) : SurvivalCard[*]
        + chooseTrackingCardsAction(idPlayer : Integer, max : Integer, trackingCards : TrackingCard[*]) : TrackingCard[*]
        + chooseCardsAction(idPlayer : Integer, max : Integer, cardsToChoose : Card[*]) : Card[*]
        + createTActionForChooseCardsAction( max : Integer, cardsToChoose : Card[*]) : TAskAction
        - sendPlaceCardsAction( idPlayer : Integer, cardsToShow : PlaceCard[*])
        - sendCardsAction( idPlayer : Integer, cardsToShow : Card[*])
        + createTActionForSendCardsAction(cardsToShow : Card[*]) : TAskAction
        + computeCardListFromCardNames( cardNames : CardName[*], cardsToChoose : Card[*]) : Card[*]
        + choosePower(idPlayer : Integer, powersDescription : String[*]) : Integer
        + targetPlayer(idPlayer : Integer) : Integer
        + choosePlace(idPlayer : Integer, number : Integer) : Place[*]
        + choosePlace(idPlayer : Integer, number : Integer, message : String) : Place[*]
        + movePlayer(idPlayer : Integer) : Pair<Integer, Place>
        + swapJetons(idPlayer : Integer) : Pair<JetonSymbol, JetonSymbol>
        + associateCardNamesToPlaces(idPlayer : Integer, cardsToAssociate : Card[*]) : Map<Card, Place>
        + createTActionForAssociateCardNamesToPlaces( cardsToAssociate : Card[*]) : TAskAction
        + computeMapCardToPlaceFromMapCardNamesToPlace( cardNamePlaceMap : Map<CardName, Place>, cards : Card[*]) : Map<Card, Place>


    }


class RoomFactory{
    - {static} idCounter : AtomicInteger
    - {static} createRoom(playerId : String) : Room
}
....


=== Item

==== Action

.Package action
[plantuml]
....
package action{
    abstract class Action{
        {abstract} getActionType() : ActionType
    }

    class ActionAssociateCardNamesToPlaces{
        - cardNamePlaceMap : Map<CardName, Place>
        + getActionType() : ActionType
        + getCardNamePlaceMap : Map<CardName, Place>
    }

    class ActionChooseCard{
        - cards : Card[*]
        + getCards : Card[*]
        + getActionType() : ActionType
    }

    class ActionChoosePlace{
        - places : Place[*]
        + getPlaces() : Place[*]
        + getActionType() : ActionType
    }

    class ActionChoosePower{
        - idPowerChosen : Integer
        + getIdPowerChosen() : Integer
        + getActionType() : ActionType
    }

    class ActionContainer{
        - actions : Action[*]
        + add(action : Action) : Boolean
        + add(actions : Action[*]) : Boolean
        + doAction(action : Action) : Boolean
        + doAction(actions : Action[*]) : Boolean
        + isEmpty() : Boolean
    }

    class ActionMoveJeton{
        - jeton : JetonSymbol
        - place : Place
        + getJeton() : JetonSymbol
        + getPlace : Place
        + getActionType() : ActionType
    }

    class ActionMovePlayer{
        - idPlayer : Integer
        - place : Place
        + getIdPlayer() : Integer
        + getPlace() : Place
        + getActionType() : ActionType
    }

    class ActionSwapJeton{
        - jeton1 : JetonSymbol
        - jeton2 : JetonSymbol
        + getJeton1() : JetonSymbol
        + getJeton2() : JetonSymbol
        + getActionType() : ActionType
    }

    class ActionTargetPlayer{
        - idPlayer : Integer
        + getIdPlayer() : Integer
        + getActionType() : ActionType
    }

    enum ActionType{
        CHOOSE_POWER
        TARGET_PLAYER
        MOVE_PLAYER
        CHOOSE_CARD
        CHOOSE_PLACE
        SWAP_JETONS
        MOVE_JETON
        ASSOCIATE_SURVIVAL_CARDS_TO_PLACES
        SHOW_CARD
    }
     enum TPairType{
        NUMBER
        CARD
        PLACE
        JETON
        PLAYER
    }


    Action <|-- ActionAssociateSurvivalCardsToPlaces
    Action <|-- ActionChooseCard
    Action <|-- ActionChoosePlace
    Action <|-- ActionChoosePower
    Action <|-- ActionMoveJeton
    Action <|-- ActionMovePlayer
    Action <|-- ActionSwapJeton
    Action <|-- ActionTargetPlayer
    ActionContainer "1" -- "*" Action
}
....


=== Board
.Package board
[plantuml]
....
package board{

    class Board{
        - boardDistribution : BoardDistribution
        - boardColor : BoardColor
        - score : Score
        + getScore() : Score
        + getBoardDistribution() : BoardDistribution
        + getBoardColor() : BoardColor
        + isArtemiaSquare() : Boolean
        + toString() : String
        - initializeScore(playerNumber : Integer)
        + isFinish() : boolean
        + getScoreTraque() : Integer
        + getScoreCreature() : Integer
        + actualBestTeam() : PlayerTeam
        + winner() : PlayerTeam
        - moveForwardTraque(delta : Integer)
        - moveForwardTraque()
        - moveBackTraque(delta : Integer)
        - moveBackTraque()
        - moveForwardCreature(delta : Integer)
        - moveForwardCreature()
        - moveBackCreature(delta : Integer)
        - moveBackCreature()

    }
    enum BoardColor{
        BLUE
        RED
        GREEN
        YELLOW
    }
    enum BoardDistribution{
        FRONT
        BACK
    }

    class Score{
        - scoreTraque : Integer
        - scoreCreature : Integer
        - winner : PlayerTeam
        + getScoreTraque() : Integer
        + getScoreCreature() : Integer
        + isFinish() : Boolean
        + actualBestTeam() : PlayerTeam
        + winner() : PlayerTeam
        + scoreCreatureGreaterThanBase() : Boolean
        + scoreTraqueGreaterThanBase() : Boolean
        + moveForwardTraque(delta : Integer)
        + moveBackTraque(delta : Integer)
        + moveForwardCreature(delta : Integer)
        + moveBackCreature(delta : Integer)
        + equals(o : Object) : Boolean
        + toString() : String
    }


    Board "1" o-- "1 score" Score
}
....

=== Card
.Package card
[plantuml]
....
package card{
    enum CardType{
        SURVIVAL
        TRACKING
        PLACE
    }

    abstract class Card{
        # name : String
        # CardName : String
        # description : String
        + getName() : String
        + getCardName() : String
        + getDescription() : String
        + getType() : String
        + equals(o : Object) : Boolean
        + {abstract} getType() : CardType
        + toString() : String
        + hashCode() : Integer
    }
    enum BoardDistribution{
        ANTRE, JUNGLE, RIVIERE, PLAGE, ROVER, MARAIS, ABRI, EPAVE, SOURCE, ARTEFACT,
    NEXUS, OASIS, FJORD, DOME, LABYRINTHE, MANGROVE, ARCHIPEL, POLE, FUNGI, PORTAIL,

    ACHARNEMENT, ANGOISSE, ANTICIPATION, CATACLYSME, CHAMP_DE_FORCE, CLONE, DEPLOIEMENT, DESESPOIR, DETOUR, DOMINATION, EFFROI,
    EMPRISE, EPIDEMIE, FAILLE_TEMPORELLE, FLASHBACK, GARGANTUA, HARCELEMENT, HURLEMENTS, INERTIE, INTERFERENCES, INTUITION,
    MAGNETISME, MIRAGE, MUTATION, PSYCHOSE, REMINISCENCE, REPERAGE, SABLES_MOUVANTS, SOIF_DE_SANG, STASE, TELEPATHIE,
    TORNADE, TOXINE, UBIQUITE, VIRUS, ZONE_INTERDITE,

    ADRENALINE, ALERTE, AMPLIFICATEUR, BROUILLAGE, CAVALE, DETECTEUR, DRONE, ENTRAVE, EQUIPEMENT, ESQUIVE,
    FAUSSE_PISTE, HOLOGRAMME, LEURRE, MIMETISME, NAVETTE, PLANQUES, PORTAIL_SURVIVAL, RALLIEMENT, REFUGE, REGENERATION,
    RESISTANCE, RETRAITE, RIPOSTE, SACRIFICE, SECOND_SOUFFLE, SIXIEME_SENS, SYSTEME_D, TENACITE, VACCIN, VOLTE_FACE,
    VORTEX
    }

    class PlaceCard {
        - number : Integer
        - imageUrl : String
        - color : String
        + getNumber() : Integer
        + getImageUrl() : String
        + getColor() : String
        + getType() : CardType
    }

    abstract class PlayerCard {
        # phase : Phase
        # phaseToApply : Phase
        + getPhase() : Phase
        + getPhaseToApply() : Phase
    }

    class SurvivalCard {
        + getType() : CardType
    }

    class TrackingCard {
        - symbols : List<JetonSymbol>
        + getType() : CardType
        + getJetons() : List<JetonSymbol>
        + containsSymbol(type : JetonSymbol) : boolean

    }

    Card <|-- PlaceCard
    Card <|-- PlayerCard
    PlayerCard <|-- SurvivalCard
    PlayerCard <|-- TrackingCard
}
....



=== Jeton
.Package jeton
[plantuml]
....
package jeton{



    abstract class Jeton{
        # powers : PowerType
        + getPowers() : PowerType
        + {abstract} getType() : JetonSymbol
    }

    class JetonArtemia{
        + getType() : JetonSymbol
    }

    class JetonCreature{
        + getType() : JetonSymbol
    }

    class JetonCible{
        + getType() : JetonSymbol
    }
    enum JetonSymbol{
        CIBLE
        ARTEMIA
        CREATURE
    }

    class PlacedJeton{
        - jeton : Jeton
        - places : Place[*]
        + getJeton() : Jeton
        + getPlaces() : Place[*]
    }

    Jeton <|-- JetonArtemia
    Jeton <|-- JetonCreature
    Jeton <|-- JetonCible
    PlacedJeton "1" -- "1 jeton" Jeton

}
....

=== Pioche
.Package pioche
[plantuml]
....
package pioche{
    class Pioche <T extends PlayerCard>{
        - cards : T[*]
        - trash : T[*]
        - random : Random
        - mix()
        + draw() : T
        + draw(number : Integer) : T[*]
        - throwAway(cards : T[*])
        - throwAway(card : T)
        + getLastTrashCards(number : Integer) : T[*]
        + getTrash() : T[*]
        + getCards() : T[*]
    }
}
....

=== Planet
.Package planet
[plantuml]
....
package planet{
    class BeaconPawn{
        - state : Integer
        - nextState()
        + isActive() : Boolean
        + getType() : PawnType
        + maxMovesInOneRound() : Integer
    }
    enum PawnType{
        SHIELD
        BEACON
    }
    enum Place{
        PLACE_ONE
        PLACE_TWO
        PLACE_THREE
        PLACE_FOUR
        PLACE_FIVE
        PLACE_SIX
        PLACE_SEVEN
        PLACE_EIGHT
        PLACE_NINE
        PLACE_TEN
    }
    class PlaceDistribution{
        - mapCardNumberToPlaceCard : Map<Integer, PlaceCard>
        - mapPlaceCardToPlace : Map<PlaceCard, Place>
        - placeIsHidden : Map<Place, Boolean>
        - initialization(placeCards : PlaceCard[*])
        - initializePlaceCardsVisibility()
        - initializePlaces()
        + createPawn() : PlanetPawn
        + isValidPlacesForJeton(adjacentPlaces Place[*]) : boolean
        + placeToNumber(place : Place) : Integer
        + numberToPlace(number : Integer) : Place
        + isAdjacentPlaces(place1 : Integer, place2 : Integer) : Boolean
        + isAdjacentPlaces(place1 : Place, place2 : Place) : Boolean
        + isValidPlacesForJeton(adjacentPlacesCard : PlaceCard[*]) : Boolean
        + placeCardToPlace(card : PlaceCard) : Place
        + placeToPlaceCard(card : PlaceCard) : PlaceCard
        + useCardLabyrinthe() : Boolean
        + useCardDome() : Boolean
        + useCardPole() : Boolean
        + getPlaceCardsInInterval(a : Integer, b : Integer) : PlaceCard[*]
        + getPlaceCards() : PlaceCard[*]
        + isHiddenCards() : boolean
        + getHiddenCards() : PlaceCard[*]
        + getHiddenPlaces() : Place[*]
        - revealPlace(place : Place)
        - revealPlace(placeCard : PlaceCard)
        + isRevealedPlace(place : Place)
        + isRevealedPlace(placeCard : PlaceCard)
    }
    class Planet{
        - mapPlaceToJetons : Map<Place, JetonSymbol[*]>
        - blockedPlaces : Map<Place, Boolean>
        - placeSurvivalCardMap : Map<Place, SurvivalCard[*]>
        - numberMovesAllowInRound : Integer
        - placeDistribution : PlaceDistribution
        - planetPawn : PlanetPawn
        - epaveUsedInTheRound : Boolean
        + getPlaceDistribution() : PlaceDistribution
        + reset()
        + placeJeton(placedJeton : PlacedJeton)
        + findPlacesWhereJetonIs(symbol : JetonSymbol) : Place[*]
        + findPlaceCardsWhereJetonIs(symbol : JetonSymbol) : PlaceCard[*]
        - removeJeton(symbol : JetonSymbol)
        - blockPlaces(places : Place[*])
        - blockPlaces(place : Place)
        - blockPlaces(placeCard : PlaceCard)
        + isBlockedPlace(card : PlaceCard) : Boolean
        + isJetonOnPlace(place : Place) : Boolean
        + isJetonOnPlace(placeCard : PlaceCard) : Boolean
        + findJetonsSymbolsOnCard(placeCard : PlaceCard) : JetonSymbol[*]
        + isJetonSymbolOnPlaceCard(symbol : JetonSymbol,placeCard : PlaceCard) : boolean
        + getPlanetPawn() : PlanetPawn
        + canMovePlanetPawn() : Boolean
        + movePlanetPawn() : Boolean
        - forceMovePlanetPawn()
        - moveBackPlanetPawn()
        - resetPawn()
        - placesWhereJetonCreatureIs() : PlaceCard[*]
        - getPlaceCardsInInterval(a : Integer, b : Integer) : PlaceCard[*]
        + planetPawnIsActive() : Boolean
        + getPlanetPawnType() : PawnType
        + canUseEpavePower() : boolean
        - setEpavePowerToUsed()
        + placeToPlaceCard(place : Place) : PlaceCard
        + isASurvivalCardOnPlace(place : Place) : boolean
        + isASurvivalCardOnPlace(placeCard : PlaceCard) : boolean
        + takeSurvivalCardOnPlace(place : Place) : SurvivalCard
        + takeSurvivalCardOnPlace(placeCard : PlaceCard) : SurvivalCard
        - putSurvivalCardOnPlace(pair : Pair<Place, SurvivalCard>)
        - putSurvivalCardOnPlace(pair : (Pair<Place, SurvivalCard>)[*])
        + placeToNumber(place : Place) : Integer
        + numberToPlace(number : Integer) : Place
        + isAdjacentPlaces(place1 : Integer, place2 : Integer) : boolean
        + isAdjacentPlaces(placeCard : PlaceCard, place : Place) : boolean
        + isAdjacentPlaces(placeCard1 : PlaceCard, placeCard1 : PlaceCard) : boolean
        + isAdjacentPlaces(place1 : Place, place2 : Place) : boolean
        + isHiddenCards() : boolean
        + getHiddenCards() : PlaceCard[*]
        + getHiddenPlaces() : Place[*]
        - revealPlace(place : Place)
        - revealPlace(placeCard : PlaceCard)
        + isRevealedPlace(place : Place): boolean
        + isRevealedPlace(placeCard : PlaceCard): boolean
        - swapJeton(symbol1 : JetonSymbol, symbol2 : JetonSymbol)
    }

    abstract class PlanetPawn{
        + {abstract} getType() : PawnType
        - {abstract} nextState()
        - previousState()
        + {abstract} isActive() : Boolean
        + {abstract} maxMovesInOneRound() : Integer
        - reset()
    }



    class ShieldPawn{
        - location : Integer
        - hasReachDome : boolean
        + getLocation() : Integer
        - nextState()
        - previousState()
        + isActive() : Boolean
        + getType() : PawnType
        + maxMovesInOneRound() : Integer
        - reset()
    }


    Planet "1" -- "1 placeDistribution" PlaceDistribution
    Planet "1" -- "1 planetPawn" PlanetPawn
    PlanetPawn <|-- ShieldPawn
    PlanetPawn <|-- BeaconPawn
}
....


=== Player
.Package player
[plantuml]
....
package player{
    enum PlayerTeam{
        CREATURE
        TRAQUE
    }
    abstract class Player{
        # name : String
        # inGameId : Integer
        # Phase : currentPhase
        + getName() : String
        + getInGameId() : Integer
        + getCurrentPhase() : Phase
        + {abstract} getTeam() : PlayerTeam
        - setCurrentPhase(currentPhase : Phase)
        + teamEqualsTo(team : PlayerTeam) : boolean
    }

    class Traque{
        - numberWillingness : Integer
        - hand : HandTraque
        - rights : TraqueRight
        - placeCardsPlayedAfterMoving : PlaceCard[*]
        - placeCardsPlayedAndVisible : PlaceCard[*]
        + getNumberWillingness() : Integer
        + getMaxWillingness() : Integer
        + getHand() : HandTraque
        + getRights() : TraqueRight
        - addWillingness(delta : Integer)
        - subWillingness(delta : Integer)
        - incrementWillingness()
        - decrementWillingness()
        - fillWillingness()
        - addPlaceCardsAfterMoving(placeCard : PlaceCard)
        - addPlaceCardsAfterMoving(placeCards : PlaceCard[*])
        + getPlaceCardsPlayedAndVisible() : PlaceCard[*]
        - addPlaceCardsPlayedAndVisible(placeCard : PlaceCard)
        - addPlaceCardsPlayedAndVisible(placeCards : PlaceCard[*])
        - reset()
        + getTeam() : PlayerTeam
        + getPlaceCards() : PlaceCard[*]
        + getPlaceCardsPlayed() : PlaceCard[*]
        + getDefausse() : PlaceCard[*]
        - setPlaceCards(placeCards : PlaceCard[*])
        - setDefausse(placeCards : PlaceCard[*])
        + placeCardHandSize() : Integer
        + placeCardIsEmpty() : boolean
        + defausseSize() : Integer
        + defausseIsEmpty() : boolean
        + placeCardPlayedSize() : Integer
        + placeCardPlayedIsEmpty() : boolean
        + throwAwayPlaceCard() : boolean
        + throwAwayPlaceCard(placeCard : PlaceCard) : boolean
        + throwAwayPlaceCard(placeCards : PlaceCard[*]) : boolean
        + takeBackPlaceCard(placeCard : PlaceCard) : boolean
        + takeBackPlaceCard(placeCards : PlaceCard[*]) : boolean
        - takeBackAllPlaceCardFromDefausse()
        + addPlaceCard(placeCard : PlaceCard) : boolean
        + addPlaceCard(placeCards : PlaceCard[*]) : boolean
        + addPlaceCardInDefausse(placeCard : PlaceCard) : boolean
        + addPlaceCardInDefausse(placeCards : PlaceCard[*]) : boolean
        + playPlaceCard(placeCard : PlaceCard) : boolean
        + playPlaceCard(placeCards : PlaceCard[*]) : boolean
        + getSurvivalCardsHand() : SurvivalCard[*]
        + getSurvivalCardsPlayed() : SurvivalCard[*]
        + survivalCardHandSize() : Integer
        + survivalCardPlayedSize() : Integer
        + survivalCardIsEmpty() : boolean
        + survivalCardPlayedIsEmpty() : boolean
        - clearSurvivalCardPlayed()
        + addSurvivalCard(survivalCard : SurvivalCard) : boolean
        + addSurvivalCard(survivalCards : SurvivalCard[*]) : boolean
        + removeSurvivalCard(survivalCard : SurvivalCard) : boolean
        + removeSurvivalCard(survivalCards : SurvivalCard[*]) : boolean
        + playSurvivalCard(survivalCard : SurvivalCard) : boolean
        + playSurvivalCard(survivalCards : SurvivalCard[*]) : boolean
        - addSurvivalCardToApplied(survivalCard : SurvivalCard)
        - removeSurvivalCardToApplied(survivalCard : SurvivalCard)
        - removeSurvivalCardToApplied(survivalCards : SurvivalCard[*])
        + getSurvivalCardsToApplied() : SurvivalCard[*]
        - resetRight()
        + getMaxPlacesCardChoosable() : Integer
        - setMaxPlacesCardChoosable(maxPlacesCardChoosable : Integer)
        + getMaxPlacesCardPlayable() : Integer
        - setMaxPlacesCardPlayable(maxPlacesCardPlayable : Integer)
        + getMaxSurvivalCardPlayable() : Integer
        - setMaxSurvivalCardPlayable(maxSurvivalCardPlayable : Integer)
        + canResist() : boolean
        - setCanResist(canResist : boolean)
        + canGiveUp() : boolean
        - setCanGiveUp(canGiveUp : boolean)
        + getPlaceCardsVisible() : Integer
        - setPlaceCardsVisible(placeCardsVisible : Integer)
        + canResist() : Integer
        - setCanResist(number : Integer)

    }

    class Creature{
        - hand : HandCreature
        - rights : CreatureRight
        + getHand() : HandCreature
        + getRights() : CreatureRight
        + getTeam() : PlayerTeam
        - reset()
        - initializationJeton()
        + jetonsSize() : Integer
        + jetonsPlayedSize() : Integer
        + jetonsIsEmpty() : boolean
        + getJetons() : JetonSymbol[*]
        + playJeton(jeton : JetonSymbol) : boolean
        + playJeton(jetons : JetonSymbol[*]) : boolean
        + jetonsPlayedIsEmpty() : boolean
        + getMaxTrackingCards() : Integer
        + getTrackingCardHand() : TrackingCard[*]
        + getTrackingCardsPlayed() : TrackingCard[*]
        + trackingCardHandSize() : Integer
        + trackingCardPlayedSize() : Integer
        + trackingCardIsEmpty() : Boolean
        + trackingCardPlayedIsEmpty() : Boolean
        - clearTrackingCardPlayed()
        + addTrackingCard(trackingCard : TrackingCard) : Boolean
        + addTrackingCard(trackingCards : TrackingCard[*]) : Boolean
        + removeTrackingCard(trackingCard : TrackingCard) : Boolean
        + removeTrackingCard(trackingCards : TrackingCard[*]) : Boolean
        + playTrackingCard(trackingCard : TrackingCard) : Boolean
        + playTrackingCard(trackingCards : TrackingCard[*]) : Boolean
        - addTrackingCardToApplied(trackingCard : TrackingCard)
        - addTrackingCardToApplied(trackingCards : TrackingCard[*])
        - removeTrackingCardToApplied(trackingCard : TrackingCard)
        - removeTrackingCardToApplied(trackingCards : TrackingCard[*])
        - setMaxTrackingCardPlayable(maxTrackingCardPlayable : Integer)
        + getTrackingCardToApplied() : TrackingCard[*]
        + getMaxTrackingCardPlayable() : Integer



    }

    package rights{
        class TraqueRight{
            - maxPlacesCardChoosable : Integer
            - placeCardsVisible : Integer
            - maxPlacesCardPlayable : Integer
            - maxSurvivalCardPlayable : Integer
            - canResist : boolean
            - canGiveUp : boolean
            - numberOfAdditionalCardsTakeBackPerPawnWillingnessLostWithResist : Integer
            - reset()
            + getMaxPlacesCardChoosable() : Integer
            - setMaxPlacesCardChoosable(maxPlacesCardChoosable : Integer)
            + getMaxPlacesCardPlayable() : Integer
            - setMaxPlacesCardPlayable(maxPlacesCardPlayable : Integer)
            + getMaxSurvivalCardPlayable() : Integer
            - setMaxSurvivalCardPlayable(maxSurvivalCardPlayable : Integer)
            + getPlaceCardsVisible() : Integer
            - setPlaceCardsVisible(placeCardsVisible : Integer)
            + getNumberOfAdditionalCardsTakeBackPerPawnWillingnessLostWithResist() : Integer
            - setNumberOfAdditionalCardsTakeBackPerPawnWillingnessLostWithResist(number : Integer)
            + canResist() : boolean
            - setCanResist(canResist : boolean)
            + canGiveUp() : boolean
            - setCanGiveUp(canGiveUp : boolean)

        }

        class CreatureRight{
            - maxTrackingCardPlayable : Integer
            + getMaxTrackingCardPlayable() : Integer
            - setMaxTrackingCardPlayable(maxTrackingCardPlayable : Integer)
            - reset()
        }
    }

    package hand{
        class Deck <T extends PlayerCard>{
            - cards : T[*]
            - playedCards : T[*]
            - maxCards : Integer
            + getMaxCards(): Integer
            + getCards(): T[*]
            + getPlayedCards(): T[*]
            - clear()
            + add(card : T) : Boolean
            + add(cardList : T[*]) : Boolean
            + remove(card : T) : Boolean
            + remove(cardList : T[*]) : Boolean
            + playCard(card : T) : T
            + playCard(cardList : T[*]): T[*]
            + handSize(): Integer
            + playedCardSize(): Integer
            + handIsEmpty(): boolean
            + playedCardIsEmpty(): boolean

        }

        class PlaceCardDeck{
            - placeCards : PlaceCard[*]
            - defausse : PlaceCard[*]
            - playedCards : PlaceCard[*]
            + getPlayedCards() : PlaceCard[*]
            + getPlaceCards() : PlaceCard[*]
            + getDefausse() : PlaceCard[*]
            - setPlaceCards(placeCards : PlaceCard[*])
            - setDefausse(defausse : PlaceCard[*])
            - setPlayedCards(playedCards : PlaceCard[*])
            + throwAway() : Boolean
            + throwAway(card : PlaceCard) : Boolean
            + throwAway(cards : PlaceCard[*]) : Boolean
            + takeBack(card : PlaceCard) : Boolean
            + takeBack(cards : PlaceCard[*]) : Boolean
            - takeBackAllFromDefausse()
            - takeBackPlayedPlaceCards()
            + add(card : PlaceCard) : Boolean
            + add(cards : PlaceCard[*]) : Boolean
            + addInDefausse(card : PlaceCard) : Boolean
            + addInDefausse(cards : PlaceCard[*]) : Boolean
            + play(card : PlaceCard) : Boolean
            + play(cards : PlaceCard) : Boolean
            + handSize() : Integer
            + handIsEmpty() : boolean
            + defausseSize() : Integer
            + defausseIsEmpty() : boolean
            + playedCardSize() : Integer
            + playedCardIsEmpty() : boolean
        }

        class HandCreature{
            - trackingCards : Deck<TrackingCard>
            - jetons : JetonSymbol[*]
            - jetonSymbolsPlayed : JetonSymbol[*]
            - trackingCardsToApplied : TrackingCard[*]
            - initializationJeton()
            - addTrackingCardToApplied(trackingCard : TrackingCard)
            - addTrackingCardToApplied(trackingCards : TrackingCard[*])
            - removeTrackingCardToApplied(trackingCard : TrackingCard)
            - removeTrackingCardToApplied(trackingCards : TrackingCard[*])
            + getTrackingCardToApplied() : TrackingCard[*]
            + getJetonSymbolsPlayed() : JetonSymbol[*]
            + getJetonSymbols() : JetonSymbol[*]
            + playJeton(jeton : Jeton) : Boolean
            + playJeton(jetons : Jeton[*]) : Boolean
            + jetonsSize() : Integer
            + jetonsPlayedSize() : Integer
            + jetonsIsEmpty() : boolean
            + jetonsPlayedIsEmpty() : boolean
            + getMaxTrackingCards() : Integer
            + getTrackingCardsDeck() : Deck<TrackingCard>
            + getTrackingCardHand() : TrackingCard[*]
            + getTrackingCardsPlayed() : TrackingCard[*]
            + trackingCardHandSize() : Integer
            + trackingCardPlayedSize() : Integer
            + trackingCardIsEmpty() : boolean
            + trackingCardPlayedIsEmpty() : boolean
            - clearTrackingCardPlayed()
            + addTrackingCard(trackingCard : TrackingCard) : boolean
            + addTrackingCard(cardList : TrackingCard[*]) : boolean
            + removeTrackingCard(trackingCard : TrackingCard) : boolean
            + removeTrackingCard(cardList : TrackingCard[*]) : boolean
            + playTrackingCard(trackingCard : TrackingCard) : boolean
            + playTrackingCard(cardList : TrackingCard[*]) : boolean

        }

        class HandTraque{
            - survivalCards : Deck<SurvivalCard>
            - placeCards : PlaceCardDeck
            - survivalCardsToApplied : SurvivalCard[*]
            - addSurvivalCardToApplied(survivalCard : SurvivalCard)
            - addSurvivalCardToApplied(survivalCards : SurvivalCard[*])
            - removeSurvivalCardToApplied(survivalCard : SurvivalCard)
            - removeSurvivalCardToApplied(survivalCards : SurvivalCard[*])
            + getSurvivalCardsToApplied() : SurvivalCard[*]
            + getPlaceCards() : PlaceCard[*]
            + getPlaceCardsPlayed() : PlaceCard[*]
            + getDefausse() : PlaceCard[*]
            - setPlaceCards(placeCards : PlaceCard[*])
            - setDefausse(placeCards : PlaceCard[*])
            + getPlaceCardsDeck() : PlaceCardDeck
            + placeCardHandSize() : Integer
            + placeCardIsEmpty() : boolean
            + defausseSize() : Integer
            + defausseIsEmpty() : boolean
            + placeCardPlayedSize() : Integer
            + placeCardPlayedIsEmpty() : boolean
            + throwAwayPlaceCard() : boolean
            + throwAwayPlaceCard(card : PlaceCard) : boolean
            + throwAwayPlaceCard(cards : PlaceCard[*]) : boolean
            + takeBackPlaceCard(card : PlaceCard) : boolean
            + takeBackPlaceCard(cards : PlaceCard[*]) : boolean
            + takeBackPlayedPlaceCards(card : PlaceCard) : boolean
            + takeBackPlaceCard(cards : PlaceCard[*]) : boolean
            - takeBackPlayedPlaceCards()
            - takeBackAllPlaceCardFromDefausse()
            + addPlaceCard(card : PlaceCard) : boolean
            + addPlaceCard(cards : PlaceCard[*]) : boolean
            + addPlaceCardInDefausse(card : PlaceCard) : boolean
            + addPlaceCardInDefausse(cards : PlaceCard[*]) : boolean
            + playPlaceCard(card : PlaceCard) : boolean
            + playPlaceCard(cards : PlaceCard[*]) : boolean
            + getSurvivalCardsDeck() : Deck<SurvivalCard>
            + getSurvivalCardsHand() : SurvivalCard[*]
            + getSurvivalCardsPlayed() : SurvivalCard[*]
            + survivalCardHandSize() : Integer
            + survivalCardPlayedSize() : Integer
            + survivalCardIsEmpty() : boolean
            + survivalCardPlayedIsEmpty() : boolean
            - clearSurvivalCardPlayed()
            + addSurvivalCard(card : SurvivalCard) : boolean
            + addSurvivalCard(cards : SurvivalCard[*]) : boolean
            + removeSurvivalCard(card : SurvivalCard) : boolean
            + removeSurvivalCard(cards : SurvivalCard[*]) : boolean
            + playSurvivalCard(card : SurvivalCard) : boolean
            + playSurvivalCard(cards : SurvivalCard[*]) : boolean


        }


        HandTraque "1" -- "1" PlaceCardDeck
        HandCreature "1" -- "1" Deck
        HandTraque "1" -- "1" Deck
    }

    Player <|-- Creature
    Player <|-- Traque

    PlayerStatus <|-- CreatureRight
    PlayerStatus <|-- TraqueRight

    Creature "1" - "1" CreatureRight
    Traque "1" - "1" TraqueRight
}

....




=== Power
.Package power
[plantuml]
....
package power{
    class Power{

    }

    class PowerContainer{

    }

    PowerContainer "1" -- "*" Power
}
....


=== Utilitary
.Package utilitary
[plantuml]
....
package utilitary{
    package request{
        enum GameRequestType{
            JOIN
        }

        abstract class GameRequest{
            + {abstract} getType() : GameRequestType
        }

        class GameJoinRequest{
            - playerId : String
            - id : Integer
            + getPlayerID() : Integer
            + getId() : Integer
            + getType() : GameRequestType
        }
    }

    class RequestConversion{
        - {static} DATABASE : NotAloneDatabase
        + {static} toPhase(s : String) : Phase
        + {static} toPhase(tphase : TPhaseId) : Phase
        + {static} toBoardColor(s : String) : BoardColor
        + {static} toBoardColor(color : TColor) : BoardColor
        + {static} toBoardDistribution(s : String) : BoardDistribution
        + {static} toBoardDistribution(tBoard : TBoard) : BoardDistribution
        + {static} toCardType(s : String) : CardType
        + {static} toCard(tCard : TCard) : Card
        + {static} toPlaceCardList(cards : TCards[*]) : PlaceCard[*]
    }
}
GameRequest <|-- GameJoinRequest
....

=== GameController
.Package gamecontroller
[plantuml]
....
package gamecontroller{
    interface GameControllerInteface{
        + isFinish() : Boolean
        + apply(power : Power)
        + apply(powers : PowerContainer)
        + playerHasFinished(playerId : Integer, phase : Phase)
        + phaseIsFinish() : Boolean
        + playerPlayCard(playerId : Integer, card : Card)
        + playerPlayCard(playerId : Integer, cards : Card[*])

        + playerPlaceJeton(playerId : Integer, jeton : PlacedJeton)
        + playerPlaceJeton(playerId : Integer, jetons : PlacedJeton[*])

        + playerResist(playerId : Integer)
        + playerGiveUp(playerId : Integer)
        + playerChooseAction(playerID : Integer, action : Action)
    }
}
....


=== Game
.Game
[plantuml]
....
class Game{
    -  requests : BlockingQueue<GameRequest>
    - numberPlayers : AtomicInteger
    - gameId : String
    - gameCreatorId : String
    - planet : Planet
    - board : Board
    - players : Map<String, Pair<Integer, PlayerTeam>>
    - isStart : Boolean
    - isClose : Boolean
    - play : Thread
    + getGameId() : String
    + getPlayers() : Map<String, Pair<Integer, PlayerTeam>>
    + getPlanet() : Planet
    + isCreator(playerId : String) : Boolean
    + join(playerId : String) : Response
    + start(playerId :String) : Response
    - requestManagement()
    - handleRequest(request : GameRequest)
}

class GameFactory{
    - {static} idCounter : AtomicInteger
    - {static} createGame(playerId : String, board : Board, planet : Planet) : Game
}

....


=== Divers

=== Player
.Divers
[plantuml]
....
enum Phase{
    PREPHASE_1
    PHASE_1
    POSTPHASE_1
    PREPHASE_2
    PHASE_2
    POSTPHASE_2
    PREPHASE_3
    PHASE_3
    POSTPHASE_3
    PREPHASE_4
    PHASE_4
    POSTPHASE_4
}

class Reserve{
    - placeCards : Map<Integer, Pair<PlaceCard, Integer>>
    - copiesNumber(playerNumber : Integer) : Integer
    + notEmpty(cardNumber : Integer) : Boolean
    + pick(cardNumber : Integer) : PlaceCard
}

....


== Game Server (example)

.GameSever
[plantuml]
....
interface GameServer {
    createGame(numberOfPlayers : Integer): Integer
    join(gameId : Integer): Integer
}

package room {
    class "GameServerController" as controller {
        createGame(numberOfPlayers : Integer): Integer
        join(gameId : Integer): Integer
    }
    class "Game \n[Thread]" as room {
        id : Integer {id}
        numberOfPlayers : Integer
    }
    class "Player" as player {
        id : Integer {id}
    }
    GameServer <|-- controller
    controller *- "[*] games" room : \t\t\t
    room *-- "[0..7] players" player
}
note right of room: Uncompleted!
....

[plantuml]
....
state Game {
    [*] --> Created
    Created -> Started : start()
    Started -> Phase1 : \t
    Phase1 --> [*]
}
note right of Game : Uncompleted!
....

=== Opérations du GameServerController

.Create Game
[source,OCL]
----
GameServerController::createGame(numberOfPlayers : Integer): Integer
pre:
    numberOfPlayers > 1 and numberOfPlayers <= 7

post:
    self.games -> exists(each | each.isOclNew())and
    room.oclinState(Created)
----

.Join Game
[source,OCL]
----
GameServerController::join(gameId : Integer): Integer
pre:
    self.games -> exists(each | each.id = gameId)
post:
    let room = self.games->select(id = gameId)->first() in
    room.players->exists(each| each.isOclNew())
----

.Start Game
[plantuml]
----
partition Game::run() {
    start
    while (enough players?)
        :JoinRequest<
        :handleRequest();
    endwhile
    :Game Start>
    stop
}
----