conception.adoc + modification Creature.java pour la CLARTÉ

not-alone-doc/src/doc/asciidoc/_sections/conception.adoc

@@ -790,90 +790,139 @@ package player{
     }
 
     package rights{
-        class TraqueStatus{
-            - survivalCardsPlayed : SurvivalCard[*]
-            - placeCardsPlayed : PlaceCard[*]
-            + getSurvivalCardsPlayed() :  SurvivalCard[*]
-            + getPlaceCardsPlayed() : PlaceCard[*]
-            + playSurvivalCard(survivalCard : SurvivalCard)
-            + playSurvivalCard(survivalCards : SurvivalCard[*])
-            + playPlaceCard(placeCard : PlaceCard)
-            + playPlaceCard(placeCards : PlaceCard[*])
-            + clear()
+        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 CreatureStatus{
-            - trackingCardsPlayed : TrackingCard[*]
-            - jetonsPlayed : Jeton[*]
-            + getTrackingCardsPlayed() : TrackingCard[*]
-            + getJetonsPlayed() : Jeton[*]
-            + playTrackingCard(trackingCard : TrackingCard)
-            + playTrackingCard(trackingCards : TrackingCard[*])
-            + playJeton(placeCard : Jeton)
-            + playJeton(placeCards : Jeton[*])
-            + clear()
+        class CreatureRight{
+            - maxTrackingCardPlayable : Integer
+            + getMaxTrackingCardPlayable() : Integer
+            - setMaxTrackingCardPlayable(maxTrackingCardPlayable : Integer)
+            - reset()
         }
     }
 
-package hand{
-    class Deck <T extends PlayerCard>{
-        - cards : T[*]
-        - maxCards : Integer
-        + add(card : T) : Boolean
-        + add(cards : T[*]) : Boolean
-        + playCard(card : T) : T
-        + playCard(cards : T[*]): T[*]
-    }
+    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[*]
-        + throwAway(placeCard : PlaceCard) : Boolean
-        + throwAway(placeCards : PlaceCard[*]) : Boolean
-        + takeBack(placeCard : PlaceCard) : Boolean
-        + takeBack(placeCards : PlaceCard[*]) : Boolean
-        + add(card : PlaceCard) : Boolean
-        + add(cards : PlaceCard[*]) : Boolean
-        + addInDefausse(card : PlaceCard) : Boolean
-        + addInDefausse(cards : PlaceCard[*]) : Boolean
-        + play(card : PlaceCard) : Boolean
-        + play(cards : PlaceCard) : Boolean
-    }
+        }
 
-    abstract class Hand{}
+        class PlaceCardDeck{
+            - placeCards : PlaceCard[*]
+            - defausse : PlaceCard[*]
+            + throwAway(placeCard : PlaceCard) : Boolean
+            + throwAway(placeCards : PlaceCard[*]) : Boolean
+            + takeBack(placeCard : PlaceCard) : Boolean
+            + takeBack(placeCards : PlaceCard[*]) : Boolean
+            + add(card : PlaceCard) : Boolean
+            + add(cards : PlaceCard[*]) : Boolean
+            + addInDefausse(card : PlaceCard) : Boolean
+            + addInDefausse(cards : PlaceCard[*]) : Boolean
+            + play(card : PlaceCard) : Boolean
+            + play(cards : PlaceCard) : Boolean
+        }
 
-    class HandCreature{
-        - trackingCards : Deck<TrackingCard>
-        - jetons : Set<Jeton>
-        + initializationJeton()
-        + getTrackingCards() : Deck<TrackingCard>
-        + playJeton(jeton : Jeton) : Jeton
-        + playJeton(jetons : Set<Jeton>) : Set<Jeton>
-    }
+        abstract class Hand{}
+
+        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
-        + getSurvivalCards() : Deck<SurvivalCard>
-        + getPlaceCards() : PlaceCardDeck
-    }
+        }
 
-    Hand <|-- HandCreature
-    Hand <|-- HandTraque
+        class HandTraque{
+            - survivalCards : Deck<SurvivalCard>
+            - placeCards PlaceCardDeck
+            + getSurvivalCards() : Deck<SurvivalCard>
+            + getPlaceCards() : PlaceCardDeck
+        }
 
-    HandTraque "1" -- "1" PlaceCardDeck
-    HandCreature "1" -- "1" Deck
-    HandTraque "1" -- "1" Deck
-}
+        Hand <|-- HandCreature
+        Hand <|-- HandTraque
+
+        HandTraque "1" -- "1" PlaceCardDeck
+        HandCreature "1" -- "1" Deck
+        HandTraque "1" -- "1" Deck
+    }
 
     Player <|-- Creature
     Player <|-- Traque
 
-    PlayerStatus <|-- CreatureStatus
-    PlayerStatus <|-- TraqueStatus
+    PlayerStatus <|-- CreatureRight
+    PlayerStatus <|-- TraqueRight
 
-    Creature "1" - "1" CreatureStatus
-    Traque "1" - "1" TraqueStatus
+    Creature "1" - "1" CreatureRight
+    Traque "1" - "1" TraqueRight
 }
 
 ....

not-alone-server/src/main/java/fr/univnantes/alma/server/game/item/player/hand/HandCreature.java

@@ -143,16 +143,16 @@ public class HandCreature {
         trackingCards.clear();
     }
 
-    public boolean addTrackingCard(TrackingCard card){
-        return trackingCards.add(card);
+    public boolean addTrackingCard(TrackingCard trackingCard){
+        return trackingCards.add(trackingCard);
     }
 
     public boolean addTrackingCard(List<TrackingCard> cardList){
         return trackingCards.add(cardList);
     }
 
-    public boolean removeTrackingCard(TrackingCard card){
-        return trackingCards.remove(card);
+    public boolean removeTrackingCard(TrackingCard trackingCard){
+        return trackingCards.remove(trackingCard);
     }
 
     public boolean removeTrackingCard(List<TrackingCard> cardList){
@@ -160,8 +160,8 @@ public class HandCreature {
     }
 
 
-    public boolean playTrackingCard(TrackingCard card){
-        return trackingCards.play(card);
+    public boolean playTrackingCard(TrackingCard trackingCard){
+        return trackingCards.play(trackingCard);
     }
 
     public boolean playTrackingCard(List<TrackingCard> cardList){