Wir werden Player implementieren. Der Spieler hat eine Hand, ein Feld, einen Friedhof und ein Deck. Außerdem wird jedes Objekt privat gemacht, so dass es nicht direkt von außen berührt werden kann. Es ist etwas überflüssig, aber wenn Sie nur mit einem Objekt spielen, z. B. einem Deck-Shuffle, delegieren wir den Prozess.
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;
}
}
Jetzt werden wir verschiedene andere Methoden implementieren.
import javafx.util.Pair;
import java.util.ArrayList;
import java.util.List;
import static com.github.javakky.blackpoker4j.Card.Job.*;
public class Player {
//Abkürzung
/**
*Funktion zum Ziehen einer Karte.
*/
public void draw() {
this.hand.addCard(this.deck.draw());
}
/**
*Funktion zum Mischen des Decks.
*/
public void shuffle() {
this.deck.shuffle();
}
/**
*Ziehe mehrere Karten und füge sie deiner Hand hinzu.
*
* @param number Die Anzahl der Ziehungen.
*/
public void draws(int number) {
for (int i = 0; i < number; i++) {
this.shuffle();
}
}
/**
*Führen Sie zu Beginn des Spiels,Kartenwechsel.
*Lege die Oberseite des Decks auf den Friedhof(Erster Angriff / zweite Angriffsentscheidung).
*
* @return Der Ruß und die Nummer der gewürfelten Karte
*/
public Card firstStep() {
Card card = this.deck.first_step();
this.cemetery.addCard(card);
return card.clone();
}
/**
*Laden Sie alle Soldaten und Barrieren in Ihrem Feld auf.
*/
public void charge() {
this.field.chargeAll();
this.field.recoveryAll();
}
/**
*Finden Sie heraus, ob Sie Ihre Hand ablegen müssen.
*/
public boolean mustCleanUp() {
return this.hand.cardSize() > 7;
}
/**
*Wähle deine Hand und lege sie auf den Friedhof.
* {@link #mustCleanUp()}Wenn nicht wahr ist,Gibt false zurück.
*
* @param index Die Nummer der Hand, die verworfen werden soll
* @Rückgabe kann ausgeführt werden(Wirf die Karte weg)Ob oder nicht
*/
public boolean cleanUp(int index) {
if (!mustCleanUp()) return false;
this.cemetery.addCard(this.hand.getCard(index));
return true;
}
/**
*Nimm 1 Schadenspunkt(Lege eine Karte vom Stapel auf den Friedhof).
*/
public void damage() {
this.cemetery.addCard(this.deck.damage());
}
/**
*Erleide Schaden für Punkte(Lege die angegebene Anzahl Karten vom Stapel auf den Friedhof).
*
* @param number Die Anzahl der erhaltenen Schäden.
*/
public void damages(int number) {
for (int i = 0; i < number; i++)
this.damage();
}
/**
*Beschwöre eine Barriere.
*Nimm 1 Schadenspunkt,Setze eine Karte aus deiner Hand.
*
* @param index Koordinaten der einzustellenden Karte.
*/
public void setBarrier(int index) {
this.damage();
this.field.setBarrier(this.hand.getCard(index));
}
/**
*Soldaten herbeirufen.
*Fahren Sie eine Barriere,1 Schadenspunkt erhalten,Nehmen Sie eine Karte offen aus Ihrer Hand.
*Es können bis zu 2 bis 10 Karten ausgegeben werden.
*Die ausgewählte Karte erfüllt nicht die Bedingungen. ・ Gibt false zurück, wenn sich die ausgewählte Barriere im Laufwerkszustand befindet.
*
* @param handIndex Welche Zahl auf Ihrer Hand ist die Karte, die Sie spielen möchten
* @param barriereIndex Was ist die Barriere zum Fahren?
* @Rückkehr Hat es Ihnen gelungen, zu beschwören?
*/
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;
}
/**
*Ass beschwören.
*1 Schadenspunkt erhalten,Nehmen Sie eine Karte offen aus Ihrer Hand.
*Es kann 1 Karte ausgestellt werden.
*Gibt false zurück, wenn die ausgewählte Karte die Bedingungen nicht erfüllt.
*
* @param handIndex Die Nummer der Karte, die Sie ausgeben möchten, liegt in Ihrer Hand
* @Rückkehr Hat es Ihnen gelungen, zu beschwören?
*/
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;
}
/**
*Beschwöre einen Helden.
*Fahren Sie zwei Barrieren,1 Schadenspunkt erhalten,Nehmen Sie eine Karte offen aus Ihrer Hand.
*Karten, die ausgestellt werden können, sind 11 bis 13.
*Die ausgewählte Karte erfüllt nicht die Bedingungen. ・ Gibt false zurück, wenn sich die ausgewählte Barriere im Laufwerkszustand befindet.
*
* @param handIndex Die Nummer der Karte, die Sie ausgeben möchten, liegt in Ihrer Hand
* @param barriereIndex1 Was ist die Barriere zum Fahren?(1)
* @param barriereIndex2 Was ist die Barriere zum Fahren?(2 ..)
* @Rückkehr Hat es Ihnen gelungen, zu beschwören?
*/
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;
}
/**
*Beschwöre einen Zauberer.
*Fahren Sie eine Barriere,Wirf 1 Karte von deiner Hand ab,Nehmen Sie eine Karte offen aus Ihrer Hand.
*Die Karte, die ausgestellt werden kann, ist Joker.
*Die ausgewählte Karte erfüllt nicht die Bedingungen. ・ Gibt false zurück, wenn sich die ausgewählte Barriere im Laufwerkszustand befindet.
*
* @param handIndex Die Nummer der Karte, die Sie ausgeben möchten, liegt in Ihrer Hand
* @param barriereIndex Was ist die Barriere zum Fahren?
* @param costHandIndex Welche Nummer liegt in Ihrer Hand, um sie zu verwerfen?
* @Rückkehr Hat es Ihnen gelungen, zu beschwören?
*/
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;
}
/**
*Gibt die Karteninformationen des angreifenden Soldaten zurück.
*Von den Karten, die an den ausgewählten Koordinaten existieren,Angreifbares Kartenobjekt(Kopieren)Gib es zurück.
*Die Karte treibt den zurückkehrenden Soldaten an.
*
* @param soldatIndex Liste der Soldatenzahlen, die Sie angreifen möchten
* @Rückgabekarte Liste der Soldaten, die tatsächlich angreifen könnten(Kopieren)
*/
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()]);
}
/**
*Generationswechsel.
*Wird aufgerufen, wenn eine offene Karte eines Nicht-Soldaten zerstört wird.
*Schicke vom Deck auf den Friedhof, bis sich ein Nicht-Soldat umdreht,Wenn Sie es umdrehen, fügen Sie es Ihrer Hand hinzu.
*/
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);
}
/**
*Wird aufgerufen, wenn eine Karte auf dem Spielfeld zerstört wird.
* @param isFront Gibt an, ob die Karte offen liegt.
* @param index Wie lautet die Nummer der Karte, die in dieser Richtung zerstört werden soll?
*/
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);
}
/**
*Block mit Soldaten(Mehrere)
* @param soldateIndex Eine Liste der Reihenfolge der Soldaten, die Sie blockieren möchten
* @Rückgabe Gesamtleistung beim Blockieren
*/
public int declarationDefense(int[] soldierIndex) {
int number = 0;
for (int index: soldierIndex) {
this.field.drive(index, true);
number += this.field.getAttack(index);
}
return number;
}
/**
*Block mit einer Barriere(Mehrere)
* @param index Die Reihenfolge der Barrieren, die Sie blockieren möchten
* @return Die Nummer der zu blockierenden Barriere
*/
public int declarationDefenseBarrier(int index) {
this.field.drive(index, false);
this.field.open(index);
return this.field.getNumber(index, false);
}
}
Wir haben mögliche Aktionen wie Draws, Attacken und Attacken implementiert. Die Regeln finden Sie auf der offiziellen Seite.
Das nächste Mal planen wir die Implementierung eines Spielbretts (Spielautomat?).
Recommended Posts