[JAVA] Fait le côté serveur du jeu de cartes en ligne ⑤

Dernière fois ici

Créer un cours de main

Je vais faire un cours de main. Cette fois, j'allais finir seulement dans la classe de main, mais comme la classe de main était presque la même que celle de Deck, je ferai autre chose.

L'implémentation de la méthode est la même que celle de Deck, et le champ a adopté ArrayList en raison du grand nombre d'accès aléatoires.

import java.util.ArrayList;
import java.util.List;

public class Hand implements CardSheaf {
    
    private List<Card> hand = new ArrayList<>();

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

    @Override
    public int cardSize() {
        return hand.size();
    }

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

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

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

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

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

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

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

}

Créer un cours de cimetière

La classe de cimetière ressemble plus à un deck qu'à votre main, donc je ne l'expliquerai pas.

import java.util.Stack;

public class Cemetery implements CardSheaf {
    
    Stack<Card> cemetery = new Stack<>();


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

    @Override
    public int cardSize() {
        return cemetery.size();
    }

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

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

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

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

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

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

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

Créer une classe de champ

Tout d'abord, implémentez-le comme n'importe quelle autre classe. Préparez également une liste avec des cartes recto et verso séparées pour un retrait facile. Compte tenu du grand nombre d'accès aléatoires, ArrayList est utilisé.

package blackpoker;

import java.util.ArrayList;
import java.util.List;

public class Field implements CardSheaf {

    private List<Card> front = new ArrayList<>();
    private List<Card> back = new ArrayList<>();
    private List<Card> fields = new ArrayList<>();

    @Override
    public int indexOf(Card card) {
        if (card.isFront()) {
            return CardSheaf.indexOf(front, card);
        }
        return CardSheaf.indexOf(back, card);
    }

    @Override
    public int cardSize() {
        return front.size() + back.size();
    }

    /**
     *Renvoie le nombre de cartes.
     * @param isFront Qu'il s'agisse de la carte avant
     * @nombre de cartes de retour
     */
    public int cardSize(boolean isFront) {
        return isFront ? front.size() : back.size();
    }

    @Override
    public void addCard(Card card) {
        CardSheaf.addCard(fields, card);
        if (card.isFront()) {
            CardSheaf.addCard(front, card);
            return;
        }
        CardSheaf.addCard(back, card);
    }

    /**
     *Ajoutez une carte à la structure de données.
     * @param isFront Indique si la carte que vous souhaitez supprimer est la face avant.
     */
    public void addCard(Card card, boolean isFront) {
        CardSheaf.addCard(fields, card);
        if (isFront) {
            CardSheaf.addCard(front, card);
            return;
        }
        CardSheaf.addCard(back, card);
    }

    @Override
    public void removeCard(Card card) {
        CardSheaf.addCard(fields, card);
        if (card.isFront()) {
            CardSheaf.removeCard(front, card);
            return;
        }
        CardSheaf.removeCard(back, card);
    }

    @Override
    public void removeCard(int index) {
        Card rm = CardSheaf.getCard(fields, index);
        CardSheaf.removeCard(fields, rm);
        if (rm.isFront()) {
            CardSheaf.removeCard(front, rm);
            return;
        }
        CardSheaf.removeCard(back, rm);
    }

    /**
     *Retirez la carte de la structure de données.
     * @param isFront Indique si la carte que vous souhaitez supprimer est la face avant.
     */
    public void removeCard(int index, boolean isFront) {
        if (isFront) {
            CardSheaf.removeCard(front, index);
            return;
        }
        CardSheaf.removeCard(back, index);
    }

    @Override
    public Card find(int number, Card.Mark mark) {
        Card tmp = CardSheaf.find(front, number, mark);
        return tmp != null ? tmp : CardSheaf.find(back, number, mark);
    }

    @Override
    public int indexOf(int number, Card.Mark mark) {
        int tmp = CardSheaf.indexOf(front, number, mark);
        return tmp >= 0 ? tmp : CardSheaf.indexOf(back, number, mark);
    }

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

    public Card getCard(int index, boolean isFront) {
        if (isFront) {
            return CardSheaf.getCard(front, index);
        }
        return CardSheaf.getCard(back, index);
    }

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

    /**
     *Retirez la carte au numéro spécifié.
     *La carte est supprimée de la structure de données.
     * @param index Index de la carte souhaitée
     * @La carte param isFront est table(Pas une barrière)qu'il s'agisse. Vrai pour les tables
     */
    public Card takeCard(int index, boolean isFront) {
        if (isFront) {
            return CardSheaf.takeCard(front, index).getValue();
        }
        return CardSheaf.takeCard(back, index).getValue();
    }
}

Pour les fonctions autres que indexOf, préparez les fonctions qui peuvent être spécifiées pour chaque carte au dos et au recto. De plus, s'il n'y a pas de deuxième argument dans ajouter ou supprimer, j'ai décidé de faire référence à isFront de l'objet Card passé.

import java.util.ArrayList;
import java.util.List;

public class Field implements CardSheaf {

    private List<Card> front = new ArrayList<>();
    private List<Card> back = new ArrayList<>();
    private List<Card> fields = new ArrayList<>();

    //Abréviation

    /**
     *Définissez la barrière.
     */
    public void setBarrier(Card card) {
        if (card.isFront()) card.setFront(false);
        if (card.isCharge()) card.setCharge(false);
        if (card.canAttack()) card.setFront(false);
        addCard(card, false);
    }

    /**
     *Mettez la carte face vers le haut.(Soldat etc.)
     */
    public void summon(Card card) {
        if (!card.isFront()) card.setFront(true);
        if (card.isCharge()) card.setCharge(false);
        addCard(card, true);
        switch (card.getJob()) {
            case ACE:
            case MAGICIAN:
                card.setCanAttack(true);
                break;
            default:
                card.setCanAttack(false);
                break;
        }
    }

    /**
     *Peut attaquer(Affichage frontal)Renvoyez la carte dans une liste.
     */
    public List<Card> lookAttackable(){
        List<Card> attackable = new ArrayList<>();
        for (Card tmp: front){
            if(tmp.canAttack()) attackable.add(tmp);
        }
        return attackable;
    }

    /**
     *Désigné(Affichage frontal)Rendez la carte attaquable.
     * @param index L'index de la carte que vous voulez pouvoir attaquer.
     */
    public void recovery(int index){
        front.get(index).setCanAttack(true);
    }

    /**
     *Tout(Affichage frontal)Rendez la carte attaquable.
     */
    public void recoveryAll(){
        for(Card tmp: front){
            if(tmp != null) tmp.setCanAttack(true);
        }
    }

    /**
     *Chargez la carte spécifiée.
     * @param index L'index de la carte que vous souhaitez charger.
     * @param isFront Indique si la carte est recto.
     */
    public void charge (int index, boolean isFront){
        if(isFront){
            front.get(index).setCharge(true);
        }else{
            back.get(index).setCharge(true);
        }
    }

    /**
     *Chargez toutes les cartes face visible.
     */
    public void chargeAllFront(){
        for(Card tmp: front){
            tmp.setCharge(true);
        }
    }

    /**
     *Chargez toutes les cartes affichées au verso.
     */
    public void chargeAllBack(){
        for(Card tmp: back){
            tmp.setCharge(true);
        }
    }

    /**
     *Chargez toutes les cartes.
     */
    public void chargeAll(){
        chargeAllFront();
        chargeAllBack();
    }

    /**
     *Conduisez la carte spécifiée.
     * @param index L'index de la carte que vous voulez conduire.
     * @param isFront Indique si la carte est recto.
     */
    public void drive (int index, boolean isFront){
        if(isFront){
            front.get(index).setCharge(false);
        }else{
            back.get(index).setCharge(false);
        }
    }

    /**
     *Conduisez toutes les cartes face visible.
     */
    public void driveAllFront(){
        for(Card tmp: front){
            tmp.setCharge(false);
        }
    }

    /**
     *Conduisez toutes les cartes au verso.
     */
    public void driveAllBack(){
        for(Card tmp: back){
            tmp.setCharge(false);
        }
    }

    /**
     *Conduisez toutes les cartes.
     */
    public void driveAll(){
        driveAllFront();
        driveAllBack();
    }

    /**
     *Détruisez la carte.
     * @param index L'index de la carte que vous souhaitez détruire.
     * @param isFront Si la carte que vous souhaitez détruire est face visible.
     * @retour L'objet de la carte détruite.
     */
    public Card destruction (int index, boolean isFront){
        return takeCard(index, isFront);
    }

    /**
     *Tournez le dos de la carte vers l'avant.
     * @param index L'index de la carte que vous souhaitez placer au recto.
     */
    public void open(int index){
        Card tmp = takeCard(index, false);
        tmp.setFront(true);
        addCard(tmp, true);
    }

    /**
     *Si la carte spécifiée est dans l'état du lecteur.
     */
    public boolean isDrive(int barrierIndex) {
        return !back.get(barrierIndex).isCharge();
    }

    /**
     *Découvrez si le soldat sélectionné peut attaquer.
     * @param index Ordre des soldats que vous voulez vérifier(Dans la carte face visible)
     */
    public boolean canAttack(int index) {
        return front.get(index).canAttack();
    }

    /**
     *Renvoie une copie de l'objet du soldat sélectionné.
     * @param index Ordre des soldats que vous voulez vérifier(Dans la carte face visible)
     * @retour Une copie de l'objet carte soldat
     */
    public Card getSoldierData(int index) {
        return front.get(index).clone();
    }


    /**
     *Renvoie le numéro du soldat sélectionné.
     * @param index Ordre des soldats que vous voulez vérifier(Dans le même sens carte)
     * @La carte param isFront est-elle une table?
     * @numéro de carte de retour
     */
    public int getNumber(int index, boolean isFront) {
        List<Card> list = isFront ? front: back;
        return list.get(index).getNumber();
    }

}

Fondamentalement, comme je l'ai écrit dans le commentaire. Cependant, je n'expliquerai que la convocation pour le moment. La méthode d'invocation, comme setBarrier, ajoute des cartes à la liste entière et à la liste des cartes affichées, et aligne si elles sont au recto ou non et si elles sont facturées. De plus, ace (1) et magician (joker) définissent canAttack sur true en raison de la règle selon laquelle ils ne tombent pas malades.

Jusqu'à ici pour cette fois. La prochaine fois, j'aimerais créer une classe Player.

La prochaine fois

Recommended Posts

Fait le côté serveur du jeu de cartes en ligne ⑤
J'ai créé le côté serveur du jeu de cartes en ligne ③
J'ai créé le côté serveur du jeu de cartes en ligne ⑥
J'ai créé le côté serveur du jeu de cartes en ligne ④
J'ai créé le côté serveur du jeu de cartes en ligne ②
J'ai créé le côté serveur du jeu de cartes en ligne ①
J'ai créé un serveur écologique avec scala
J'ai créé un jeu Janken en Java (CLI)
J'ai créé une image Docker pour la version japonaise de SDAPS
J'ai fait un jeu de problèmes de calcul simple en Java
J'ai créé un serveur et un client Restful au printemps.
Une brève explication d'un jeu de labyrinthe fait à Java pour les cousins du primaire
J'ai essayé de faire une version japonaise de la transmission automatique du courrier de Rails / devise
Création du côté serveur d'un jeu de cartes en ligne [Table of Contents]
J'ai créé une application de chat.
J'ai essayé JAX-RS et pris note de la procédure
Une histoire sur la connexion à un serveur CentOS 8 avec un ancien Ansible
J'ai fait un petit bijou pour poster le texte du mode org sur qiita
J'ai créé un outil pour afficher la différence du fichier CSV
J'ai créé une application shopify @java
J'ai créé une interface graphique avec Swing
J'ai fait une simple fonction de recommandation.
J'ai fait une annotation en Java.
J'ai créé une application correspondante (application Android)
J'ai créé un outil de génération package.xml.
[Android] J'ai créé une application de podomètre.
[Ruby] J'ai créé un simple client Ping
J'ai fait une mort risquée avec Ruby
J'ai créé un plug-in pour IntelliJ IDEA
J'ai créé une application Janken avec kotlin
J'ai créé une application de calculatrice sur Android
J'ai créé un nouvel outil de déploiement Java
J'ai créé une application Janken avec Android
Un exemple simple du modèle MVC
Apprendre Java avec Progate → Je vais vous expliquer parce que j'ai moi-même créé un jeu de base
Rails6 Je veux créer un tableau de valeurs avec une case à cocher
J'ai fait un exemple de la façon d'écrire un délégué dans Swift UI 2.0 à l'aide de MapKit