Nous allons implémenter Player. Le joueur a une main, un champ, un cimetière et un deck. De plus, chaque objet est rendu privé afin qu'il ne puisse pas être directement touché de l'extérieur. C'est un peu redondant, mais si vous voulez jouer avec un seul objet, comme un mélange de deck, nous déléguerons le processus.
public class Player {
private final Hand hand;
private final Field field;
private final Cemetery cemetery;
private final Deck deck;
private boolean canAttack;
public Player(Card[] deck_list) {
this.hand = new Hand();
this.field = new Field();
this.cemetery = new Cemetery();
this.deck = new Deck(deck_list);
this.setCanAttack(true);
}
public boolean canAttack() {
return canAttack;
}
public void setCanAttack(boolean canAttack) {
this.canAttack = canAttack;
}
}
Maintenant, nous allons implémenter diverses autres méthodes.
import javafx.util.Pair;
import java.util.ArrayList;
import java.util.List;
import static com.github.javakky.blackpoker4j.Card.Job.*;
public class Player {
//Abréviation
/**
*Fonction pour tirer une carte.
*/
public void draw() {
this.hand.addCard(this.deck.draw());
}
/**
*Fonction pour mélanger le jeu.
*/
public void shuffle() {
this.deck.shuffle();
}
/**
*Piochez plusieurs cartes et ajoutez-les à votre main.
*
* @param number Le nombre de tirages.
*/
public void draws(int number) {
for (int i = 0; i < number; i++) {
this.shuffle();
}
}
/**
*Jouez au début du jeu,Processus de retournement de carte.
*Mettez le dessus du pont dans le cimetière(Première attaque / deuxième décision d'attaque).
*
* @retour La suie et le numéro de la carte roulée
*/
public Card firstStep() {
Card card = this.deck.first_step();
this.cemetery.addCard(card);
return card.clone();
}
/**
*Chargez tous les soldats et barrières dans votre champ.
*/
public void charge() {
this.field.chargeAll();
this.field.recoveryAll();
}
/**
*Découvrez si vous devez jeter votre main.
*/
public boolean mustCleanUp() {
return this.hand.cardSize() > 7;
}
/**
*Choisissez votre main et mettez-la dans le cimetière.
* {@link #mustCleanUp()}Si ce n'est pas vrai,Renvoie false.
*
* @param index Le numéro de la main à jeter
* @le retour peut être exécuté(Jeter la carte)Que ce soit ou non
*/
public boolean cleanUp(int index) {
if (!mustCleanUp()) return false;
this.cemetery.addCard(this.hand.getCard(index));
return true;
}
/**
*Prendre 1 point de dégâts(Mettez une carte du paquet dans le cimetière).
*/
public void damage() {
this.cemetery.addCard(this.deck.damage());
}
/**
*Prendre des dégâts pour des points(Placez le nombre spécifié de cartes du paquet dans le cimetière).
*
* @param number Le nombre de dommages subis.
*/
public void damages(int number) {
for (int i = 0; i < number; i++)
this.damage();
}
/**
*Invoquer une barrière.
*Prendre 1 point de dégâts,Définissez une carte sélectionnée dans votre main.
*
* @param index Coordonnées de la carte à définir.
*/
public void setBarrier(int index) {
this.damage();
this.field.setBarrier(this.hand.getCard(index));
}
/**
*Invoquer des soldats.
*Conduisez une barrière,A reçu 1 point de dégâts,Sortez une carte de votre main face visible.
*Jusqu'à 2 à 10 cartes peuvent être émises.
*La carte sélectionnée ne remplit pas les conditions ・ Renvoie false si la barrière sélectionnée est dans l'état du lecteur.
*
* @param handIndex Le numéro de la carte que vous voulez sortir est dans votre main
* @param obstacleIndex Quelle est la barrière à conduire
* @retour Avez-vous réussi à convoquer?
*/
public boolean summonSoldier(int handIndex, int barrierIndex) {
if (this.field.isDrive(barrierIndex) && this.hand.getJob(handIndex) != SOLDIER) {
return false;
}
this.damage();
this.field.drive(barrierIndex, false);
Card card = this.hand.getCard(handIndex);
this.field.summon(card);
return true;
}
/**
*Invoquer Ace.
*A reçu 1 point de dégâts,Sortez une carte de votre main face visible.
*1 carte peut être émise.
*Renvoie false si la carte sélectionnée ne remplit pas les conditions.
*
* @param handIndex Le numéro de la carte que vous voulez sortir est dans votre main
* @retour Avez-vous réussi à convoquer?
*/
public boolean summonAce(int handIndex) {
if (this.hand.getJob(handIndex) != ACE) {
return false;
}
this.damage();
Card card = this.hand.getCard(handIndex);
this.field.summon(card);
return true;
}
/**
*Invoquer un héros.
*Conduisez deux barrières,A reçu 1 point de dégâts,Sortez une carte de votre main face visible.
*Les cartes pouvant être émises vont de 11 à 13.
*La carte sélectionnée ne remplit pas les conditions ・ Renvoie false si la barrière sélectionnée est dans l'état du lecteur.
*
* @param handIndex Le numéro de la carte que vous voulez sortir est dans votre main
* @param barrièreIndex1 Quelle est la barrière à conduire(1er)
* @param barrièreIndex2 Quelle est la barrière à conduire(2e)
* @retour Avez-vous réussi à convoquer?
*/
public boolean summonHero(int handIndex, int barrierIndex1, int barrierIndex2) {
if (this.field.isDrive(barrierIndex1) && this.field.isDrive(barrierIndex2) && this.hand.getJob(handIndex) != HERO) {
return false;
}
this.damage();
this.field.drive(barrierIndex1, false);
this.field.drive(barrierIndex2, false);
Card card = this.hand.getCard(handIndex);
this.field.summon(card);
return true;
}
/**
*Invoquer un magicien.
*Conduisez une barrière,Défaussez 1 carte de votre main,Sortez une carte de votre main face visible.
*La carte qui peut être émise est Joker.
*La carte sélectionnée ne remplit pas les conditions ・ Renvoie false si la barrière sélectionnée est dans l'état du lecteur.
*
* @param handIndex Le numéro de la carte que vous voulez sortir est dans votre main
* @param obstacleIndex Quelle est la barrière à conduire
* @param costHandIndex Quel nombre est dans votre main à défausser
* @retour Avez-vous réussi à convoquer?
*/
public boolean summonMagician(int handIndex, int costHandIndex, int barrierIndex) {
if (this.field.isDrive(barrierIndex) && this.hand.getJob(handIndex) != MAGICIAN) {
return false;
}
this.field.drive(barrierIndex, false);
if (handIndex > costHandIndex) {
Card card = this.hand.getCard(handIndex);
this.field.summon(card);
this.cemetery.addCard(this.hand.getCard(costHandIndex));
} else {
this.cemetery.addCard(this.hand.getCard(costHandIndex));
Card card = this.hand.getCard(handIndex);
this.field.summon(card);
}
return true;
}
/**
*Renvoie les informations de la carte du soldat attaquant.
*Des cartes qui existent aux coordonnées sélectionnées,Objet de carte attaquable(copie)rends le.
*La carte conduit le soldat de retour.
*
* @param soldierIndex Liste des numéros de soldat que vous voulez attaquer
* @retourne la liste des soldats qui pourraient réellement attaquer(copie)
*/
public Card[] declarationAttack(int[] soldierIndex) {
List<Card> attackers = new ArrayList<>();
for (int index : soldierIndex) {
if (this.field.canAttack(index)) {
attackers.add(this.field.getSoldierData(index));
this.field.drive(index, false);
}
}
return attackers.toArray(new Card[attackers.size()]);
}
/**
*Changement générationnel.
*Appelé lorsqu'une carte non soldat face recto est détruite.
*Envoyer du pont au cimetière jusqu'à ce que le non-soldat tourne,Si vous le retournez, ajoutez-le à votre main.
*/
public void alternation() {
Card card;
while (true) {
card = this.deck.takeTop();
if(Card.isNotSoldier(card.getJob())) break;
this.cemetery.addCard(card);
}
this.hand.addCard(card);
}
/**
*Appelé lorsqu'une carte sur le terrain est détruite.
* @param isFront Indique si la carte est face visible.
* @param index Quel est le numéro de la carte à détruire dans ce sens?
*/
public void destruction(boolean isFront, int index) {
Card card = this.field.destruction(index, isFront);
if(Card.isNotSoldier(card.getJob())) {
this.alternation();
}
this.cemetery.addCard(card);
}
/**
*Bloquer avec des soldats(Plusieurs)
* @param soldierIndex Une liste de l'ordre des soldats que vous souhaitez bloquer
* @retour Puissance totale lors du blocage
*/
public int declarationDefense(int[] soldierIndex) {
int number = 0;
for (int index: soldierIndex) {
this.field.drive(index, true);
number += this.field.getAttack(index);
}
return number;
}
/**
*Bloquer avec une barrière(Plusieurs)
* @param index L'ordre des barrières que vous souhaitez bloquer
* @retour Le numéro de la barrière à bloquer
*/
public int declarationDefenseBarrier(int index) {
this.field.drive(index, false);
this.field.open(index);
return this.field.getNumber(index, false);
}
}
Nous avons mis en œuvre des actions possibles telles que des tirages au sort, des attaques et des attaques. Veuillez consulter la page officielle pour les règles.
La prochaine fois, nous prévoyons de mettre en place un plateau de jeu (machine de jeu?).
Recommended Posts