diff --git a/src/main/java/controls/AbstractGameState.java b/src/main/java/controls/AbstractGameState.java
index cd6b9d5..1332c29 100644
--- a/src/main/java/controls/AbstractGameState.java
+++ b/src/main/java/controls/AbstractGameState.java
@@ -1,6 +1,7 @@
 package controls;
 
 import resources.Algo;
+import values.Card;
 
 import java.util.List;
 import java.util.Map;
@@ -20,15 +21,15 @@
     public abstract void attack();
 
 
-    public List<Map.Entry<Integer, Boolean>> getMyHands() {
+    public List<Card> getMyHands() {
         return algo.getHandsA();
     }
 
-    public List<Map.Entry<Integer, Boolean>> getOpponentHands() {
+    public List<Card> getOpponentHands() {
         return algo.getHandsB();
     }
 
-    public Map.Entry<Integer, Boolean> getTopCard() {
+    public Card getTopCard() {
         if (isDeckLess()) return null;
         return algo.getDeck().get(0);
     }
diff --git a/src/main/java/controls/BotIntelligence.java b/src/main/java/controls/BotIntelligence.java
index 9276c18..b016253 100644
--- a/src/main/java/controls/BotIntelligence.java
+++ b/src/main/java/controls/BotIntelligence.java
@@ -1,6 +1,7 @@
 package controls;
 
 import interfaces.IBotBehavior;
+import values.Card;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -25,8 +26,8 @@
         List<Integer> candidates = new ArrayList<Integer>();
         for (int i = 0; i < DECK_COUNT; i++) candidates.add(i);
 
-        candidates.removeAll(turnBot.getOpponentHands().stream().map(x -> x.getKey()).collect(Collectors.toList()));
-        candidates.removeAll(turnBot.getMyHands().stream().filter(x -> x.getValue()).map(x -> x.getKey()).collect(Collectors.toList()));
+        candidates.removeAll(turnBot.getOpponentHands().stream().map(x -> x.isFace()).collect(Collectors.toList()));
+        candidates.removeAll(turnBot.getMyHands().stream().filter(x -> x.isFace()).map(x -> x.getNumber()).collect(Collectors.toList()));
 
         return candidates;
     }
@@ -37,24 +38,24 @@
      * @return 候補のリスト
      */
     List<int[]> assignCandidateNumberEachHand() {
-        List<Map.Entry<Integer, Boolean>> myHands = turnBot.getMyHands();
+        List<Card> myHands = turnBot.getMyHands();
         List<int[]> result = new ArrayList<int[]>();
 
-        for (Map.Entry<Integer, Boolean> card : myHands) {//ユーザーの手札を左から見ていく
+        for (Card card : myHands) {//ユーザーの手札を左から見ていく
             int index = myHands.indexOf(card);//左からindex番目に
             List<Integer> candidateList = calculateCandidate();//確認するカード
 
 
-            if (card.getValue()) {
+            if (card.isFace()) {
                 candidateList.clear();
             } else {                  //裏の場合
 
                 //そのカードから右隣のカードを確認していく
                 for (int i = 0; i < myHands.size() - index - 1; i++) {
                     //今確認していっているカード
-                    Map.Entry<Integer, Boolean> currentCard = myHands.get(i + index + 1);
-                    if (currentCard.getValue()) {//確認しているカードが表なら、(YES)
-                        candidateList.removeIf(x -> x > currentCard.getKey());//その確認したカードの数字より大きい数字を除外する。
+                    Card currentCard = myHands.get(i + index + 1);
+                    if (currentCard.isFace()) {//確認しているカードが表なら、(YES)
+                        candidateList.removeIf(x -> x > currentCard.getNumber());//その確認したカードの数字より大きい数字を除外する。
                         for (int j = 1; j < i; j++) {//そして、その確認したカードよりjだけ小さいそのカードからj番目の数字を除外する。
                             candidateList.remove(candidateList.size() - 1);
                         }
@@ -65,15 +66,15 @@
                 //そのカードから左隣のカードを確認していく
                 for (int i = 1; i <= index; i++) {
                     //今確認していっているカード
-                    Map.Entry<Integer, Boolean> currentCard = myHands.get(index - i);
-                    if (currentCard.getValue()) {//表があれば、それより小さい数字を候補から削除する
-                        candidateList.removeIf(x -> x < currentCard.getKey());
+                    Card currentCard = myHands.get(index - i);
+                    if (currentCard.isFace()) {//表があれば、それより小さい数字を候補から削除する
+                        candidateList.removeIf(x -> x < currentCard.getNumber());
                     }
                 }
 
 
             }
-            String s = (card.getValue() ? "+" : "-") + card.getKey() + ":[";
+            String s = (card.isFace() ? "+" : "-") + card.getNumber() + ":[";
             for (int i : candidateList) s += i + " ";
             s += "]\n";
             System.out.println(s);
@@ -85,10 +86,10 @@
     //公開されていないカードのインデックスを選ぶ(カードにかかれている番号ではない)
     @Override
     public int selectAttacker() {
-        List<Map.Entry<Integer, Boolean>> botHands = turnBot.getOpponentHands();
+        List<Card> botHands = turnBot.getOpponentHands();
 
-        for (Map.Entry<Integer, Boolean> i : botHands) {//小さいものから選択
-            if (!i.getValue()) return botHands.indexOf(i);
+        for (Card i : botHands) {//小さいものから選択
+            if (!i.isFace()) return botHands.indexOf(i);
         }
         return 0;
     }
diff --git a/src/main/java/controls/ConstantMethods.java b/src/main/java/controls/ConstantMethods.java
index 323dba0..3d3ceab 100644
--- a/src/main/java/controls/ConstantMethods.java
+++ b/src/main/java/controls/ConstantMethods.java
@@ -1,6 +1,7 @@
 package controls;
 
 import resources.Algo;
+import values.Card;
 
 import java.util.Map;
 
@@ -8,16 +9,16 @@
     public static void printAlgoState(Algo algo) {
         String s = "";
         s += "deck:\n";
-        for (Map.Entry<Integer, Boolean> i : algo.getDeck()) {
-            s += "\t" + i.getKey() + "\t" + (i.getValue() ? "open" : "closed") + "\n";
+        for (Card i : algo.getDeck()) {
+            s += "\t" + i.getNumber() + "\t" + (i.isFace() ? "open" : "closed") + "\n";
         }
         s += "handsA:\n";
-        for (Map.Entry<Integer, Boolean> i : algo.getHandsA()) {
-            s += "\t" + i.getKey() + "\t" + (i.getValue() ? "open" : "closed") + "\n";
+        for (Card i : algo.getHandsA()) {
+            s += "\t" + i.getNumber() + "\t" + (i.isFace() ? "open" : "closed") + "\n";
         }
         s += "handsB:\n";
-        for (Map.Entry<Integer, Boolean> i : algo.getHandsB()) {
-            s += "\t" + i.getKey() + "\t" + (i.getValue() ? "open" : "closed") + "\n";
+        for (Card i : algo.getHandsB()) {
+            s += "\t" + i.getNumber() + "\t" + (i.isFace() ? "open" : "closed") + "\n";
         }
         s += "\n";
         if (algo.getLoseA()) s += "B win.\n";
diff --git a/src/main/java/controls/StepScheduler.java b/src/main/java/controls/StepScheduler.java
deleted file mode 100644
index 5302d65..0000000
--- a/src/main/java/controls/StepScheduler.java
+++ /dev/null
@@ -1,91 +0,0 @@
-package controls;
-
-import interfaces.IAttack;
-import resources.Algo;
-
-import java.util.List;
-import java.util.Map;
-
-public class StepScheduler implements IAttack {
-    Algo algo;
-    int turnCount = 0;
-    boolean isATurn;
-    boolean isSucceedLatestAttack;
-
-    public StepScheduler() {
-        algo = new Algo();
-        isATurn = true;
-    }
-
-    @Override
-    public void attack(int guess, int attacker, int target) {
-        if (isATurn) {
-            if (isDeckLess()) {
-                //algo.selectAndAttackA(attacker, target, guess);
-                isSucceedLatestAttack = algo.getResultBySelectingA().getKey();
-            } else {
-              //  algo.drawAndAttackA(target, guess);
-                isSucceedLatestAttack = algo.getResultByDrawingA().getKey();
-            }
-        } else {
-            if (isDeckLess()) {
-              //  algo.selectAndAttackB(attacker, target, guess);
-                isSucceedLatestAttack = algo.getResultBySelectingB().getKey();
-            } else {
-              //  algo.drawAndAttackB(target, guess);
-                isSucceedLatestAttack = algo.getResultByDrawingB().getKey();
-            }
-        }
-        turnCount++;
-
-    }
-
-    @Override
-    public List<Map.Entry<Integer, Boolean>> getMyHands() {
-        return algo.getHandsA();
-    }
-
-    @Override
-    public List<Map.Entry<Integer, Boolean>> getOpponentHands() {
-        return algo.getHandsB();
-    }
-
-    @Override
-    public Map.Entry<Integer, Boolean> getTopCard() {
-        if (isDeckLess()) return null;
-        return algo.getDeck().get(0);
-    }
-
-    public boolean isDeckLess() {
-        return algo.getDeck().size() == 0;
-    }
-
-    @Override
-    public int getDeckNumber() {
-        return algo.getDeck().size();
-    }
-
-    public boolean isSucceedLatestAttack() {
-        return isSucceedLatestAttack;
-    }
-
-    @Override
-    public boolean updateTurn() {
-        isATurn = isATurn ? false : true;
-        return isATurn;
-    }
-
-    public boolean isATurn() {
-        return isATurn;
-    }
-
-    @Override
-    public boolean isALose() {
-        return algo.getLoseA();
-    }
-
-    @Override
-    public boolean isBLose() {
-        return algo.getLoseB();
-    }
-}
diff --git a/src/main/java/resources/Algo.java b/src/main/java/resources/Algo.java
index 21d8459..72f8b0b 100644
--- a/src/main/java/resources/Algo.java
+++ b/src/main/java/resources/Algo.java
@@ -1,5 +1,7 @@
 package resources;
 
+import values.Card;
+
 import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
@@ -109,7 +111,7 @@
         return resultBySelectingB.getValue();
     }
 
-    public List<Map.Entry<Integer, Boolean>> getDeck() {
+    public List<Card> getDeck() {
         return deck.getValue();
     }
 
@@ -121,11 +123,11 @@
         return loseB.getValue();
     }
 
-    public List<Map.Entry<Integer, Boolean>> getHandsA() {
+    public List<Card> getHandsA() {
         return handsA.getValue();
     }
 
-    public List<Map.Entry<Integer, Boolean>> getHandsB() {
+    public List<Card> getHandsB() {
         return handsB.getValue();
     }
 
@@ -140,8 +142,8 @@
             handsA.getValue().add(deck.head());
             handsB.getValue().add(deck.head());
         }
-        getHandsA().sort(Comparator.comparing(Map.Entry<Integer, Boolean>::getKey));
-        getHandsB().sort(Comparator.comparing(Map.Entry<Integer, Boolean>::getKey));
+        getHandsA().sort(Comparator.comparing(Card::getNumber));
+        getHandsB().sort(Comparator.comparing(Card::getNumber));
     }
     public void setDeck(int... param){
         deck.setValue(param);
diff --git a/src/main/java/resources/Deck.java b/src/main/java/resources/Deck.java
index 0b443a0..31c3dad 100644
--- a/src/main/java/resources/Deck.java
+++ b/src/main/java/resources/Deck.java
@@ -1,16 +1,18 @@
 package resources;
 
+import values.Card;
+
 import java.util.*;
 
 public class Deck {
     private Map.Entry<Boolean, Integer> succeedDrawB;
     private Map.Entry<Boolean, Integer> succeedDrawA;
-    private List<Map.Entry<Integer, Boolean>> value = new ArrayList<>();
+    private List<Card> value = new ArrayList<>();
 
     //added
     public void init(int num) {
         for (int i = 0; i < num; i++) {
-            this.value.add(new AbstractMap.SimpleEntry<>(i, false));
+            this.value.add(new Card(i, false));
         }
         Collections.shuffle(this.value);
     }
@@ -18,26 +20,26 @@
     public void setValue(int... params){
         this.value.clear();
         for (int i = 0; i < params.length; i++){
-            this.value.add(new AbstractMap.SimpleEntry<>(i, false));
+            this.value.add(new Card(i, false));
         }
     }
     //added
-    public Map.Entry<Integer, Boolean> head() {
-        Map.Entry<Integer, Boolean> card = getValue().get(0);
+    public Card head() {
+        Card card = getValue().get(0);
         getValue().remove(getValue().get(0));
         return card;
     }
 
-    public List<Map.Entry<Integer, Boolean>> getValue() {
+    public List<Card> getValue() {
         return value;
     }
 
-    public void updateSucceedDrawB(Map.Entry<Boolean, Integer> succeedDrawB) {
+    public void updateResultByDrawingB(Map.Entry<Boolean, Integer> succeedDrawB) {
         this.succeedDrawB = succeedDrawB;
         value = this.value.subList(1, this.value.size());
     }
 
-    public void updateSucceedDrawA(Map.Entry<Boolean, Integer> succeedDrawA) {
+    public void updateResultByDrawingA(Map.Entry<Boolean, Integer> succeedDrawA) {
         this.succeedDrawA = succeedDrawA;
         value = this.value.subList(1, this.value.size());
     }
diff --git a/src/main/java/resources/HandsA.java b/src/main/java/resources/HandsA.java
index 006b4fe..e63d066 100644
--- a/src/main/java/resources/HandsA.java
+++ b/src/main/java/resources/HandsA.java
@@ -1,41 +1,43 @@
 package resources;
 
+import values.Card;
+
 import java.util.*;
 
 public class HandsA {
-    private Map.Entry<Boolean, Map.Entry<Integer, Integer>> succeedSelectA;
-    private Map.Entry<Boolean, Map.Entry<Integer, Integer>> succeedSelectB;
-    private Map.Entry<Boolean, Integer> succeedDrawB;
-    private Map.Entry<Boolean, Integer> succeedDrawA;
+    private Map.Entry<Boolean, Map.Entry<Integer, Integer>> resultBySelectingA;
+    private Map.Entry<Boolean, Map.Entry<Integer, Integer>> resultBySelectingB;
+    private Map.Entry<Boolean, Integer> resultByDrawingB;
+    private Map.Entry<Boolean, Integer> resultByDrawingA;
     private LoseA loseA;
-    private List<Map.Entry<Integer, Boolean>> value = new ArrayList<Map.Entry<Integer, Boolean>>();
+    private List<Card> value = new ArrayList<Card>();
 
     public HandsA(LoseA loseA) {
         this.loseA = loseA;
     }
 
-    public List<Map.Entry<Integer, Boolean>> getValue() {
+    public List<Card> getValue() {
         return value;
     }
 
-    public void updateSucceedSelectA(Map.Entry<Boolean, Map.Entry<Integer, Integer>> succeedSelectA) {
-        this.succeedSelectA = succeedSelectA;
-        List<Map.Entry<Integer, Boolean>> temp_if3;
-        if (succeedSelectA.getKey()) {
+    public void updateResultBySelectingA(Map.Entry<Boolean, Map.Entry<Integer, Integer>> resultBySelectingA) {
+        this.resultBySelectingA = resultBySelectingA;
+        List<Card> temp_if3;
+        if (resultBySelectingA.getKey()) {
             temp_if3 = this.value;
         } else {
-            this.value.set(succeedSelectA.getValue().getValue(), new AbstractMap.SimpleEntry<>(this.value.get(succeedSelectA.getValue().getValue()).getKey(), true));
+            this.value.set(resultBySelectingA.getValue().getValue(), new Card(this.value.get(resultBySelectingA.getValue().getValue()).getNumber(), true));
             temp_if3 = this.value;
         }
         value = temp_if3;
         this.loseA.updateHandsA(value);
     }
 
-    public void updateSucceedSelectB(Map.Entry<Boolean, Map.Entry<Integer, Integer>> succeedSelectB) {
-        this.succeedSelectB = succeedSelectB;
-        List<Map.Entry<Integer, Boolean>> temp_if4;
-        if (succeedSelectB.getKey()) {
-            this.value.set(succeedSelectB.getValue().getKey(), new AbstractMap.SimpleEntry<>(this.value.get(succeedSelectB.getValue().getKey()).getKey(), true));
+    public void updateResultBySelectingB(Map.Entry<Boolean, Map.Entry<Integer, Integer>> resultBySelectingB) {
+        this.resultBySelectingB = resultBySelectingB;
+        List<Card> temp_if4;
+        if (resultBySelectingB.getKey()) {
+            this.value.set(resultBySelectingB.getValue().getKey(), new Card(this.value.get(resultBySelectingB.getValue().getKey()).getNumber(), true));
             temp_if4 = this.value;
         } else {
             temp_if4 = this.value;
@@ -44,11 +46,11 @@
         this.loseA.updateHandsA(value);
     }
 
-    public void updateSucceedDrawB(Map.Entry<Boolean, Integer> succeedDrawB, List<Map.Entry<Integer, Boolean>> deck) {
-        this.succeedDrawB = succeedDrawB;
-        List<Map.Entry<Integer, Boolean>> temp_if6;
-        if (succeedDrawB.getKey()) {
-            this.value.set(succeedDrawB.getValue(), new AbstractMap.SimpleEntry<>(this.value.get(succeedDrawB.getValue()).getKey(), true));
+    public void updateResultByDrawingB(Map.Entry<Boolean, Integer> resultByDrawingB, List<Card> deck) {
+        this.resultByDrawingB = resultByDrawingB;
+        List<Card> temp_if6;
+        if (resultByDrawingB.getKey()) {
+            this.value.set(resultByDrawingB.getValue(), new Card(this.value.get(resultByDrawingB.getValue()).getNumber(), true));
             temp_if6 = this.value;
         } else {
             temp_if6 = this.value;
@@ -57,16 +59,16 @@
         this.loseA.updateHandsA(value);
     }
 
-    public void updateSucceedDrawA(Map.Entry<Boolean, Integer> succeedDrawA, List<Map.Entry<Integer, Boolean>> deck) {
-        this.succeedDrawA = succeedDrawA;
-        List<Map.Entry<Integer, Boolean>> temp_if7;
-        if (succeedDrawA.getKey()) {
-            this.value.add(0, new AbstractMap.SimpleEntry<>(deck.get(0).getKey(), false));
-            this.value.sort(Comparator.comparing(Map.Entry<Integer, Boolean>::getKey));
+    public void updateResultByDrawingA(Map.Entry<Boolean, Integer> resultByDrawingA, List<Card> deck) {
+        this.resultByDrawingA = resultByDrawingA;
+        List<Card> temp_if7;
+        if (resultByDrawingA.getKey()) {
+            this.value.add(0, new Card(deck.get(0).getNumber(), false));
+            this.value.sort(Comparator.comparing(Card::getNumber));
             temp_if7 = this.value;
         } else {
-            this.value.add(0, new AbstractMap.SimpleEntry<>(deck.get(0).getKey(), true));
-            this.value.sort(Comparator.comparing(Map.Entry<Integer, Boolean>::getKey));
+            this.value.add(0, new Card(deck.get(0).getNumber(), true));
+            this.value.sort(Comparator.comparing(Card::getNumber));
             temp_if7 = this.value;
         }
         value = temp_if7;
diff --git a/src/main/java/resources/HandsB.java b/src/main/java/resources/HandsB.java
index 957dceb..ca4a021 100644
--- a/src/main/java/resources/HandsB.java
+++ b/src/main/java/resources/HandsB.java
@@ -1,5 +1,7 @@
 package resources;
 
+import values.Card;
+
 import java.util.*;
 
 public class HandsB {
@@ -8,37 +10,37 @@
     private Map.Entry<Boolean, Integer> succeedDrawA;
     private Map.Entry<Boolean, Map.Entry<Integer, Integer>> succeedSelectB;
     private LoseB loseB;
-    private List<Map.Entry<Integer, Boolean>> value = new ArrayList<Map.Entry<Integer, Boolean>>();
+    private List<Card> value = new ArrayList<Card>();
 
     public HandsB(LoseB loseB) {
         this.loseB = loseB;
     }
 
-    public List<Map.Entry<Integer, Boolean>> getValue() {
+    public List<Card> getValue() {
         return value;
     }
 
-    public void updateSucceedDrawB(Map.Entry<Boolean, Integer> succeedDrawB, List<Map.Entry<Integer, Boolean>> deck) {
+    public void updateResultByDrawingB(Map.Entry<Boolean, Integer> succeedDrawB, List<Card> deck) {
         this.succeedDrawB = succeedDrawB;
-        List<Map.Entry<Integer, Boolean>> temp_if0;
+        List<Card> temp_if0;
         if (succeedDrawB.getKey()) {
-            this.value.add(0, new AbstractMap.SimpleEntry<>(deck.get(0).getKey(), false));
-            this.value.sort(Comparator.comparing(Map.Entry<Integer, Boolean>::getKey));
+            this.value.add(0, new Card(deck.get(0).getNumber(), false));
+            this.value.sort(Comparator.comparing(Card::getNumber));
             temp_if0 = this.value;
         } else {
-            this.value.add(0, new AbstractMap.SimpleEntry<>(deck.get(0).getKey(), true));
-            this.value.sort(Comparator.comparing(Map.Entry<Integer, Boolean>::getKey));
+            this.value.add(0, new Card(deck.get(0).getNumber(), true));
+            this.value.sort(Comparator.comparing(Card::getNumber));
             temp_if0 = this.value;
         }
         value = temp_if0;
         this.loseB.updateHandsB(value);
     }
 
-    public void updateSucceedSelectA(Map.Entry<Boolean, Map.Entry<Integer, Integer>> succeedSelectA) {
+    public void updateResultBySelectingA(Map.Entry<Boolean, Map.Entry<Integer, Integer>> succeedSelectA) {
         this.succeedSelectA = succeedSelectA;
-        List<Map.Entry<Integer, Boolean>> temp_if1;
+        List<Card> temp_if1;
         if (succeedSelectA.getKey()) {
-            this.value.set(succeedSelectA.getValue().getKey(), new AbstractMap.SimpleEntry<>(this.value.get(succeedSelectA.getValue().getKey()).getKey(), true));
+            this.value.set(succeedSelectA.getValue().getKey(), new Card(this.value.get(succeedSelectA.getValue().getKey()).getNumber(), true));
             temp_if1 = this.value;
         } else {
             temp_if1 = this.value;
@@ -47,11 +49,11 @@
         this.loseB.updateHandsB(value);
     }
 
-    public void updateSucceedDrawA(Map.Entry<Boolean, Integer> succeedDrawA, List deck) {
+    public void updateResultByDrawingA(Map.Entry<Boolean, Integer> succeedDrawA, List deck) {
         this.succeedDrawA = succeedDrawA;
-        List<Map.Entry<Integer, Boolean>> temp_if2;
+        List<Card> temp_if2;
         if (succeedDrawA.getKey()) {
-            this.value.set(succeedDrawA.getValue(), new AbstractMap.SimpleEntry<>(this.value.get(succeedDrawA.getValue()).getKey(), true));
+            this.value.set(succeedDrawA.getValue(), new Card(this.value.get(succeedDrawA.getValue()).getNumber(), true));
             temp_if2 = this.value;
         } else {
             temp_if2 = this.value;
@@ -60,13 +62,13 @@
         this.loseB.updateHandsB(value);
     }
 
-    public void updateSucceedSelectB(Map.Entry<Boolean, Map.Entry<Integer, Integer>> succeedSelectB) {
+    public void updateResultBySelectingB(Map.Entry<Boolean, Map.Entry<Integer, Integer>> succeedSelectB) {
         this.succeedSelectB = succeedSelectB;
-        List<Map.Entry<Integer, Boolean>> temp_if5;
+        List<Card> temp_if5;
         if (succeedSelectB.getKey()) {
             temp_if5 = this.value;
         } else {
-            this.value.set(succeedSelectB.getValue().getValue(), new AbstractMap.SimpleEntry<>(this.value.get(succeedSelectB.getValue().getValue()).getKey(), true));
+            this.value.set(succeedSelectB.getValue().getValue(), new Card(this.value.get(succeedSelectB.getValue().getValue()).getNumber(), true));
             temp_if5 = this.value;
         }
         value = temp_if5;
diff --git a/src/main/java/resources/LoseA.java b/src/main/java/resources/LoseA.java
index 79a95ba..2e76bea 100644
--- a/src/main/java/resources/LoseA.java
+++ b/src/main/java/resources/LoseA.java
@@ -1,5 +1,7 @@
 package resources;
 
+import values.Card;
+
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
@@ -7,8 +9,15 @@
 public class LoseA {
     private boolean value;
 
-    public void updateHandsA(List<Map.Entry<Integer, Boolean>> handsA) {
-        value = (handsA.stream().filter(item -> item.getValue() == false).collect(Collectors.toList()).size() == 0);
+    public void updateHandsA(List<Card> handsA) {
+        boolean result = true;
+        for (Card card : handsA) {
+            if (!card.isFace()) {
+                result = false;
+                break;
+            }
+        }
+        value = result;
     }
 
     public boolean getValue() {
diff --git a/src/main/java/resources/LoseB.java b/src/main/java/resources/LoseB.java
index 7757b0a..065fb7f 100644
--- a/src/main/java/resources/LoseB.java
+++ b/src/main/java/resources/LoseB.java
@@ -1,5 +1,7 @@
 package resources;
 
+import values.Card;
+
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
@@ -7,8 +9,15 @@
 public class LoseB {
     private boolean value;
 
-    public void updateHandsB(List<Map.Entry<Integer, Boolean>> handsB) {
-        value = (handsB.stream().filter(item -> item.getValue() == false).collect(Collectors.toList()).size() == 0);
+    public void updateHandsB(List<Card> handsB) {
+        boolean result = true;
+        for (Card card : handsB) {
+            if (!card.isFace()) {
+                result = false;
+                break;
+            }
+        }
+        value = result;
     }
 
     public boolean getValue() {
diff --git a/src/main/java/resources/ResultByDrawingA.java b/src/main/java/resources/ResultByDrawingA.java
index b4d0421..f764fb5 100644
--- a/src/main/java/resources/ResultByDrawingA.java
+++ b/src/main/java/resources/ResultByDrawingA.java
@@ -22,11 +22,11 @@
     }
 
     public void drawAndAttackA() {
-        this.value = new AbstractMap.SimpleEntry<>((handsB.getValue().get(targetA.getValue()).getKey() == guessA.getValue()), targetA.getValue());
+        this.value = new AbstractMap.SimpleEntry<>((handsB.getValue().get(targetA.getValue()).getNumber() == guessA.getValue()), targetA.getValue());
         List deck = this.deck.getValue();
-        this.handsA.updateSucceedDrawA(value, deck);
-        this.handsB.updateSucceedDrawA(value, deck);
-        this.deck.updateSucceedDrawA(value);
+        this.handsA.updateResultByDrawingA(value, deck);
+        this.handsB.updateResultByDrawingA(value, deck);
+        this.deck.updateResultByDrawingA(value);
     }
 
     public Map.Entry<Boolean, Integer> getValue() {
diff --git a/src/main/java/resources/ResultByDrawingB.java b/src/main/java/resources/ResultByDrawingB.java
index 416d363..1776d67 100644
--- a/src/main/java/resources/ResultByDrawingB.java
+++ b/src/main/java/resources/ResultByDrawingB.java
@@ -21,12 +21,12 @@
     }
 
     public void drawAndAttackB() {
-        this.value = new AbstractMap.SimpleEntry<>((handsA.getValue().get(targetB.getValue()).getKey() == guessB.getValue()), targetB.getValue());
+        this.value = new AbstractMap.SimpleEntry<>((handsA.getValue().get(targetB.getValue()).getNumber() == guessB.getValue()), targetB.getValue());
 
         List deck = this.deck.getValue();
-        this.handsB.updateSucceedDrawB(value, deck);
-        this.handsA.updateSucceedDrawB(value, deck);
-        this.deck.updateSucceedDrawB(value);
+        this.handsB.updateResultByDrawingB(value, deck);
+        this.handsA.updateResultByDrawingB(value, deck);
+        this.deck.updateResultByDrawingB(value);
     }
 
     public Map.Entry<Boolean, Integer> getValue() {
diff --git a/src/main/java/resources/ResultBySelectingA.java b/src/main/java/resources/ResultBySelectingA.java
index c30c120..fa1559a 100644
--- a/src/main/java/resources/ResultBySelectingA.java
+++ b/src/main/java/resources/ResultBySelectingA.java
@@ -22,9 +22,9 @@
     }
 
     public void selectAndAttackA() {
-        this.value = new AbstractMap.SimpleEntry<>((handsB.getValue().get(targetA.getValue()).getKey() == guessA.getValue()), new AbstractMap.SimpleEntry<>(targetA.getValue(), attackerA.getValue()));
-        this.handsA.updateSucceedSelectA(value);
-        this.handsB.updateSucceedSelectA(value);
+        this.value = new AbstractMap.SimpleEntry<>((handsB.getValue().get(targetA.getValue()).getNumber() == guessA.getValue()), new AbstractMap.SimpleEntry<>(targetA.getValue(), attackerA.getValue()));
+        this.handsA.updateResultBySelectingA(value);
+        this.handsB.updateResultBySelectingA(value);
     }
 
     public Map.Entry<Boolean, Map.Entry<Integer, Integer>> getValue() {
diff --git a/src/main/java/resources/ResultBySelectingB.java b/src/main/java/resources/ResultBySelectingB.java
index 4aec0f0..378839c 100644
--- a/src/main/java/resources/ResultBySelectingB.java
+++ b/src/main/java/resources/ResultBySelectingB.java
@@ -20,9 +20,9 @@
     }
 
     public void selectAndAttackB() {
-        this.value = new AbstractMap.SimpleEntry<>((handsA.getValue().get(targetB.getValue()).getKey() == guessB.getValue()), new AbstractMap.SimpleEntry<>(targetB.getValue(), attackerB.getValue()));
-        this.handsB.updateSucceedSelectB(value);
-        this.handsA.updateSucceedSelectB(value);
+        this.value = new AbstractMap.SimpleEntry<>((handsA.getValue().get(targetB.getValue()).getNumber() == guessB.getValue()), new AbstractMap.SimpleEntry<>(targetB.getValue(), attackerB.getValue()));
+        this.handsB.updateResultBySelectingB(value);
+        this.handsA.updateResultBySelectingB(value);
     }
 
     public Map.Entry<Boolean, Map.Entry<Integer, Integer>> getValue() {
diff --git a/src/main/java/values/Card.java b/src/main/java/values/Card.java
new file mode 100644
index 0000000..b8f2f71
--- /dev/null
+++ b/src/main/java/values/Card.java
@@ -0,0 +1,32 @@
+package values;
+
+public class Card {
+    private int number;
+    private boolean face;
+
+    public Card(int number, boolean face) {
+        this.number = number;
+        this.face = face;
+    }
+
+    public Card(Card other){
+        this.number = other.number;
+        this.face = other.face;
+    }
+
+    public int getNumber() {
+        return number;
+    }
+
+    public void setNumber(int number) {
+        this.number = number;
+    }
+
+    public boolean isFace() {
+        return face;
+    }
+
+    public void setFace(boolean face) {
+        this.face = face;
+    }
+}
diff --git a/src/main/java/views/MainPanel.java b/src/main/java/views/MainPanel.java
index c123729..ffaf092 100644
--- a/src/main/java/views/MainPanel.java
+++ b/src/main/java/views/MainPanel.java
@@ -6,6 +6,7 @@
 import controls.TurnBot;
 import interfaces.IGameView;
 import resources.Algo;
+import values.Card;
 
 import javax.swing.*;
 import java.awt.*;
@@ -158,10 +159,10 @@
     }
 
     void paintDrawCard(AbstractGameState abstractGameState) {
-        Map.Entry<Integer, Boolean> deckTopCard = abstractGameState.getTopCard();
+        Card deckTopCard = abstractGameState.getTopCard();
 
         if (!abstractGameState.isDeckLess()) {    //デッキが存在する場合にデッキトップのカードを表示する処理
-            CardButton cardButton = new CardButton(deckTopCard.getKey().toString());
+            CardButton cardButton = new CardButton(((Integer)deckTopCard.getNumber()).toString());
             cardButton.setBounds(0, 100, CARD_WIDTH, CARD_HEIGHT);
             if (abstractGameState.isATurn()) {
                 myHandAttackerPanel.add(cardButton);
@@ -184,12 +185,12 @@
     public void onStartPlayerTurn(AbstractGameState abstractGameState) {
         JOptionPane.showMessageDialog(null, "あなたのターンです。");
         String selectText = !abstractGameState.isDeckLess()
-                ? "あなたは数字\"" + abstractGameState.getTopCard().getKey() + "\"のカードをドローしました。"
+                ? "あなたは数字\"" + abstractGameState.getTopCard().getNumber() + "\"のカードをドローしました。"
                 : "アタックに使用するカードを手札から選んでください。";
 
         paintDrawCard(abstractGameState);
         if (!abstractGameState.isDeckLess()) {
-            selectText = "あなたは数字\"" + abstractGameState.getTopCard().getKey() + "\"のカードをドローしました。";
+            selectText = "あなたは数字\"" + abstractGameState.getTopCard().getNumber() + "\"のカードをドローしました。";
             phaseController.setSelection(0);
         } else {
             selectText = "アタックに使用するカードを手札から選んでください。";
@@ -271,8 +272,8 @@
 
     @Override
     public void repaintBoard(AbstractGameState abstractGameState) {
-        List<Map.Entry<Integer, Boolean>> myHands = abstractGameState.getMyHands();
-        List<Map.Entry<Integer, Boolean>> opponentHands = abstractGameState.getOpponentHands();
+        List<Card> myHands = abstractGameState.getMyHands();
+        List<Card> opponentHands = abstractGameState.getOpponentHands();
 
         /**
          * 初期化処理(する必要があるのかどうかは知らない)
@@ -290,9 +291,9 @@
             cardButton.setPreferredSize(new Dimension(CARD_HEIGHT, CARD_WIDTH));
             deckButtonPanel.add(cardButton);
         }
-        for (Map.Entry<Integer, Boolean> i : myHands) {
-            CardButton cardButton = new CardButton(i.getKey().toString());
-            cardButton.setStatus(i.getValue() ? CardButton.Status.OPEN : CardButton.Status.MY_CLOSED);
+        for (Card i : myHands) {
+            CardButton cardButton = new CardButton(((Integer)i.getNumber()).toString());
+            cardButton.setStatus(i.isFace() ? CardButton.Status.OPEN : CardButton.Status.MY_CLOSED);
             myHandButtons.add(cardButton);
             myHandButtonsPanel.add(cardButton);
         }
@@ -301,10 +302,10 @@
         /**
          *相手のカードに関する処理
          */
-        for (Map.Entry<Integer, Boolean> i : opponentHands) {
-            CardButton cardButton = new CardButton(i.getValue() ? i.getKey().toString() : CLOSED_SYMBOL);
-            cardButton.setStatus(i.getValue() ? CardButton.Status.OPEN : CardButton.Status.CLOSED);
-            cardButton.setEnabled(!i.getValue());
+        for (Card i : opponentHands) {
+            CardButton cardButton = new CardButton(i.isFace() ? ((Integer)i.getNumber()).toString() : CLOSED_SYMBOL);
+            cardButton.setStatus(i.isFace() ? CardButton.Status.OPEN : CardButton.Status.CLOSED);
+            cardButton.setEnabled(!i.isFace());
             opponentHandButtons.add(cardButton);
             opponentButtonsPanel.add(cardButton, 0);//見た目の順序が逆になるように,0番目に挿入
         }
diff --git a/src/test/java/AlgoTest.java b/src/test/java/AlgoTest.java
index 80b81f8..8872e49 100644
--- a/src/test/java/AlgoTest.java
+++ b/src/test/java/AlgoTest.java
@@ -38,7 +38,7 @@
         var iniHandsANum = algo.getHandsA().size();
         var initDeckNum=algo.getDeck().size();
         //正解のカードを選択させるための変数
-        var guess = algo.getHandsB().get(0).getKey();
+        var guess = algo.getHandsB().get(0).getNumber();
         var target = 0;
         //テスト対象メソッド
         //algo.drawA(guess, target);
@@ -50,7 +50,7 @@
         //Aはデッキから引いているので,実行前と比べて枚数が1枚増えているか
         assertEquals(iniHandsANum+1,algo.getHandsA().size());
         //Aによってアタックを成功されたBのカードが表になっているか
-        assertEquals(true, algo.getHandsB().get(0).getValue());
+        assertEquals(true, algo.getHandsB().get(0).isFace());
         //Aがデッキから引いているので,デッキの枚数が1枚減っているか
         assertEquals(initDeckNum-1,algo.getDeck().size());
 
@@ -67,7 +67,7 @@
         var iniHandsANum = algo.getHandsA().size();
         var initDeckNum=algo.getDeck().size();
         //正解でないカードを選択させるための変数
-        var guess = algo.getHandsB().get(0).getKey()+1;
+        var guess = algo.getHandsB().get(0).getNumber()+1;
         var target = 0;
         var top = algo.getDeck().get(0);
         //テスト対象メソッド
@@ -80,9 +80,9 @@
 
         assertEquals(iniHandsANum+1,algo.getHandsA().size());
         //アタックの失敗でBのカードが表になっていない
-        assertEquals(false, algo.getHandsB().get(0).getValue());
+        assertEquals(false, algo.getHandsB().get(0).isFace());
         //アタックが失敗したので,使用したカードが表になっている
-        assertTrue(algo.getHandsA().contains(new AbstractMap.SimpleEntry<>(top.getKey(),true)));
+        assertTrue(algo.getHandsA().contains(new AbstractMap.SimpleEntry<>(top.getNumber(),true)));
         //Aがデッキから引いているので,デッキの枚数が1枚減っている
         assertEquals(initDeckNum-1,algo.getDeck().size());
 
@@ -99,7 +99,7 @@
         var iniHandsBNum = algo.getHandsB().size();
         var initDeckNum=algo.getDeck().size();
         //正解のカードを選択させるための変数
-        var guess = algo.getHandsA().get(0).getKey();
+        var guess = algo.getHandsA().get(0).getNumber();
         var target = 0;
         //テスト対象メソッド
      //   algo.drawB(guess, target);
@@ -110,7 +110,7 @@
         //Aはデッキから引いているので,実行前と比べて枚数が1枚増えているか
         assertEquals(iniHandsBNum+1,algo.getHandsB().size());
         //Aによってアタックを成功されたBのカードが表になっているか
-        assertEquals(true, algo.getHandsA().get(0).getValue());
+        assertEquals(true, algo.getHandsA().get(0).isFace());
         //Aがデッキから引いているので,デッキの枚数が1枚減っているか
         assertEquals(initDeckNum-1,algo.getDeck().size());
     }
@@ -124,7 +124,7 @@
         Algo algo = new Algo();
         algo.distributeHands();
         //正解のカードを選択させるための変数
-        var guess = algo.getHandsB().get(0).getKey();
+        var guess = algo.getHandsB().get(0).getNumber();
         var target = 0;
         var attacker = 0;
 
@@ -136,9 +136,9 @@
         algo.selectAndAttackA();
         printAlgoState(algo);
         //Aによってアタックを成功されたBのカードが表になっているか
-        assertEquals(true, algo.getHandsB().get(target).getValue());
+        assertEquals(true, algo.getHandsB().get(target).isFace());
         //Aのアタックを成功しているので,使用したカードが表になっていないか
-        assertEquals(false, algo.getHandsA().get(attacker).getValue());
+        assertEquals(false, algo.getHandsA().get(attacker).isFace());
     }
 
     /**
@@ -152,7 +152,7 @@
         //間違いのカードを選択させるための変数
         var target = 0;
         var attacker = 0;
-        var guess = algo.getHandsB().get(target).getKey()+1;
+        var guess = algo.getHandsB().get(target).getNumber()+1;
         //テスト対象メソッド
        // algo.selectA(guess, attacker, target);
         algo.setAttackerA(attacker);
@@ -161,9 +161,9 @@
         algo.selectAndAttackA();
         printAlgoState(algo);
         //Aによってアタックを成功されたBのカードが表になっていないか
-        assertEquals(false, algo.getHandsB().get(target).getValue());
+        assertEquals(false, algo.getHandsB().get(target).isFace());
         //Aのアタックが失敗しているので,使用したカードが表になっているか
-        assertEquals(true, algo.getHandsA().get(attacker).getValue());
+        assertEquals(true, algo.getHandsA().get(attacker).isFace());
     }
 
     @Test
@@ -180,7 +180,7 @@
     void playA() {
         Algo algo = new Algo();
         algo.distributeHands();
-        var guess = algo.getHandsB().get(0).getKey();
+        var guess = algo.getHandsB().get(0).getNumber();
         var target = 0;
         var attacker = 0;
 
@@ -200,9 +200,9 @@
 
         int tar=0, gue=0;
         for(int i=0;i<algo.getHandsB().size();i++){
-            if(algo.getHandsB().get(i).getValue()==false){
+            if(algo.getHandsB().get(i).isFace()==false){
                 tar=i;
-                gue=algo.getHandsB().get(i).getKey();
+                gue=algo.getHandsB().get(i).getNumber();
                 break;
             }
         }
@@ -219,12 +219,12 @@
         String s="--------------\n";
         s+="\thandsB:\t";
         for(var b : algo.getHandsB()){
-            s+=(b.getValue()?"["+b.getKey()+"+]":"[ -]");
+            s+=(b.isFace()?"["+b.getNumber()+"+]":"[ -]");
         }
         s+="\ndeck: "+algo.getDeck().size()+"\n";
         s+="\thandsA:\t";
         for(var a : algo.getHandsA()){
-            s+="["+a.getKey()+(a.getValue()?"+":"-")+"]";
+            s+="["+a.getNumber()+(a.isFace()?"+":"-")+"]";
         }
         s+="\n\n";
         if(algo.getLoseA())s+="B win.\n";
@@ -235,12 +235,12 @@
         String s="";
         s+="\thandsA:\t";
         for(var a : algo.getHandsA()){
-            s+=(a.getValue()?"["+a.getKey()+"+]":"[ -]");
+            s+=(a.isFace()?"["+a.getNumber()+"+]":"[ -]");
         }
         s+="\n\t\t\t\t\tdeck: "+algo.getDeck().size()+"\n";
         s+="\thandsB:\t";
         for(var b : algo.getHandsB()){
-            s+="["+b.getKey()+(b.getValue()?"+":"-")+"]";
+            s+="["+b.getNumber()+(b.isFace()?"+":"-")+"]";
         }
         System.out.println(s);
     }
diff --git a/src/test/java/controls/BotIntelligenceTest.java b/src/test/java/controls/BotIntelligenceTest.java
index 9b921b9..7793bd8 100644
--- a/src/test/java/controls/BotIntelligenceTest.java
+++ b/src/test/java/controls/BotIntelligenceTest.java
@@ -34,21 +34,21 @@
      */
     @Test
     void calc(){
-        StepScheduler stepScheduler=new StepScheduler();
 
-        var algo = stepScheduler.algo;
+
+        var algo = new Algo();
         BotIntelligence botIntelligence=new BotIntelligence(new TurnBot(algo));
         var iniHandsANum = algo.getHandsA().size();
         var initDeckNum=algo.getDeck().size();
         //正解のカードを選択させるための変数
-        var guess = algo.getHandsB().get(0).getKey();
+        var guess = algo.getHandsB().get(0).getNumber();
         var target = 1;
         //テスト対象メソッド
         algo.setTargetA(target);
         algo.setGuessA(guess);
         algo.drawAndAttackA();
 
-        stepScheduler.isATurn = false;
+
         printAlgoState(algo);
         botIntelligence.assignCandidateNumberEachHand();
     }