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();
}
}
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();
}
}
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.
Recommended Posts