Ich werde eine Handklasse machen. Dieses Mal wollte ich nur in der Handklasse abschließen, aber da die Handklasse fast dieselbe war wie Deck, werde ich andere Dinge tun.
Die Methodenimplementierung ist dieselbe wie bei Deck, und das Feld hat ArrayList aufgrund der großen Anzahl zufälliger Zugriffe übernommen.
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();
}
}
Die Friedhofsklasse ähnelt eher einem Deck als deiner Hand, deshalb werde ich es nicht erklären.
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();
}
}
Implementieren Sie es zunächst wie jede andere Klasse. Bereiten Sie außerdem eine Liste mit separaten Vorder- und Rückkarten zum einfachen Entfernen vor. In Anbetracht der großen Anzahl von Direktzugriffen wird ArrayList verwendet.
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();
}
/**
*Gibt die Anzahl der Karten zurück.
* @param isFront Ob es um die Frontkarte geht
* @Anzahl der Rückgabekarten
*/
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);
}
/**
*Fügen Sie der Datenstruktur eine Karte hinzu.
* @param isFront Ob die Karte, die Sie löschen möchten, die Vorderseite ist.
*/
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);
}
/**
*Entfernen Sie die Karte aus der Datenstruktur.
* @param isFront Ob die Karte, die Sie löschen möchten, die Vorderseite ist.
*/
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();
}
/**
*Entfernen Sie die Karte unter der angegebenen Nummer.
*Die Karte wird aus der Datenstruktur entfernt.
* @param index Index der gewünschten Karte
* @param isFront Karte ist Tabelle(Keine Barriere)ob. Richtig für Tabellen
*/
public Card takeCard(int index, boolean isFront) {
if (isFront) {
return CardSheaf.takeCard(front, index).getValue();
}
return CardSheaf.takeCard(back, index).getValue();
}
}
Bereiten Sie für andere Funktionen als indexOf Funktionen vor, die für jede Karte auf der Vorder- und Rückseite angegeben werden können. Wenn es kein zweites Argument zum Hinzufügen oder Entfernen gibt, habe ich mich entschlossen, auf isFront des übergebenen Kartenobjekts zu verweisen.
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<>();
//Abkürzung
/**
*Stellen Sie die Barriere ein.
*/
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);
}
/**
*Legen Sie die Karte offen aus.(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;
}
}
/**
*Kann angreifen(Frontseitenanzeige)Geben Sie die Karte in einer Liste zurück.
*/
public List<Card> lookAttackable(){
List<Card> attackable = new ArrayList<>();
for (Card tmp: front){
if(tmp.canAttack()) attackable.add(tmp);
}
return attackable;
}
/**
*Vorgesehen(Frontseitenanzeige)Mach die Karte angreifbar.
* @param index Der Index der Karte, die Sie angreifen möchten.
*/
public void recovery(int index){
front.get(index).setCanAttack(true);
}
/**
*Alles(Frontseitenanzeige)Mach die Karte angreifbar.
*/
public void recoveryAll(){
for(Card tmp: front){
if(tmp != null) tmp.setCanAttack(true);
}
}
/**
*Laden Sie die angegebene Karte auf.
* @param index Der Index der Karte, die Sie aufladen möchten.
* @param isFront Gibt an, ob sich die Karte auf der Vorderseite befindet.
*/
public void charge (int index, boolean isFront){
if(isFront){
front.get(index).setCharge(true);
}else{
back.get(index).setCharge(true);
}
}
/**
*Laden Sie alle offenen Karten auf.
*/
public void chargeAllFront(){
for(Card tmp: front){
tmp.setCharge(true);
}
}
/**
*Laden Sie alle auf der Rückseite angezeigten Karten auf.
*/
public void chargeAllBack(){
for(Card tmp: back){
tmp.setCharge(true);
}
}
/**
*Laden Sie alle Karten auf.
*/
public void chargeAll(){
chargeAllFront();
chargeAllBack();
}
/**
*Fahren Sie die angegebene Karte.
* @param index Der Index der Karte, die Sie fahren möchten.
* @param isFront Gibt an, ob sich die Karte auf der Vorderseite befindet.
*/
public void drive (int index, boolean isFront){
if(isFront){
front.get(index).setCharge(false);
}else{
back.get(index).setCharge(false);
}
}
/**
*Fahren Sie alle offenen Karten.
*/
public void driveAllFront(){
for(Card tmp: front){
tmp.setCharge(false);
}
}
/**
*Fahren Sie alle Karten auf der Rückseite.
*/
public void driveAllBack(){
for(Card tmp: back){
tmp.setCharge(false);
}
}
/**
*Fahren Sie alle Karten.
*/
public void driveAll(){
driveAllFront();
driveAllBack();
}
/**
*Zerstöre die Karte.
* @param index Der Index der Karte, die Sie zerstören möchten.
* @param isFront Ob die Karte, die Sie zerstören möchten, offen liegt.
* @return Das Objekt der zerstörten Karte.
*/
public Card destruction (int index, boolean isFront){
return takeCard(index, isFront);
}
/**
*Drehen Sie die hintere Karte nach vorne.
* @param index Der Index der Karte, die Sie auf der Vorderseite haben möchten.
*/
public void open(int index){
Card tmp = takeCard(index, false);
tmp.setFront(true);
addCard(tmp, true);
}
/**
*Gibt an, ob sich die angegebene Karte im Laufwerksstatus befindet.
*/
public boolean isDrive(int barrierIndex) {
return !back.get(barrierIndex).isCharge();
}
/**
*Finden Sie heraus, ob der ausgewählte Soldat angreifen kann.
* @param index Reihenfolge der Soldaten, die Sie überprüfen möchten(In der offenen Karte)
*/
public boolean canAttack(int index) {
return front.get(index).canAttack();
}
/**
*Gibt eine Kopie des Objekts des ausgewählten Soldaten zurück.
* @param index Reihenfolge der Soldaten, die Sie überprüfen möchten(In der offenen Karte)
* @return Eine Kopie des Soldatenkartenobjekts
*/
public Card getSoldierData(int index) {
return front.get(index).clone();
}
/**
*Gibt die Nummer des ausgewählten Soldaten zurück.
* @param index Reihenfolge der Soldaten, die Sie überprüfen möchten(In die gleiche Richtung Karte)
* @Ist die param isFront-Karte eine Tabelle?
* @Kartennummer zurückgeben
*/
public int getNumber(int index, boolean isFront) {
List<Card> list = isFront ? front: back;
return list.get(index).getNumber();
}
}
Grundsätzlich wie ich im Kommentar geschrieben habe. Ich werde jedoch vorerst nur die Beschwörung erläutern. Die Beschwörungsmethode fügt wie setBarrier der gesamten Liste und der angezeigten Kartenliste Karten hinzu und richtet aus, ob sie vorne liegen oder nicht und ob sie aufgeladen werden. Außerdem setzen Ass (1) und Magier (Joker) canAttack auf true, da sie nicht krank werden.
Bis hierher für diese Zeit. Nächstes Mal möchte ich eine Player-Klasse erstellen.
Recommended Posts