diff --git a/src/main/java/controls/AbstractGameState.java b/src/main/java/controls/AbstractGameState.java
index fd0fac6..7a66e00 100644
--- a/src/main/java/controls/AbstractGameState.java
+++ b/src/main/java/controls/AbstractGameState.java
@@ -9,12 +9,14 @@
     Algo algo;
     static boolean isATurn;
     boolean isSucceedLatestAttack;
-    public AbstractGameState(Algo algo){
+
+    public AbstractGameState(Algo algo) {
         this.algo = algo;
-        isATurn=algo.isATurn();
+        isATurn = algo.isATurn();
     }
 
     public abstract void attack(int guess, int attacker, int target);
+
     public List<Map.Entry<Integer, Boolean>> getMyHands() {
         return algo.getHandsA();
     }
@@ -27,16 +29,20 @@
         if (isDeckLess()) return null;
         return algo.getDeck().get(0);
     }
+
     public void updateTurn() {
         algo.updateTurn();
-        isATurn= algo.isATurn();
+        isATurn = algo.isATurn();
     }
+
     public boolean isATurn() {
         return isATurn;
     }
+
     public boolean isDeckLess() {
         return algo.getDeck().size() == 0;
     }
+
     public boolean isSucceedLatestAttack() {
         return isSucceedLatestAttack;
     }
diff --git a/src/main/java/controls/BotIntelligence.java b/src/main/java/controls/BotIntelligence.java
index dd0d493..9276c18 100644
--- a/src/main/java/controls/BotIntelligence.java
+++ b/src/main/java/controls/BotIntelligence.java
@@ -1,15 +1,18 @@
 package controls;
 
-import interfaces.IAttack;
 import interfaces.IBotBehavior;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
 import java.util.stream.Collectors;
 
 import static views.Constants.DECK_COUNT;
 
 public class BotIntelligence implements IBotBehavior {
     TurnBot turnBot;
+
     public BotIntelligence(TurnBot turnBot) {
         this.turnBot = turnBot;
     }
@@ -19,7 +22,7 @@
      */
     List<Integer> calculateCandidate() {
         //候補の初期化
-        var candidates = new ArrayList<Integer>();
+        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()));
@@ -34,12 +37,12 @@
      * @return 候補のリスト
      */
     List<int[]> assignCandidateNumberEachHand() {
-        var myHands = turnBot.getMyHands();
-        var result = new ArrayList<int[]>();
+        List<Map.Entry<Integer, Boolean>> myHands = turnBot.getMyHands();
+        List<int[]> result = new ArrayList<int[]>();
 
-        for (var card : myHands) {//ユーザーの手札を左から見ていく
-            var index = myHands.indexOf(card);//左からindex番目に
-            var candidateList = calculateCandidate();//確認するカード
+        for (Map.Entry<Integer, Boolean> card : myHands) {//ユーザーの手札を左から見ていく
+            int index = myHands.indexOf(card);//左からindex番目に
+            List<Integer> candidateList = calculateCandidate();//確認するカード
 
 
             if (card.getValue()) {
@@ -49,7 +52,7 @@
                 //そのカードから右隣のカードを確認していく
                 for (int i = 0; i < myHands.size() - index - 1; i++) {
                     //今確認していっているカード
-                    var currentCard = myHands.get(i + index + 1);
+                    Map.Entry<Integer, Boolean> currentCard = myHands.get(i + index + 1);
                     if (currentCard.getValue()) {//確認しているカードが表なら、(YES)
                         candidateList.removeIf(x -> x > currentCard.getKey());//その確認したカードの数字より大きい数字を除外する。
                         for (int j = 1; j < i; j++) {//そして、その確認したカードよりjだけ小さいそのカードからj番目の数字を除外する。
@@ -62,7 +65,7 @@
                 //そのカードから左隣のカードを確認していく
                 for (int i = 1; i <= index; i++) {
                     //今確認していっているカード
-                    var currentCard = myHands.get(index - i);
+                    Map.Entry<Integer, Boolean> currentCard = myHands.get(index - i);
                     if (currentCard.getValue()) {//表があれば、それより小さい数字を候補から削除する
                         candidateList.removeIf(x -> x < currentCard.getKey());
                     }
@@ -70,8 +73,8 @@
 
 
             }
-            var s = (card.getValue() ? "+" : "-") + card.getKey() + ":[";
-            for (var i : candidateList) s += i + " ";
+            String s = (card.getValue() ? "+" : "-") + card.getKey() + ":[";
+            for (int i : candidateList) s += i + " ";
             s += "]\n";
             System.out.println(s);
             result.add(candidateList.stream().mapToInt(x -> x).toArray());
@@ -82,9 +85,9 @@
     //公開されていないカードのインデックスを選ぶ(カードにかかれている番号ではない)
     @Override
     public int selectAttacker() {
-        var botHands = turnBot.getOpponentHands();
+        List<Map.Entry<Integer, Boolean>> botHands = turnBot.getOpponentHands();
 
-        for (var i : botHands) {//小さいものから選択
+        for (Map.Entry<Integer, Boolean> i : botHands) {//小さいものから選択
             if (!i.getValue()) return botHands.indexOf(i);
         }
         return 0;
@@ -92,10 +95,10 @@
 
     @Override
     public int selectTarget() {
-        var candidate = assignCandidateNumberEachHand();
+        List<int[]> candidate = assignCandidateNumberEachHand();
         int result = 0;
         int min = DECK_COUNT;
-        for (var i : candidate) {
+        for (int[] i : candidate) {
             if (i.length < min && i.length != 0) {
                 result = candidate.indexOf(i);
                 min = i.length;
@@ -106,7 +109,7 @@
 
     @Override
     public int declareNumber(int target) {
-        var array = assignCandidateNumberEachHand().get(target);
+        int[] array = assignCandidateNumberEachHand().get(target);
         return array[new Random().nextInt(array.length)];
     }
 
diff --git a/src/main/java/controls/ConstantMethods.java b/src/main/java/controls/ConstantMethods.java
index 8dacc13..323dba0 100644
--- a/src/main/java/controls/ConstantMethods.java
+++ b/src/main/java/controls/ConstantMethods.java
@@ -2,19 +2,21 @@
 
 import resources.Algo;
 
+import java.util.Map;
+
 public class ConstantMethods {
     public static void printAlgoState(Algo algo) {
         String s = "";
         s += "deck:\n";
-        for (var i : algo.getDeck()) {
+        for (Map.Entry<Integer, Boolean> i : algo.getDeck()) {
             s += "\t" + i.getKey() + "\t" + (i.getValue() ? "open" : "closed") + "\n";
         }
         s += "handsA:\n";
-        for (var i : algo.getHandsA()) {
+        for (Map.Entry<Integer, Boolean> i : algo.getHandsA()) {
             s += "\t" + i.getKey() + "\t" + (i.getValue() ? "open" : "closed") + "\n";
         }
         s += "handsB:\n";
-        for (var i : algo.getHandsB()) {
+        for (Map.Entry<Integer, Boolean> i : algo.getHandsB()) {
             s += "\t" + i.getKey() + "\t" + (i.getValue() ? "open" : "closed") + "\n";
         }
         s += "\n";
diff --git a/src/main/java/controls/PhaseController.java b/src/main/java/controls/PhaseController.java
index 8a1cabb..e40c0e1 100644
--- a/src/main/java/controls/PhaseController.java
+++ b/src/main/java/controls/PhaseController.java
@@ -14,40 +14,43 @@
     public AbstractGameState abstractGameState;
     TurnPlayer turnPlayer;
     TurnBot turnBot;
-    public PhaseController(Algo algo){
+
+    public PhaseController(Algo algo, IGameView iGameView) {
         this.algo = algo;
         isDecidedAttacker = false;
         turnPlayer = new TurnPlayer(algo);
         turnBot = new TurnBot(algo);
         abstractGameState = turnPlayer;
-        currentPhase=Phase.Selection;
-    }
-    public void bindGameView(IGameView iGameView){
+        currentPhase = Phase.Selection;
         this.iGameView = iGameView;
     }
-    public void startGame(){
+
+    public void startGame() {
         changePhase(Phase.StartPlayerTurn);
     }
-    public void setSelection(int attacker){
+
+    public void setSelection(int attacker) {
         changePhase(Phase.Selection, attacker);
     }
-    public void setTarget(int target){
+
+    public void setTarget(int target) {
         changePhase(Phase.Target, target);
 
     }
-    public boolean isDecidedAttacker(){
+
+    public boolean isDecidedAttacker() {
         return isDecidedAttacker;
     }
+
     /**
-     *
-     * @param phase 遷移先の状態
+     * @param phase  遷移先の状態
      * @param params 遷移先に遷移するために必要な引数
      */
     private void changePhase(Phase phase, int... params) {
 
-        switch (phase){
+        switch (phase) {
             case StartPlayerTurn:
-                abstractGameState=turnPlayer;
+                abstractGameState = turnPlayer;
                 isDecidedAttacker = !abstractGameState.isDeckLess();
                 iGameView.repaintBoard(abstractGameState);
                 iGameView.onStartPlayerTurn(abstractGameState);
@@ -69,12 +72,12 @@
                 break;
             case Declaration:
                 this.guess = params[0];
-                abstractGameState.attack(this.guess,this.attacker,this.target);
+                abstractGameState.attack(this.guess, this.attacker, this.target);
                 currentPhase = Phase.StartBotTurn;
-                var isSucceed = abstractGameState.isSucceedLatestAttack();
+                boolean isSucceed = abstractGameState.isSucceedLatestAttack();
                 iGameView.repaintBoard(abstractGameState);
                 iGameView.onFinishedPlayerAttack(guess, isSucceed);
-                if(judgeGameOver())return;
+                if (judgeGameOver()) return;
                 changePhase(Phase.StartBotTurn, 0);
                 break;
             case StartBotTurn:
@@ -87,9 +90,9 @@
                 break;
             case BotAttack:
                 abstractGameState.updateTurn();
-                abstractGameState.attack(params[0],params[1],params[2]);
+                abstractGameState.attack(params[0], params[1], params[2]);
                 iGameView.onFinishedBotAttack(params[0], abstractGameState.isSucceedLatestAttack());
-                if(judgeGameOver())return;
+                if (judgeGameOver()) return;
                 changePhase(Phase.StartPlayerTurn);
                 break;
 
@@ -99,24 +102,26 @@
     public void setDeclaration(int guess) {
         changePhase(Phase.Declaration, guess);
     }
-    public void botAttack(int guess, int attacker, int target){
-        changePhase(Phase.BotAttack,guess,attacker,target);
+
+    public void botAttack(int guess, int attacker, int target) {
+        changePhase(Phase.BotAttack, guess, attacker, target);
 
 
     }
-    boolean judgeGameOver(){
 
-        if(algo.getLoseA()){
+    boolean judgeGameOver() {
+
+        if (algo.getLoseA()) {
             iGameView.onFinishedGame(abstractGameState, true);
-            return  true;
-        }else if(algo.getLoseB()){
-            iGameView.onFinishedGame(abstractGameState,false);
+            return true;
+        } else if (algo.getLoseB()) {
+            iGameView.onFinishedGame(abstractGameState, false);
             return true;
         }
         return false;
     }
 
-    enum Phase{
+    enum Phase {
         StartPlayerTurn,
         Selection,
         Target,
diff --git a/src/main/java/controls/TurnBot.java b/src/main/java/controls/TurnBot.java
index ba6d508..31bbf8e 100644
--- a/src/main/java/controls/TurnBot.java
+++ b/src/main/java/controls/TurnBot.java
@@ -2,7 +2,7 @@
 
 import resources.Algo;
 
-public class TurnBot extends AbstractGameState{
+public class TurnBot extends AbstractGameState {
     public TurnBot(Algo algo) {
         super(algo);
     }
diff --git a/src/main/java/controls/TurnPlayer.java b/src/main/java/controls/TurnPlayer.java
index a7d6bff..f157c4c 100644
--- a/src/main/java/controls/TurnPlayer.java
+++ b/src/main/java/controls/TurnPlayer.java
@@ -2,7 +2,7 @@
 
 import resources.Algo;
 
-public class TurnPlayer extends AbstractGameState{
+public class TurnPlayer extends AbstractGameState {
     public TurnPlayer(Algo algo) {
         super(algo);
     }
diff --git a/src/main/java/interfaces/IGameView.java b/src/main/java/interfaces/IGameView.java
index 34cfaae..76b0b98 100644
--- a/src/main/java/interfaces/IGameView.java
+++ b/src/main/java/interfaces/IGameView.java
@@ -5,20 +5,25 @@
 
 public interface IGameView {
     void onStartPlayerTurn(AbstractGameState abstractGameState);
+
     /**
      * アタックに使用するカードが決定した際に実行
+     *
      * @param selection
      */
     void onDecidedSelection(int selection);
+
     /**
      * アタックの対象が決定した際に実行
+     *
      * @param target
      */
     void onDecidedTarget(int target);
 
     /**
      * プレイヤーのアタックが終了した際に実行
-     * @param guess 宣言した数
+     *
+     * @param guess     宣言した数
      * @param isSucceed アタックの成否の結果
      */
     void onFinishedPlayerAttack(int guess, boolean isSucceed);
@@ -45,6 +50,7 @@
 
     /**
      * 盤面を再描画する
+     *
      * @param abstractGameState
      */
     void repaintBoard(AbstractGameState abstractGameState);
diff --git a/src/main/java/resources/Algo.java b/src/main/java/resources/Algo.java
index 85919fc..8d371e0 100644
--- a/src/main/java/resources/Algo.java
+++ b/src/main/java/resources/Algo.java
@@ -1,8 +1,11 @@
 package resources;
 
-import java.util.*;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
 
 import static views.Constants.DECK_COUNT;
+import static views.Constants.HAND_COUNT;
 
 public class Algo {
     private LoseB loseB;
@@ -16,6 +19,7 @@
     private SucceedSelectB succeedSelectB;
     int turnCount = 0;
     boolean isATurn;
+
     public Algo() {
         ///モデル生成分
         loseB = new LoseB();
@@ -29,13 +33,8 @@
         succeedSelectB = new SucceedSelectB(handsA, handsB);
         //追加分
         isATurn = true;
-        deck.reset(DECK_COUNT);
-        for (int i = 0; i < 2; i++) {
-            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));
+        deck.init(DECK_COUNT);
+
     }
 
     public void inputSelectA(int guess, int attacker, int target) {
@@ -54,10 +53,6 @@
         this.succeedSelectB.inputSelectB(guess, attacker, target);
     }
 
-    private void countUpTurn() {
-        turnCount++;
-    }
-
     public Map.Entry<Boolean, Map.Entry<Integer, Integer>> getSucceedSelectB() {
         return succeedSelectB.getValue();
     }
@@ -95,8 +90,25 @@
     }
 
     //追加分
+    /**
+     * 各プレイヤーに手札を配るメソッド
+     */
+    public void distributeHands(){
+        for (int i = 0; i < HAND_COUNT; i++) {
+            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));
+    }
+    public void setDeck(int... param){
+        deck.setValue(param);
+    }
     public boolean isATurn() {
         return isATurn;
     }
-    public void updateTurn(){isATurn= isATurn? false : true;}
+
+    public void updateTurn() {
+        isATurn = !isATurn;
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/resources/Algotest.java b/src/main/java/resources/Algotest.java
deleted file mode 100644
index 386cec3..0000000
--- a/src/main/java/resources/Algotest.java
+++ /dev/null
@@ -1,79 +0,0 @@
-package resources;
-
-import java.util.*;
-
-public class Algotest {
-    private LoseB loseB;
-    private HandsB handsB;
-    private LoseA loseA;
-    private HandsA handsA;
-    private Deck deck;
-    private SucceedDrawA succeedDrawA;
-    private SucceedDrawB succeedDrawB;
-    private SucceedSelectA succeedSelectA;
-    private SucceedSelectB succeedSelectB;
-
-    public Algotest() {
-        loseB = new LoseB();
-        handsB = new HandsB(loseB);
-        loseA = new LoseA();
-        handsA = new HandsA(loseA);
-        deck = new Deck();
-        succeedDrawA = new SucceedDrawA(handsB, deck, handsA);
-        succeedDrawB = new SucceedDrawB(deck, handsB, handsA);
-        succeedSelectA = new SucceedSelectA(handsB, handsA);
-        succeedSelectB = new SucceedSelectB(handsA, handsB);
-    }
-
-    public void inputSelectA(int guess, int attacker, int target) {
-        this.succeedSelectA.inputSelectA(guess, attacker, target);
-    }
-
-    public void inputDrawA(int guess, int target) {
-        this.succeedDrawA.inputDrawA(guess, target);
-    }
-
-    public void inputDrawB(int guess, int target) {
-        this.succeedDrawB.inputDrawB(guess, target);
-    }
-
-    public void inputSelectB(int guess, int attacker, int target) {
-        this.succeedSelectB.inputSelectB(guess, attacker, target);
-    }
-
-    public Map.Entry<Boolean, Map.Entry<Integer, Integer>> getSucceedSelectB() {
-        return succeedSelectB.getValue();
-    }
-
-    public Map.Entry<Boolean, Map.Entry<Integer, Integer>> getSucceedSelectA() {
-        return succeedSelectA.getValue();
-    }
-
-    public List getDeck() {
-        return deck.getValue();
-    }
-
-    public Map.Entry<Boolean, Integer> getSucceedDrawB() {
-        return succeedDrawB.getValue();
-    }
-
-    public boolean getLoseA() {
-        return loseA.getValue();
-    }
-
-    public boolean getLoseB() {
-        return loseB.getValue();
-    }
-
-    public List<Map.Entry<Integer, Boolean>> getHandsB() {
-        return handsB.getValue();
-    }
-
-    public List<Map.Entry<Integer, Boolean>> getHandsA() {
-        return handsA.getValue();
-    }
-
-    public Map.Entry<Boolean, Integer> getSucceedDrawA() {
-        return succeedDrawA.getValue();
-    }
-}
\ No newline at end of file
diff --git a/src/main/java/resources/Deck.java b/src/main/java/resources/Deck.java
index 4d80fb5..0b443a0 100644
--- a/src/main/java/resources/Deck.java
+++ b/src/main/java/resources/Deck.java
@@ -8,16 +8,22 @@
     private List<Map.Entry<Integer, Boolean>> value = new ArrayList<>();
 
     //added
-    public void reset(int num) {
+    public void init(int num) {
         for (int i = 0; i < num; i++) {
             this.value.add(new AbstractMap.SimpleEntry<>(i, false));
         }
         Collections.shuffle(this.value);
     }
 
+    public void setValue(int... params){
+        this.value.clear();
+        for (int i = 0; i < params.length; i++){
+            this.value.add(new AbstractMap.SimpleEntry<>(i, false));
+        }
+    }
     //added
     public Map.Entry<Integer, Boolean> head() {
-        var card = getValue().get(0);
+        Map.Entry<Integer, Boolean> card = getValue().get(0);
         getValue().remove(getValue().get(0));
         return card;
     }
diff --git a/src/main/java/resources/LoseA.java b/src/main/java/resources/LoseA.java
index fe2e386..79a95ba 100644
--- a/src/main/java/resources/LoseA.java
+++ b/src/main/java/resources/LoseA.java
@@ -1,6 +1,7 @@
 package resources;
 
-import java.util.*;
+import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 
 public class LoseA {
diff --git a/src/main/java/resources/LoseB.java b/src/main/java/resources/LoseB.java
index e24a6cc..7757b0a 100644
--- a/src/main/java/resources/LoseB.java
+++ b/src/main/java/resources/LoseB.java
@@ -1,6 +1,7 @@
 package resources;
 
-import java.util.*;
+import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 
 public class LoseB {
diff --git a/src/main/java/resources/SucceedDrawA.java b/src/main/java/resources/SucceedDrawA.java
index 376387c..d817ebc 100644
--- a/src/main/java/resources/SucceedDrawA.java
+++ b/src/main/java/resources/SucceedDrawA.java
@@ -1,7 +1,9 @@
 package resources;
 
 
-import java.util.*;
+import java.util.AbstractMap;
+import java.util.List;
+import java.util.Map;
 
 public class SucceedDrawA {
     private HandsB handsB;
diff --git a/src/main/java/resources/SucceedDrawB.java b/src/main/java/resources/SucceedDrawB.java
index ff75bef..09bda57 100644
--- a/src/main/java/resources/SucceedDrawB.java
+++ b/src/main/java/resources/SucceedDrawB.java
@@ -1,6 +1,8 @@
 package resources;
 
-import java.util.*;
+import java.util.AbstractMap;
+import java.util.List;
+import java.util.Map;
 
 public class SucceedDrawB {
     private Deck deck;
diff --git a/src/main/java/resources/SucceedSelectA.java b/src/main/java/resources/SucceedSelectA.java
index fcb96a7..b14c24d 100644
--- a/src/main/java/resources/SucceedSelectA.java
+++ b/src/main/java/resources/SucceedSelectA.java
@@ -1,6 +1,7 @@
 package resources;
 
-import java.util.*;
+import java.util.AbstractMap;
+import java.util.Map;
 
 public class SucceedSelectA {
     private HandsB handsB;
diff --git a/src/main/java/resources/SucceedSelectB.java b/src/main/java/resources/SucceedSelectB.java
index 8cc154c..827721e 100644
--- a/src/main/java/resources/SucceedSelectB.java
+++ b/src/main/java/resources/SucceedSelectB.java
@@ -1,6 +1,7 @@
 package resources;
 
-import java.util.*;
+import java.util.AbstractMap;
+import java.util.Map;
 
 public class SucceedSelectB {
     private HandsA handsA;
diff --git a/src/main/java/views/ActivateListener.java b/src/main/java/views/ActivateListener.java
new file mode 100644
index 0000000..6e5655a
--- /dev/null
+++ b/src/main/java/views/ActivateListener.java
@@ -0,0 +1,5 @@
+package views;
+
+public interface ActivateListener {
+    void onActivate();
+}
diff --git a/src/main/java/views/CardButton.java b/src/main/java/views/CardButton.java
index 1eadaf1..144daf1 100644
--- a/src/main/java/views/CardButton.java
+++ b/src/main/java/views/CardButton.java
@@ -2,11 +2,9 @@
 
 import javax.swing.*;
 import javax.swing.border.LineBorder;
-
 import java.awt.*;
 
 import static views.Constants.*;
-import static views.Constants.CARD_HEIGHT;
 
 public class CardButton extends JButton {
     private Status status;
diff --git a/src/main/java/views/Constants.java b/src/main/java/views/Constants.java
index 2c062bc..291f0f9 100644
--- a/src/main/java/views/Constants.java
+++ b/src/main/java/views/Constants.java
@@ -1,35 +1,16 @@
 package views;
 
-import javax.swing.*;
 import java.awt.*;
 
 public class Constants {
     public static final int CARD_WIDTH = 50;
     public static final int CARD_HEIGHT = 75;
-    public Step STEP;
-
-    public enum Step {
-        SelectMyHands,
-        SelectOpponentHands,
-        Declare,
-        Confirm,
-        OpponentSelect,
-        OpponentDeclare,
-        OpponentJudge,
-        OpponentConfirm
-    }
-
     public static String CLOSED_SYMBOL = "?";
-    public static int DECK_COUNT = 11;
+    public static int DECK_COUNT = 12;
+    public static int HAND_COUNT = 2;
     public static Color SELECTED_COLOR = Color.CYAN;
     public static Color ATTACKER_COLOR = Color.RED;
     public static Color UNSELECTED_COLOR = Color.BLACK;
     public static Color OPEN_COLOR = Color.WHITE;
     public static Color CLOSED_COLOR = Color.BLACK;
-    public static JButton cardPaint = new JButton() {
-        @Override
-        protected void paintComponent(Graphics g) {
-            super.paintComponent(g);
-        }
-    };
 }
diff --git a/src/main/java/views/HandButtons.java b/src/main/java/views/HandButtons.java
index d0b86a5..bdbdf48 100644
--- a/src/main/java/views/HandButtons.java
+++ b/src/main/java/views/HandButtons.java
@@ -7,20 +7,22 @@
  * 手札の情報をボタンで扱うためのクラス
  */
 class HandButtons extends ArrayList<CardButton> {
-    public void addListeners(ActionListener al){
-        for (var hb : this){
+    public void addListeners(ActionListener al) {
+        for (CardButton hb : this) {
             hb.addActionListener(al);
         }
     }
-    public void setEnableButtons(boolean enableButtons){
-        for (var hb : this){
+
+    public void setEnableButtons(boolean enableButtons) {
+        for (CardButton hb : this) {
             hb.setEnabled(enableButtons);
         }
     }
-    public void removeButtonListeners(){
-        for(var my:this) {
-            for( ActionListener al : my.getActionListeners() ) {
-                my.removeActionListener( al );
+
+    public void removeButtonListeners() {
+        for (CardButton my : this) {
+            for (ActionListener al : my.getActionListeners()) {
+                my.removeActionListener(al);
             }
         }
     }
diff --git a/src/main/java/views/MainFrame.java b/src/main/java/views/MainFrame.java
index f69bab9..acaf0e4 100644
--- a/src/main/java/views/MainFrame.java
+++ b/src/main/java/views/MainFrame.java
@@ -12,14 +12,11 @@
 
     public MainFrame() {
         super("Algolike");
-        var algo = new Algo();
-        var mainPanel = new MainPanel(algo);
-        var phaseController = new PhaseController(algo);
-        mainPanel.bindPhaseController(phaseController);
-        phaseController.bindGameView(mainPanel);
+        Algo algo = new Algo();
+        algo.distributeHands();
+        MainPanel mainPanel = new MainPanel(algo);
 
         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-        mainPanel.setVisible(true);
 
         this.add(mainPanel, BorderLayout.CENTER);
         this.pack();
@@ -27,7 +24,7 @@
         this.addWindowListener(new WindowListener() {
             @Override
             public void windowOpened(WindowEvent e) {
-                phaseController.startGame();
+                mainPanel.activate();
             }
 
             @Override
diff --git a/src/main/java/views/MainPanel.java b/src/main/java/views/MainPanel.java
index 2cc785d..c123729 100644
--- a/src/main/java/views/MainPanel.java
+++ b/src/main/java/views/MainPanel.java
@@ -1,28 +1,35 @@
 package views;
 
-import controls.*;
+import controls.AbstractGameState;
+import controls.BotIntelligence;
+import controls.PhaseController;
+import controls.TurnBot;
 import interfaces.IGameView;
 import resources.Algo;
 
 import javax.swing.*;
 import java.awt.*;
-import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
+import java.awt.event.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
 
 import static java.lang.Integer.parseInt;
 import static views.Constants.*;
 
 public class MainPanel extends JPanel implements IGameView {
+    PhaseController phaseController;
     JPanel myHandButtonsPanel;
     JPanel myHandAttackerPanel;
     JPanel myPanel;
     JPanel opponentButtonsPanel;
     JPanel opponentAttackerPanel;
     JPanel opponentPanel;
-    PhaseController phaseController;
     private HandButtons myHandButtons;
     private HandButtons opponentHandButtons;
     private JPanel deckButtonPanel;
+    List<ActivateListener> activateListeners = new ArrayList<>();
+
     public MainPanel(Algo algo) {
         super(new BorderLayout());
         myHandButtons = new HandButtons();
@@ -38,7 +45,7 @@
         opponentAttackerPanel = new JPanel();
         opponentPanel = new JPanel();
 
-        phaseController = new PhaseController(algo);
+        phaseController = new PhaseController(algo, this);
 
         myPanel.add(myHandAttackerPanel);
         myPanel.add(myHandButtonsPanel);
@@ -50,12 +57,47 @@
         add(myPanel, BorderLayout.SOUTH);
         add(opponentPanel, BorderLayout.NORTH);
 
+        this.addComponentListener(new ComponentListener() {
+            @Override
+            public void componentResized(ComponentEvent e) {
+
+            }
+
+            @Override
+            public void componentMoved(ComponentEvent e) {
+
+            }
+
+            @Override
+            public void componentShown(ComponentEvent e) {
+                phaseController.startGame();
+            }
+
+            @Override
+            public void componentHidden(ComponentEvent e) {
+
+            }
+        });
+
         updateOpponentHandButtons();
         repaint();
+
+        this.addActivateListener(new ActivateListener() {
+            @Override
+            public void onActivate() {
+                phaseController.startGame();
+            }
+        });
     }
-    public void bindPhaseController(PhaseController phaseController){
-        this.phaseController = phaseController;
+
+    public void addActivateListener(ActivateListener activateListener) {
+        activateListeners.add(activateListener);
     }
+
+    public void activate() {
+        for (ActivateListener al : activateListeners) al.onActivate();
+    }
+
     void updateMyHandButtons() {
         /**
          * 自分の手札のボタンにリスナーを追加する処理
@@ -65,17 +107,17 @@
         myHandButtons.addListeners(new ActionListener() {
             @Override
             public void actionPerformed(ActionEvent e) {
-                var sourceButton = ((CardButton) e.getSource());
-                var isOpened = sourceButton.getStatus()== CardButton.Status.OPEN;
-                if(isOpened){
+                CardButton sourceButton = ((CardButton) e.getSource());
+                boolean isOpened = sourceButton.getStatus() == CardButton.Status.OPEN;
+                if (isOpened) {
                     JOptionPane.showMessageDialog(null, "裏のカードを選んでください. ", "Warn",
                             JOptionPane.WARNING_MESSAGE);
                     return;
                 }
 
-                for (var my : MainPanel.this.myHandButtons) my.setEnabledSelection(false);
+                for (CardButton my : MainPanel.this.myHandButtons) my.setEnabledSelection(false);
                 sourceButton.setEnabledSelection(true);
-                var option = JOptionPane.showConfirmDialog(null, "このカードを使ってアタックをしますか?", "confirmation", 2);
+                int option = JOptionPane.showConfirmDialog(null, "このカードを使ってアタックをしますか?", "confirmation", 2);
 
                 if (option == JOptionPane.YES_OPTION) {
                     int attacker = myHandButtons.indexOf(sourceButton);
@@ -96,16 +138,16 @@
         opponentHandButtons.addListeners(new ActionListener() {
             @Override
             public void actionPerformed(ActionEvent e) {
-                if(!phaseController.isDecidedAttacker()){
+                if (!phaseController.isDecidedAttacker()) {
                     JOptionPane.showMessageDialog(null, "あなたの手札からアタックに使用するカードを選んでください. ", "Warn",
-                                JOptionPane.WARNING_MESSAGE);
+                            JOptionPane.WARNING_MESSAGE);
                     return;
                 }
-                var sourceButton = ((CardButton) e.getSource());
-                var index = opponentHandButtons.indexOf(sourceButton);
+                CardButton sourceButton = ((CardButton) e.getSource());
+                int index = opponentHandButtons.indexOf(sourceButton);
                 sourceButton.setEnabledSelection(true);
                 //相手のカードを選択したときに確認用ダイアログを出す
-                var option = JOptionPane.showConfirmDialog(null, "このカードを選びますか?", "confirmation", 2);
+                int option = JOptionPane.showConfirmDialog(null, "このカードを選びますか?", "confirmation", 2);
                 if (option == JOptionPane.YES_OPTION) {
                     phaseController.setTarget(index);
                 } else {
@@ -116,10 +158,10 @@
     }
 
     void paintDrawCard(AbstractGameState abstractGameState) {
-        var deckTopCard = abstractGameState.getTopCard();
+        Map.Entry<Integer, Boolean> deckTopCard = abstractGameState.getTopCard();
 
         if (!abstractGameState.isDeckLess()) {    //デッキが存在する場合にデッキトップのカードを表示する処理
-            var cardButton = new CardButton(deckTopCard.getKey().toString());
+            CardButton cardButton = new CardButton(deckTopCard.getKey().toString());
             cardButton.setBounds(0, 100, CARD_WIDTH, CARD_HEIGHT);
             if (abstractGameState.isATurn()) {
                 myHandAttackerPanel.add(cardButton);
@@ -130,38 +172,41 @@
             if (abstractGameState.getDeckNumber() == 1) {
                 deckButtonPanel.removeAll();
             }
-        }else{
+        } else {
             updateMyHandButtons();
         }
 
         validate();
         repaint();
     }
+
     @Override
     public void onStartPlayerTurn(AbstractGameState abstractGameState) {
         JOptionPane.showMessageDialog(null, "あなたのターンです。");
-        var selectText = !abstractGameState.isDeckLess()
+        String selectText = !abstractGameState.isDeckLess()
                 ? "あなたは数字\"" + abstractGameState.getTopCard().getKey() + "\"のカードをドローしました。"
                 : "アタックに使用するカードを手札から選んでください。";
 
         paintDrawCard(abstractGameState);
         if (!abstractGameState.isDeckLess()) {
-            selectText ="あなたは数字\"" + abstractGameState.getTopCard().getKey() + "\"のカードをドローしました。";
+            selectText = "あなたは数字\"" + abstractGameState.getTopCard().getKey() + "\"のカードをドローしました。";
             phaseController.setSelection(0);
-        }else {
+        } else {
             selectText = "アタックに使用するカードを手札から選んでください。";
         }
         JOptionPane.showMessageDialog(null, selectText);
 
     }
+
     @Override
     public void onDecidedSelection(int attacker) {
     }
+
     @Override
     public void onDecidedTarget(int target) {
         String[] optionsToChoose = new String[DECK_COUNT];
-        for (var i = 0; i < optionsToChoose.length; i++) optionsToChoose[i] = String.valueOf(i);
-        var getDeclaredNumber = (String) JOptionPane.showInputDialog(
+        for (int i = 0; i < optionsToChoose.length; i++) optionsToChoose[i] = String.valueOf(i);
+        String getDeclaredNumber = (String) JOptionPane.showInputDialog(
                 null,
                 "このカードの数字を宣言してください。",
                 "Declare Number",
@@ -171,12 +216,13 @@
                 optionsToChoose[0]);
 
         if (getDeclaredNumber != null) {   //数字を宣言して、承認したとき
-            var g = parseInt(getDeclaredNumber);
+            int g = parseInt(getDeclaredNumber);
             phaseController.setDeclaration(g);
         } else {
             opponentHandButtons.get(target).setEnabledSelection(false);
         }
     }
+
     @Override
     public void onFinishedPlayerAttack(int guess, boolean isSucceed) {
         String resultMessage = "あなたのアタックは";
@@ -187,57 +233,46 @@
 
     @Override
     public void onStartBotAttack(TurnBot turnBot) {
-        var bot = new BotIntelligence(turnBot);
-        JOptionPane.showMessageDialog(null, "Botのターンです。");
-        var selectText = "";
-        var atk = 0;
+        BotIntelligence bot = new BotIntelligence(turnBot);
+        JOptionPane.showMessageDialog(null, "CPUのターンです。");
+        String selectText = "";
+        int atk = 0;
         if (!turnBot.isDeckLess()) { //デッキにカードが存在するとき
             paintDrawCard(turnBot);//デッキから引いたカードを描画する
-            selectText = "Botはカードをドローしました。";
+            selectText = "CPUはカードをドローしました。";
         } else {
             atk = bot.selectAttacker();
             opponentHandButtons.get(atk).setEnabledSelection(true);
-            selectText = "Botはアタックに使用するカードを選びました。";
+            selectText = "CPUはアタックに使用するカードを選びました。";
         }
         JOptionPane.showMessageDialog(null, selectText);
 
-        var targetText = "";
-        var tar = bot.selectTarget();
+        String targetText = "";
+        int tar = bot.selectTarget();
         myHandButtons.get(tar).setEnabledSelection(true);
-        JOptionPane.showMessageDialog(null, "Botはこのカードを対象にしました。");
+        JOptionPane.showMessageDialog(null, "CPUはこのカードを対象にしました。");
 
 
-        var dec = bot.declareNumber(tar);
-        JOptionPane.showMessageDialog(null, "Botは\"" + dec + "\"を宣言しました。");
+        int dec = bot.declareNumber(tar);
+        JOptionPane.showMessageDialog(null, "CPUは\"" + dec + "\"を宣言しました。");
 
         phaseController.botAttack(dec, atk, tar);
-//        boolean isSucceed = abstractGameState.isSucceedLatestAttack();
-//
-//        String resultMessage = "Botのアタックは ";
-//        resultMessage += isSucceed ? "成功しました。" : "失敗しました。";
-//        JOptionPane.showMessageDialog(null, resultMessage);
-//
-//        myHandButtons.get(tar).setEnabledSelection(false);
-//        repaintField();
-//        if (isGameOver()) {
-//            finishGame();
-//            return;
-//        }
-//        abstractGameState.updateTurn();
+
     }
 
     @Override
     public void onFinishedBotAttack(int guess, boolean isSucceed) {
-        String resultMessage = "Botのアタックは";
+        String resultMessage = "CPUのアタックは";
         resultMessage += isSucceed ? "成功しました。" : "失敗しました。";
         resultMessage += "(宣言した値：" + guess + ")";
         JOptionPane.showMessageDialog(null, resultMessage);
 
     }
+
     @Override
     public void repaintBoard(AbstractGameState abstractGameState) {
-        var myHands = abstractGameState.getMyHands();
-        var opponentHands = abstractGameState.getOpponentHands();
+        List<Map.Entry<Integer, Boolean>> myHands = abstractGameState.getMyHands();
+        List<Map.Entry<Integer, Boolean>> opponentHands = abstractGameState.getOpponentHands();
 
         /**
          * 初期化処理(する必要があるのかどうかは知らない)
@@ -251,12 +286,12 @@
         opponentHandButtons.clear();
 
         if (!abstractGameState.isDeckLess()) {        //デッキが存在する場合
-            var cardButton = new JButton("deck");
+            JButton cardButton = new JButton("deck");
             cardButton.setPreferredSize(new Dimension(CARD_HEIGHT, CARD_WIDTH));
             deckButtonPanel.add(cardButton);
         }
-        for (var i : myHands) {
-            var cardButton = new CardButton(i.getKey().toString());
+        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);
             myHandButtons.add(cardButton);
             myHandButtonsPanel.add(cardButton);
@@ -266,8 +301,8 @@
         /**
          *相手のカードに関する処理
          */
-        for (var i : opponentHands) {
-            var cardButton = new CardButton(i.getValue() ? i.getKey().toString() : CLOSED_SYMBOL);
+        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());
             opponentHandButtons.add(cardButton);
@@ -279,13 +314,14 @@
         validate();
         repaint();
     }
+
     @Override
     public void onFinishedGame(AbstractGameState abstractGameState, boolean isLoseA) {
         this.repaintBoard(abstractGameState);
         myHandButtons.setEnableButtons(false);
         opponentHandButtons.setEnableButtons(false);
         if (isLoseA) {
-            JOptionPane.showMessageDialog(null, "Botが勝利しました。");
+            JOptionPane.showMessageDialog(null, "CPUが勝利しました。");
         } else {
             JOptionPane.showMessageDialog(null, "あなたが勝利しました。");
         }
diff --git a/src/main/java/views/StartPanel.java b/src/main/java/views/StartPanel.java
new file mode 100644
index 0000000..c711fca
--- /dev/null
+++ b/src/main/java/views/StartPanel.java
@@ -0,0 +1,20 @@
+package views;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+public class StartPanel extends JPanel {
+    public StartPanel(MainPanel mainPanel) {
+        super(new BorderLayout());
+        var button = new JButton("Start");
+        button.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                mainPanel.setVisible(true);
+            }
+        });
+        add(button);
+    }
+}
diff --git a/src/test/java/AlgoTest.java b/src/test/java/AlgoTest.java
index 636248d..66619a0 100644
--- a/src/test/java/AlgoTest.java
+++ b/src/test/java/AlgoTest.java
@@ -1,6 +1,8 @@
 import resources.Algo;
 import org.junit.jupiter.api.Test;
+import resources.Deck;
 
+import java.lang.reflect.Field;
 import java.util.AbstractMap;
 
 import static controls.ConstantMethods.printAlgoState;
@@ -9,7 +11,16 @@
 public class AlgoTest {
 
     @Test
-    void ゲーム開始時0から10のカードで構成されたデッキとそこから2枚引いて構成された各プレイヤーの手札が存在する() {
+    void testAlgo(){
+        Algo algo = new Algo();
+
+    }
+
+    /**
+     * ゲーム開始時0から10のカードで構成されたデッキとそこから2枚引いて構成された各プレイヤーの手札が存在する
+     */
+    @Test
+    void testInitialize() {
         Algo algo = new Algo();
         printAlgoState(algo);
         assertEquals(2, algo.getHandsA().size());
@@ -17,8 +28,11 @@
 
     }
 
+    /**
+     * Aはデッキから引いたカードでアタックが成功してBのカードが1枚表になる
+     */
     @Test
-    void Aはデッキから引いたカードでアタックが成功してBのカードが1枚表になる() {
+    void testAttack() {
         //初期化
         Algo algo = new Algo();
         var iniHandsANum = algo.getHandsA().size();
@@ -39,8 +53,12 @@
         assertEquals(initDeckNum-1,algo.getDeck().size());
 
     }
+
+    /**
+     * Aはデッキから引いたカードでアタックが失敗してAのデッキに表のカードが追加される
+     */
     @Test
-    void Aはデッキから引いたカードでアタックが失敗してAのデッキに表のカードが追加される() {
+    void tes() {
         //初期化
         Algo algo = new Algo();
         var iniHandsANum = algo.getHandsA().size();
@@ -64,8 +82,12 @@
         assertEquals(initDeckNum-1,algo.getDeck().size());
 
     }
+
+    /**
+     * Bはデッキから引いたカードでアタックが成功してAのカードが1枚表になる
+     */
     @Test
-    void Bはデッキから引いたカードでアタックが成功してAのカードが1枚表になる() {
+    void testAtk() {
         //初期化
         Algo algo = new Algo();
         var iniHandsBNum = algo.getHandsB().size();
@@ -84,8 +106,12 @@
         //Aがデッキから引いているので,デッキの枚数が1枚減っているか
         assertEquals(initDeckNum-1,algo.getDeck().size());
     }
+
+    /**
+     * Aは手札から選んだカードでアタックが成功してBのカードが1枚表になる
+     */
     @Test
-    void Aは手札から選んだカードでアタックが成功してBのカードが1枚表になる() {
+    void testAtk2() {
         //初期化
         Algo algo = new Algo();
 
@@ -103,8 +129,12 @@
         //Aのアタックを成功しているので,使用したカードが表になっていないか
         assertEquals(false, algo.getHandsA().get(attacker).getValue());
     }
+
+    /**
+     * Aは手札から選んだカードでのアタックが失敗し選んだカードが表になる
+     */
     @Test
-    void Aは手札から選んだカードでのアタックが失敗し選んだカードが表になる() {
+    void testAtk3() {
         //初期化
         Algo algo = new Algo();
 
@@ -121,10 +151,21 @@
         //Aのアタックが失敗しているので,使用したカードが表になっているか
         assertEquals(true, algo.getHandsA().get(attacker).getValue());
     }
+
     @Test
-    void playA(){
+    void playB() {
         Algo algo = new Algo();
-        //正解のカードを選択させるための変数
+        algo.setDeck(0, 1, 2, 3, 4, 5, 6);
+        algo.distributeHands();
+
+
+
+        printAlgoState(algo);
+    }
+    @Test
+    void playA() {
+        Algo algo = new Algo();
+        algo.distributeHands();
         var guess = algo.getHandsB().get(0).getKey();
         var target = 0;
         var attacker = 0;
diff --git a/src/test/java/MainTest.java b/src/test/java/MainTest.java
new file mode 100644
index 0000000..c9da560
--- /dev/null
+++ b/src/test/java/MainTest.java
@@ -0,0 +1,63 @@
+import org.junit.jupiter.api.Test;
+import resources.Algo;
+
+import static controls.ConstantMethods.printAlgoState;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class MainTest {
+    @Test
+    void test(){
+        Algo algo = new Algo();
+        algo.setDeck(0, 1, 2, 3, 4, 5, 6, 7);
+        algo.distributeHands();
+        printAlgoState(algo);
+
+        //Aはカードを1枚引き、Bの0番目のカードに対して「1」を宣言する。
+        algo.inputDrawA(3, 0);
+
+        //アタックは失敗する。
+        assertEquals(false, algo.getSucceedDrawA().getKey());
+
+        assertEquals(false, algo.getLoseA());
+        assertEquals(false, algo.getLoseB());
+
+        //Bはカードを1枚引き、Aの2番目のカードに対して「2」を宣言する。
+        algo.inputDrawB(2,2);
+
+        //アタックは失敗する。
+        assertEquals(false, algo.getSucceedDrawB().getKey());
+
+        assertEquals(false, algo.getLoseA());
+        assertEquals(false, algo.getLoseB());
+
+        //Aはカードを1枚引き、Bの1番目のカードに対して「3」を宣言する。
+        algo.inputDrawA(3, 1);
+
+        //アタックは成功する。
+        assertEquals(true, algo.getSucceedDrawA().getKey());
+
+        assertEquals(false, algo.getLoseA());
+        assertEquals(false, algo.getLoseB());
+
+        //Bはカードを1枚引き、Aの0番目のカードに対して「2」を宣言する。
+        algo.inputDrawB(2,0);
+
+        //アタックは失敗する。
+        assertEquals(false, algo.getSucceedDrawB().getKey());
+
+        assertEquals(false, algo.getLoseA());
+        assertEquals(false, algo.getLoseB());
+
+        //Aは手札の0番目のカードアタックに使用し、Bの0番目のカードに対して「1」を宣言する。
+        algo.inputSelectA(1, 0, 0);
+
+        //アタックは成功する。
+        assertEquals(true, algo.getSucceedSelectA().getKey());
+
+        //Bの手札が全て表になったので、Bは敗北する。
+        assertEquals(false, algo.getLoseA());
+        assertEquals(true, algo.getLoseB());
+
+        printAlgoState(algo);
+    }
+}
diff --git a/src/test/java/controls/BotIntelligenceTest.java b/src/test/java/controls/BotIntelligenceTest.java
index aa18c35..81f11b2 100644
--- a/src/test/java/controls/BotIntelligenceTest.java
+++ b/src/test/java/controls/BotIntelligenceTest.java
@@ -8,8 +8,11 @@
 
 class BotIntelligenceTest {
 
+    /**
+     * 正しく未確定数字を計算ができる
+     */
     @Test
-    void 正しく未確定数字を計算ができる() {
+    void testCalc() {
         StepScheduler stepScheduler=new StepScheduler();
 
         var algo = stepScheduler.algo;
@@ -22,8 +25,12 @@
         s+="]";
         System.out.println(s);
     }
+
+    /**
+     * 各手札のカードに対して候補を算出できる
+     */
     @Test
-    void 各手札のカードに対して候補を算出できる(){
+    void calc(){
         StepScheduler stepScheduler=new StepScheduler();
 
         var algo = stepScheduler.algo;