[JAVA] J'ai créé le côté serveur du jeu de cartes en ligne ④

Dernière fois ici

Créer une classe Deck

Oui, cette fois je vais enfin créer un deck. Utilisons fermement l'interface de liasse de papier que nous avons créée la dernière fois.

Tout d'abord, créez une classe

public class Deck{
    private Stack<Card> deck = new Stack();
}

Oui, nous avons un deck.

C'est une blague, mais maintenant nous avons une classe Deck avec des cartes comme Stack. À propos, Java Stack est une sous-classe de List.

Étant donné que le pont ne sort que du haut, j'ai utilisé la pile au lieu du tableau ou de la liste linéaire.

Implémentez CardSheaf.

public class Deck implements CardSheaf {

    private Stack<Card> deck = new Stack<>();

    public Deck(List<Card> deck) {
        this.deck.addAll(deck);
    }

    public Deck(Card... deck) {
        this.deck.addAll(Arrays.asList(deck));
    }

    @Override
    public int indexOf(Card card) {
        return CardSheaf.indexOf(deck, card);
    }

    //La classe CardSheaf ne fournit pas d'implémentation standard de cardSize, nous l'avons donc implémentée.
    //Récupérez simplement le nombre d'éléments.
    @Override
    public int cardSize() {
        return deck.size();
    }

    @Override
    public void addCard(Card card) {
        CardSheaf.addCard(deck, card);
    }

    @Override
    public void removeCard(Card card) {
        CardSheaf.removeCard(deck, card);
    }

    @Override
    public void removeCard(int index) {
        CardSheaf.removeCard(deck, index);
    }

    @Override
    public Card find(int number, Card.Mark mark) {
        return CardSheaf.find(deck, number, mark);
    }

    @Override
    public int indexOf(int number, Card.Mark mark) {
        return CardSheaf.indexOf(deck, number, mark);
    }

    @Override
    public Card getCard(int index) {
        return CardSheaf.getCard(deck, index);
    }

    @Override
    public Card takeCard(int index) {
        return CardSheaf.takeCard(deck, index).getValue();
    }
}

Dans la classe Deck, puisque la carte est gérée comme une liste, la méthode statique de CardSheaf est utilisée telle quelle.

Définir les méthodes requises pour Deck

import java.util.*;

public class Deck implements CardSheaf {

    private Stack<Card> deck = new Stack<>();

    /**
     *Initialisez le jeu avec les cartes de la liste.
     * @jeu de paramètres Une liste de toutes les cartes que vous voulez mettre dans votre deck en premier
     */
    public Deck(List<Card> deck) {
        this.deck.addAll(deck);
    }

    /**
     *Initialisez le jeu avec les cartes du tableau.
     * @jeu de paramètres Un tableau de toutes les cartes que vous voulez mettre dans le jeu en premier
     */
    public Deck(Card... deck) {
        this.deck.addAll(Arrays.asList(deck));
    }

    //Abréviation
    /**
     *Sortez la carte du dessus du jeu.
     */
    public Card take_top() {
        return deck.pop();
    }

    /**
     *Utilisé pour juger la première attaque au début de la partie.
     * @retour La carte du dessus du jeu
     */
    public Card first_step() {
        return this.take_top();
    }

    /**
     *Dessiner une carte.
     * @retour La carte du dessus du jeu
     */
    public Card draw() {
        return this.take_top();
    }

    /**
     *Appelé lorsqu'il est endommagé.
     * @retour La carte du dessus du jeu
     */
    public Card damage() {
        return this.take_top();
    }

    /**
     *Mélangez le jeu.
     */
    public void shuffle() {
        Collections.shuffle(deck);
    }

    /**
     *Déterminez s'il y a des cartes dans le paquet.
     * @retourne vrai s'il y a des cartes dans le paquet, faux sinon
     */
    public boolean hasCard() {
        return cardSize() > 0;
    }
}

Alors c'est tout pour cette fois.

La prochaine fois, je prévois de mettre en œuvre ma main.

La prochaine fois