diff --git a/src/main/java/Main.java b/src/main/java/Main.java
index 7ccfb3e..c4252fa 100644
--- a/src/main/java/Main.java
+++ b/src/main/java/Main.java
@@ -3,7 +3,7 @@
 import javax.swing.*;
 
 public class Main {
-    public static void main(String[] args){
+    public static void main(String[] args) {
         JFrame mainFrame = new MainFrame();
         mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         mainFrame.setSize(640, 480);
diff --git a/src/main/java/controls/BotIntelligence.java b/src/main/java/controls/BotIntelligence.java
index 1435452..d2d1588 100644
--- a/src/main/java/controls/BotIntelligence.java
+++ b/src/main/java/controls/BotIntelligence.java
@@ -10,16 +10,17 @@
 
 public class BotIntelligence implements IBotBehavior {
 
-    public BotIntelligence(){
+    public BotIntelligence() {
 
     }
+
     /**
-    未確定の数字を列挙する
+     * 未確定の数字を列挙する
      */
-    List<Integer> calculateCandidate(IAttack iAttack){
+    List<Integer> calculateCandidate(IAttack iAttack) {
         //候補の初期化
         var candidates = new ArrayList<Integer>();
-        for(int i=0;i<DECK_COUNT;i++)candidates.add(i);
+        for (int i = 0; i < DECK_COUNT; i++) candidates.add(i);
 
         candidates.removeAll(iAttack.getOpponentHands().stream().map(x -> x.getKey()).collect(Collectors.toList()));
         candidates.removeAll(iAttack.getMyHands().stream().filter(x -> x.getValue()).map(x -> x.getKey()).collect(Collectors.toList()));
@@ -29,49 +30,50 @@
 
     /**
      * 相手の手札に対して、候補となる数字を割り当てる
+     *
      * @param iAttack
      * @return 候補のリスト
      */
-    List<int[]> assignCandidateNumberEachHand(IAttack iAttack){
-        var myHands=iAttack.getMyHands();
-        var result=new ArrayList<int[]>();
+    List<int[]> assignCandidateNumberEachHand(IAttack iAttack) {
+        var myHands = iAttack.getMyHands();
+        var result = new ArrayList<int[]>();
 
-        for(var card:myHands){//ユーザーの手札を左から見ていく
-            var index=myHands.indexOf(card);//左からindex番目に
+        for (var card : myHands) {//ユーザーの手札を左から見ていく
+            var index = myHands.indexOf(card);//左からindex番目に
             var candidateList = calculateCandidate(iAttack);//確認するカード
 
 
-            if(card.getValue()) {
+            if (card.getValue()) {
                 candidateList.clear();
-            }else{                  //裏の場合
+            } else {                  //裏の場合
 
                 //そのカードから右隣のカードを確認していく
-                for(int i=0;i<myHands.size()-index-1;i++){
+                for (int i = 0; i < myHands.size() - index - 1; i++) {
                     //今確認していっているカード
-                    var currentCard = myHands.get(i+index+1);
-                    if(currentCard.getValue()){//確認しているカードが表なら、(YES)
+                    var 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番目の数字を除外する。
-                            candidateList.remove(candidateList.size()-1);
+                        for (int j = 1; j < i; j++) {//そして、その確認したカードよりjだけ小さいそのカードからj番目の数字を除外する。
+                            candidateList.remove(candidateList.size() - 1);
                         }
                         break;
                     }
                 }
 
                 //そのカードから左隣のカードを確認していく
-                for(int i=1;i<=index;i++){
+                for (int i = 1; i <= index; i++) {
                     //今確認していっているカード
-                    var currentCard = myHands.get(index-i);
-                    if(currentCard.getValue()){//表があれば、それより小さい数字を候補から削除する
-                        candidateList.removeIf(x-> x<currentCard.getKey());
+                    var currentCard = myHands.get(index - i);
+                    if (currentCard.getValue()) {//表があれば、それより小さい数字を候補から削除する
+                        candidateList.removeIf(x -> x < currentCard.getKey());
                     }
                 }
 
 
             }
-            var s=(card.getValue()?"+":"-")+card.getKey()+":[";
-            for (var i:candidateList)s+=i+" ";
-            s+="]\n";
+            var s = (card.getValue() ? "+" : "-") + card.getKey() + ":[";
+            for (var i : candidateList) s += i + " ";
+            s += "]\n";
             System.out.println(s);
             result.add(candidateList.stream().mapToInt(x -> x).toArray());
         }
@@ -83,21 +85,21 @@
     public int selectAttacker(IAttack iAttack) {
         var botHands = iAttack.getOpponentHands();
 
-        for(var i:botHands){//小さいものから選択
-            if(!i.getValue())return botHands.indexOf(i);
+        for (var i : botHands) {//小さいものから選択
+            if (!i.getValue()) return botHands.indexOf(i);
         }
         return 0;
     }
 
     @Override
     public int selectTarget(IAttack iAttack) {
-        var candidate= assignCandidateNumberEachHand(iAttack);
-        int result=0;
-        int min=DECK_COUNT;
-        for(var i:candidate){
-            if(i.length<min&&i.length!=0){
-                result=candidate.indexOf(i);
-                min=i.length;
+        var candidate = assignCandidateNumberEachHand(iAttack);
+        int result = 0;
+        int min = DECK_COUNT;
+        for (var i : candidate) {
+            if (i.length < min && i.length != 0) {
+                result = candidate.indexOf(i);
+                min = i.length;
             }
         }
         return result;
@@ -105,7 +107,7 @@
 
     @Override
     public int declareNumber(IAttack iAttack, int target) {
-        var array =assignCandidateNumberEachHand(iAttack).get(target);
+        var array = assignCandidateNumberEachHand(iAttack).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 8680f10..8dacc13 100644
--- a/src/main/java/controls/ConstantMethods.java
+++ b/src/main/java/controls/ConstantMethods.java
@@ -1,25 +1,25 @@
 package controls;
 
-import models.Algo;
+import resources.Algo;
 
 public class ConstantMethods {
-    public static void printAlgoState(Algo algo){
-        String s="";
-        s+="deck:\n";
-        for(var i : algo.getDeck()){
-            s+="\t"+i.getKey()+"\t"+(i.getValue()?"open":"closed")+"\n";
+    public static void printAlgoState(Algo algo) {
+        String s = "";
+        s += "deck:\n";
+        for (var i : algo.getDeck()) {
+            s += "\t" + i.getKey() + "\t" + (i.getValue() ? "open" : "closed") + "\n";
         }
-        s+="handsA:\n";
-        for(var i : algo.getHandsA()){
-            s+="\t"+i.getKey()+"\t"+(i.getValue()?"open":"closed")+"\n";
+        s += "handsA:\n";
+        for (var i : algo.getHandsA()) {
+            s += "\t" + i.getKey() + "\t" + (i.getValue() ? "open" : "closed") + "\n";
         }
-        s+="handsB:\n";
-        for(var i : algo.getHandsB()){
-            s+="\t"+i.getKey()+"\t"+(i.getValue()?"open":"closed")+"\n";
+        s += "handsB:\n";
+        for (var i : algo.getHandsB()) {
+            s += "\t" + i.getKey() + "\t" + (i.getValue() ? "open" : "closed") + "\n";
         }
-        s+="\n";
-        if(algo.getLoseA())s+="B win.\n";
-        else if(algo.getLoseB())s+="A win.\n";
+        s += "\n";
+        if (algo.getLoseA()) s += "B win.\n";
+        else if (algo.getLoseB()) s += "A win.\n";
         System.out.println(s);
     }
 }
diff --git a/src/main/java/controls/StepScheduler.java b/src/main/java/controls/StepScheduler.java
index fa20250..eee1ccc 100644
--- a/src/main/java/controls/StepScheduler.java
+++ b/src/main/java/controls/StepScheduler.java
@@ -1,37 +1,37 @@
 package controls;
 
 import interfaces.IAttack;
-import models.Algo;
-import views.Constants;
+import resources.Algo;
 
 import java.util.List;
 import java.util.Map;
 
 public class StepScheduler implements IAttack {
     Algo algo;
-    int turnCount=0;
+    int turnCount = 0;
     boolean isATurn;
     boolean isSucceedLatestAttack;
-    public StepScheduler(){
+
+    public StepScheduler() {
         algo = new Algo();
-        isATurn=true;
+        isATurn = true;
     }
 
     @Override
-    public void Attack(int guess, int attacker, int target) {
-        if(isATurn){
-            if(isDeckLess()){
+    public void attack(int guess, int attacker, int target) {
+        if (isATurn) {
+            if (isDeckLess()) {
                 algo.inputSelectA(guess, attacker, target);
                 isSucceedLatestAttack = algo.getSucceedSelectA().getKey();
-            }else{
+            } else {
                 algo.inputDrawA(guess, target);
                 isSucceedLatestAttack = algo.getSucceedDrawA().getKey();
             }
-        }else {
-            if(isDeckLess()){
+        } else {
+            if (isDeckLess()) {
                 algo.inputSelectB(guess, attacker, target);
                 isSucceedLatestAttack = algo.getSucceedSelectB().getKey();
-            }else{
+            } else {
                 algo.inputDrawB(guess, target);
                 isSucceedLatestAttack = algo.getSucceedDrawB().getKey();
             }
@@ -52,12 +52,12 @@
 
     @Override
     public Map.Entry<Integer, Boolean> getTopCard() {
-        if(isDeckLess())return null;
+        if (isDeckLess()) return null;
         return algo.getDeck().get(0);
     }
 
-    public boolean isDeckLess(){
-        return algo.getDeck().size()==0;
+    public boolean isDeckLess() {
+        return algo.getDeck().size() == 0;
     }
 
     @Override
@@ -65,17 +65,17 @@
         return algo.getDeck().size();
     }
 
-    public boolean isSucceedLatestAttack(){
+    public boolean isSucceedLatestAttack() {
         return isSucceedLatestAttack;
     }
 
     @Override
-    public boolean shiftTurn() {
-        isATurn = isATurn?false:true;
+    public boolean updateTurn() {
+        isATurn = isATurn ? false : true;
         return isATurn;
     }
 
-    public boolean isATurn(){
+    public boolean isATurn() {
         return isATurn;
     }
 
diff --git a/src/main/java/interfaces/IAttack.java b/src/main/java/interfaces/IAttack.java
index 84f9eda..6f9b82c 100644
--- a/src/main/java/interfaces/IAttack.java
+++ b/src/main/java/interfaces/IAttack.java
@@ -1,24 +1,31 @@
 package interfaces;
 
-import views.Constants;
-
 import java.util.List;
 import java.util.Map;
 
 public interface IAttack {
     /**
-
+     *
      */
-    void Attack(int guess, int attacker, int target);
+    void attack(int guess, int attacker, int target);
+
     List<Map.Entry<Integer, Boolean>> getMyHands();
+
     List<Map.Entry<Integer, Boolean>> getOpponentHands();
 
     Map.Entry<Integer, Boolean> getTopCard();
+
     boolean isDeckLess();
+
     int getDeckNumber();
+
     boolean isSucceedLatestAttack();
-    boolean shiftTurn();
+
+    boolean updateTurn();
+
     boolean isATurn();
+
     boolean isALose();
+
     boolean isBLose();
 }
diff --git a/src/main/java/interfaces/IBotBehavior.java b/src/main/java/interfaces/IBotBehavior.java
index 7000961..d5e2afa 100644
--- a/src/main/java/interfaces/IBotBehavior.java
+++ b/src/main/java/interfaces/IBotBehavior.java
@@ -2,6 +2,8 @@
 
 public interface IBotBehavior {
     int selectAttacker(IAttack iAttack);
+
     int selectTarget(IAttack iAttack);
+
     int declareNumber(IAttack iAttack, int target);
 }
diff --git a/src/main/java/models/Algo.java b/src/main/java/models/Algo.java
deleted file mode 100644
index ad3aac8..0000000
--- a/src/main/java/models/Algo.java
+++ /dev/null
@@ -1,80 +0,0 @@
-package models;
-
-import java.util.*;
-
-import static views.Constants.DECK_COUNT;
-
-public class Algo {
-	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;
-	int turnCount=0;
-	public Algo() {
-		///モデル生成分
-		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);
-		//追加分
-		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));
-	}
-	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);
-	}
-	private void countUpTurn(){
-		turnCount++;
-	}
-	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<Map.Entry<Integer, Boolean>> 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/models/Algotest.java b/src/main/java/models/Algotest.java
deleted file mode 100644
index 9fd79ab..0000000
--- a/src/main/java/models/Algotest.java
+++ /dev/null
@@ -1,65 +0,0 @@
-package models;
-
-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/models/Deck.java b/src/main/java/models/Deck.java
deleted file mode 100644
index ef2441e..0000000
--- a/src/main/java/models/Deck.java
+++ /dev/null
@@ -1,33 +0,0 @@
-package models;
-
-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<>();
-	//added
-	public void reset(int num){
-		for(int i=0;i<num;i++){
-			this.value.add(new AbstractMap.SimpleEntry<>(i,false));
-		}
-		Collections.shuffle(this.value);
-	}
-	//added
-	public Map.Entry<Integer, Boolean> head(){
-		var card=getValue().get(0);
-		getValue().remove(getValue().get(0));
-		return card;
-	}
-	public List<Map.Entry<Integer, Boolean>>  getValue() {
-		return value;
-	}
-	public void updateSucceedDrawB(Map.Entry<Boolean, Integer> succeedDrawB) {
-		this.succeedDrawB = succeedDrawB;
-		value = this.value.subList(1, this.value.size());
-	}
-	public void updateSucceedDrawA(Map.Entry<Boolean, Integer> succeedDrawA) {
-		this.succeedDrawA = succeedDrawA;
-		value = this.value.subList(1, this.value.size());
-	}
-}
\ No newline at end of file
diff --git a/src/main/java/models/HandsA.java b/src/main/java/models/HandsA.java
deleted file mode 100644
index d7d8c46..0000000
--- a/src/main/java/models/HandsA.java
+++ /dev/null
@@ -1,70 +0,0 @@
-package models;
-
-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 LoseA loseA;
-	private List<Map.Entry<Integer, Boolean>> value = new ArrayList<Map.Entry<Integer, Boolean>>();
-	public HandsA(LoseA loseA) {
-		this.loseA = loseA;
-	}
-	public List<Map.Entry<Integer, Boolean>> 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()) {
-			temp_if3 = this.value;
-		} else {
-			this.value.set(succeedSelectA.getValue().getValue(),new AbstractMap.SimpleEntry<>(this.value.get(succeedSelectA.getValue().getValue()).getKey(), 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));
-			temp_if4 = this.value;
-		} else {
-			temp_if4 = this.value;
-		}
-		value = temp_if4;
-		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));
-			temp_if6 = this.value;
-		} else {
-			temp_if6 = this.value;
-		}
-		value = temp_if6;
-		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));
-			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));
-			temp_if7 = this.value;
-		}
-		value = temp_if7;
-		this.loseA.updateHandsA(value);
-	}
-}
\ No newline at end of file
diff --git a/src/main/java/models/HandsB.java b/src/main/java/models/HandsB.java
deleted file mode 100644
index c9e3f5f..0000000
--- a/src/main/java/models/HandsB.java
+++ /dev/null
@@ -1,69 +0,0 @@
-package models;
-
-import java.util.*;
-
-public class HandsB {
-	private Map.Entry<Boolean, Integer> succeedDrawB;
-	private Map.Entry<Boolean, Map.Entry<Integer, Integer>> succeedSelectA;
-	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>>();
-	public HandsB(LoseB loseB) {
-		this.loseB = loseB;
-	}
-	public List<Map.Entry<Integer, Boolean>> getValue() {
-		return value;
-	}
-	public void updateSucceedDrawB(Map.Entry<Boolean, Integer> succeedDrawB, List<Map.Entry<Integer, Boolean>> deck) {
-		this.succeedDrawB = succeedDrawB;
-		List<Map.Entry<Integer, Boolean>> 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));
-			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));
-			temp_if0 = this.value;
-		}
-		value = temp_if0;
-		this.loseB.updateHandsB(value);
-	}
-	public void updateSucceedSelectA(Map.Entry<Boolean, Map.Entry<Integer, Integer>> succeedSelectA) {
-		this.succeedSelectA = succeedSelectA;
-		List<Map.Entry<Integer, Boolean>> temp_if1;
-		if (succeedSelectA.getKey()) {
-			this.value.set(succeedSelectA.getValue().getKey(),new AbstractMap.SimpleEntry<>(this.value.get(succeedSelectA.getValue().getKey()).getKey(), true));
-			temp_if1 = this.value;
-		} else {
-			temp_if1 = this.value;
-		}
-		value = temp_if1;
-		this.loseB.updateHandsB(value);
-	}
-	public void updateSucceedDrawA(Map.Entry<Boolean, Integer> succeedDrawA, List deck) {
-		this.succeedDrawA = succeedDrawA;
-		List<Map.Entry<Integer, Boolean>> temp_if2;
-		if (succeedDrawA.getKey()) {
-			this.value.set(succeedDrawA.getValue(),new AbstractMap.SimpleEntry<>(this.value.get(succeedDrawA.getValue()).getKey(), true));
-			temp_if2 = this.value;
-		} else {
-			temp_if2 = this.value;
-		}
-		value = temp_if2;
-		this.loseB.updateHandsB(value);
-	}
-	public void updateSucceedSelectB(Map.Entry<Boolean, Map.Entry<Integer, Integer>> succeedSelectB) {
-		this.succeedSelectB = succeedSelectB;
-		List<Map.Entry<Integer, Boolean>> 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));
-			temp_if5 = this.value;
-		}
-		value = temp_if5;
-		this.loseB.updateHandsB(value);
-	}
-}
\ No newline at end of file
diff --git a/src/main/java/models/LoseA.java b/src/main/java/models/LoseA.java
deleted file mode 100644
index 0e6bc3f..0000000
--- a/src/main/java/models/LoseA.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package models;
-
-import java.util.*;
-import java.util.stream.Collectors;
-
-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 boolean getValue() {
-		return value;
-	}
-}
\ No newline at end of file
diff --git a/src/main/java/models/LoseB.java b/src/main/java/models/LoseB.java
deleted file mode 100644
index ae7a6fc..0000000
--- a/src/main/java/models/LoseB.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package models;
-
-import java.util.*;
-import java.util.stream.Collectors;
-
-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 boolean getValue() {
-		return value;
-	}
-}
\ No newline at end of file
diff --git a/src/main/java/models/SucceedDrawA.java b/src/main/java/models/SucceedDrawA.java
deleted file mode 100644
index 7596e8a..0000000
--- a/src/main/java/models/SucceedDrawA.java
+++ /dev/null
@@ -1,26 +0,0 @@
-package models;
-
-
-import java.util.*;
-
-public class SucceedDrawA {
-	private HandsB handsB;
-	private Deck deck;
-	private HandsA handsA;
-	private Map.Entry<Boolean, Integer> value;
-	public SucceedDrawA(HandsB handsB, Deck deck, HandsA handsA) {
-		this.handsB = handsB;
-		this.deck = deck;
-		this.handsA = handsA;
-	}
-	public void inputDrawA(int guess, int target) {
-		this.value = new AbstractMap.SimpleEntry<>((handsB.getValue().get(target).getKey()==guess), target);
-		List deck = this.deck.getValue();
-		this.handsA.updateSucceedDrawA(value, deck);
-		this.handsB.updateSucceedDrawA(value, deck);
-		this.deck.updateSucceedDrawA(value);
-	}
-	public Map.Entry<Boolean, Integer> getValue() {
-		return value;
-	}
-}
\ No newline at end of file
diff --git a/src/main/java/models/SucceedDrawB.java b/src/main/java/models/SucceedDrawB.java
deleted file mode 100644
index d18e819..0000000
--- a/src/main/java/models/SucceedDrawB.java
+++ /dev/null
@@ -1,26 +0,0 @@
-package models;
-
-import java.util.*;
-
-public class SucceedDrawB {
-	private Deck deck;
-	private HandsB handsB;
-	private HandsA handsA;
-	private Map.Entry<Boolean, Integer> value;
-	public SucceedDrawB(Deck deck, HandsB handsB, HandsA handsA) {
-		this.deck = deck;
-		this.handsB = handsB;
-		this.handsA = handsA;
-	}
-	public void inputDrawB(int guess, int target) {
-		this.value = new AbstractMap.SimpleEntry<>((handsA.getValue().get(target).getKey()==guess), target);
-
-		List deck = this.deck.getValue();
-		this.handsB.updateSucceedDrawB(value, deck);
-		this.handsA.updateSucceedDrawB(value, deck);
-		this.deck.updateSucceedDrawB(value);
-	}
-	public Map.Entry<Boolean, Integer> getValue() {
-		return value;
-	}
-}
\ No newline at end of file
diff --git a/src/main/java/models/SucceedSelectA.java b/src/main/java/models/SucceedSelectA.java
deleted file mode 100644
index 9ff49e3..0000000
--- a/src/main/java/models/SucceedSelectA.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package models;
-
-import java.util.*;
-
-public class SucceedSelectA {
-	private HandsB handsB;
-	private HandsA handsA;
-	private Map.Entry<Boolean, Map.Entry<Integer, Integer>> value;
-	public SucceedSelectA(HandsB handsB, HandsA handsA) {
-		this.handsB = handsB;
-		this.handsA = handsA;
-	}
-	public void inputSelectA(int guess, int attacker, int target) {
-		this.value = new AbstractMap.SimpleEntry<>((handsB.getValue().get(target).getKey()==guess), new AbstractMap.SimpleEntry<>(target,attacker));
-		this.handsA.updateSucceedSelectA(value);
-		this.handsB.updateSucceedSelectA(value);
-	}
-	public Map.Entry<Boolean, Map.Entry<Integer, Integer>> getValue() {
-		return value;
-	}
-}
\ No newline at end of file
diff --git a/src/main/java/models/SucceedSelectB.java b/src/main/java/models/SucceedSelectB.java
deleted file mode 100644
index 9cfbbc1..0000000
--- a/src/main/java/models/SucceedSelectB.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package models;
-
-import java.util.*;
-
-public class SucceedSelectB {
-	private HandsA handsA;
-	private HandsB handsB;
-	private Map.Entry<Boolean, Map.Entry<Integer, Integer>> value;
-	public SucceedSelectB(HandsA handsA, HandsB handsB) {
-		this.handsA = handsA;
-		this.handsB = handsB;
-	}
-	public void inputSelectB(int guess, int attacker, int target) {
-		this.value = new AbstractMap.SimpleEntry<>((handsA.getValue().get(target).getKey()==guess), new AbstractMap.SimpleEntry<>(target,attacker));
-		this.handsB.updateSucceedSelectB(value);
-		this.handsA.updateSucceedSelectB(value);
-	}
-	public Map.Entry<Boolean, Map.Entry<Integer, Integer>> getValue() {
-		return value;
-	}
-}
\ No newline at end of file
diff --git a/src/main/java/resources/Algo.java b/src/main/java/resources/Algo.java
new file mode 100644
index 0000000..4b7c627
--- /dev/null
+++ b/src/main/java/resources/Algo.java
@@ -0,0 +1,95 @@
+package resources;
+
+import java.util.*;
+
+import static views.Constants.DECK_COUNT;
+
+public class Algo {
+    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;
+    int turnCount = 0;
+
+    public Algo() {
+        ///モデル生成分
+        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);
+        //追加分
+        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));
+    }
+
+    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);
+    }
+
+    private void countUpTurn() {
+        turnCount++;
+    }
+
+    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<Map.Entry<Integer, Boolean>> 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/Algotest.java b/src/main/java/resources/Algotest.java
new file mode 100644
index 0000000..386cec3
--- /dev/null
+++ b/src/main/java/resources/Algotest.java
@@ -0,0 +1,79 @@
+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
new file mode 100644
index 0000000..4d80fb5
--- /dev/null
+++ b/src/main/java/resources/Deck.java
@@ -0,0 +1,38 @@
+package resources;
+
+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<>();
+
+    //added
+    public void reset(int num) {
+        for (int i = 0; i < num; i++) {
+            this.value.add(new AbstractMap.SimpleEntry<>(i, false));
+        }
+        Collections.shuffle(this.value);
+    }
+
+    //added
+    public Map.Entry<Integer, Boolean> head() {
+        var card = getValue().get(0);
+        getValue().remove(getValue().get(0));
+        return card;
+    }
+
+    public List<Map.Entry<Integer, Boolean>> getValue() {
+        return value;
+    }
+
+    public void updateSucceedDrawB(Map.Entry<Boolean, Integer> succeedDrawB) {
+        this.succeedDrawB = succeedDrawB;
+        value = this.value.subList(1, this.value.size());
+    }
+
+    public void updateSucceedDrawA(Map.Entry<Boolean, Integer> succeedDrawA) {
+        this.succeedDrawA = succeedDrawA;
+        value = this.value.subList(1, this.value.size());
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/resources/HandsA.java b/src/main/java/resources/HandsA.java
new file mode 100644
index 0000000..006b4fe
--- /dev/null
+++ b/src/main/java/resources/HandsA.java
@@ -0,0 +1,75 @@
+package resources;
+
+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 LoseA loseA;
+    private List<Map.Entry<Integer, Boolean>> value = new ArrayList<Map.Entry<Integer, Boolean>>();
+
+    public HandsA(LoseA loseA) {
+        this.loseA = loseA;
+    }
+
+    public List<Map.Entry<Integer, Boolean>> 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()) {
+            temp_if3 = this.value;
+        } else {
+            this.value.set(succeedSelectA.getValue().getValue(), new AbstractMap.SimpleEntry<>(this.value.get(succeedSelectA.getValue().getValue()).getKey(), 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));
+            temp_if4 = this.value;
+        } else {
+            temp_if4 = this.value;
+        }
+        value = temp_if4;
+        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));
+            temp_if6 = this.value;
+        } else {
+            temp_if6 = this.value;
+        }
+        value = temp_if6;
+        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));
+            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));
+            temp_if7 = this.value;
+        }
+        value = temp_if7;
+        this.loseA.updateHandsA(value);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/resources/HandsB.java b/src/main/java/resources/HandsB.java
new file mode 100644
index 0000000..957dceb
--- /dev/null
+++ b/src/main/java/resources/HandsB.java
@@ -0,0 +1,75 @@
+package resources;
+
+import java.util.*;
+
+public class HandsB {
+    private Map.Entry<Boolean, Integer> succeedDrawB;
+    private Map.Entry<Boolean, Map.Entry<Integer, Integer>> succeedSelectA;
+    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>>();
+
+    public HandsB(LoseB loseB) {
+        this.loseB = loseB;
+    }
+
+    public List<Map.Entry<Integer, Boolean>> getValue() {
+        return value;
+    }
+
+    public void updateSucceedDrawB(Map.Entry<Boolean, Integer> succeedDrawB, List<Map.Entry<Integer, Boolean>> deck) {
+        this.succeedDrawB = succeedDrawB;
+        List<Map.Entry<Integer, Boolean>> 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));
+            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));
+            temp_if0 = this.value;
+        }
+        value = temp_if0;
+        this.loseB.updateHandsB(value);
+    }
+
+    public void updateSucceedSelectA(Map.Entry<Boolean, Map.Entry<Integer, Integer>> succeedSelectA) {
+        this.succeedSelectA = succeedSelectA;
+        List<Map.Entry<Integer, Boolean>> temp_if1;
+        if (succeedSelectA.getKey()) {
+            this.value.set(succeedSelectA.getValue().getKey(), new AbstractMap.SimpleEntry<>(this.value.get(succeedSelectA.getValue().getKey()).getKey(), true));
+            temp_if1 = this.value;
+        } else {
+            temp_if1 = this.value;
+        }
+        value = temp_if1;
+        this.loseB.updateHandsB(value);
+    }
+
+    public void updateSucceedDrawA(Map.Entry<Boolean, Integer> succeedDrawA, List deck) {
+        this.succeedDrawA = succeedDrawA;
+        List<Map.Entry<Integer, Boolean>> temp_if2;
+        if (succeedDrawA.getKey()) {
+            this.value.set(succeedDrawA.getValue(), new AbstractMap.SimpleEntry<>(this.value.get(succeedDrawA.getValue()).getKey(), true));
+            temp_if2 = this.value;
+        } else {
+            temp_if2 = this.value;
+        }
+        value = temp_if2;
+        this.loseB.updateHandsB(value);
+    }
+
+    public void updateSucceedSelectB(Map.Entry<Boolean, Map.Entry<Integer, Integer>> succeedSelectB) {
+        this.succeedSelectB = succeedSelectB;
+        List<Map.Entry<Integer, Boolean>> 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));
+            temp_if5 = this.value;
+        }
+        value = temp_if5;
+        this.loseB.updateHandsB(value);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/resources/LoseA.java b/src/main/java/resources/LoseA.java
new file mode 100644
index 0000000..fe2e386
--- /dev/null
+++ b/src/main/java/resources/LoseA.java
@@ -0,0 +1,16 @@
+package resources;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+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 boolean getValue() {
+        return value;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/resources/LoseB.java b/src/main/java/resources/LoseB.java
new file mode 100644
index 0000000..e24a6cc
--- /dev/null
+++ b/src/main/java/resources/LoseB.java
@@ -0,0 +1,16 @@
+package resources;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+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 boolean getValue() {
+        return value;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/resources/SucceedDrawA.java b/src/main/java/resources/SucceedDrawA.java
new file mode 100644
index 0000000..376387c
--- /dev/null
+++ b/src/main/java/resources/SucceedDrawA.java
@@ -0,0 +1,29 @@
+package resources;
+
+
+import java.util.*;
+
+public class SucceedDrawA {
+    private HandsB handsB;
+    private Deck deck;
+    private HandsA handsA;
+    private Map.Entry<Boolean, Integer> value;
+
+    public SucceedDrawA(HandsB handsB, Deck deck, HandsA handsA) {
+        this.handsB = handsB;
+        this.deck = deck;
+        this.handsA = handsA;
+    }
+
+    public void inputDrawA(int guess, int target) {
+        this.value = new AbstractMap.SimpleEntry<>((handsB.getValue().get(target).getKey() == guess), target);
+        List deck = this.deck.getValue();
+        this.handsA.updateSucceedDrawA(value, deck);
+        this.handsB.updateSucceedDrawA(value, deck);
+        this.deck.updateSucceedDrawA(value);
+    }
+
+    public Map.Entry<Boolean, Integer> getValue() {
+        return value;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/resources/SucceedDrawB.java b/src/main/java/resources/SucceedDrawB.java
new file mode 100644
index 0000000..ff75bef
--- /dev/null
+++ b/src/main/java/resources/SucceedDrawB.java
@@ -0,0 +1,29 @@
+package resources;
+
+import java.util.*;
+
+public class SucceedDrawB {
+    private Deck deck;
+    private HandsB handsB;
+    private HandsA handsA;
+    private Map.Entry<Boolean, Integer> value;
+
+    public SucceedDrawB(Deck deck, HandsB handsB, HandsA handsA) {
+        this.deck = deck;
+        this.handsB = handsB;
+        this.handsA = handsA;
+    }
+
+    public void inputDrawB(int guess, int target) {
+        this.value = new AbstractMap.SimpleEntry<>((handsA.getValue().get(target).getKey() == guess), target);
+
+        List deck = this.deck.getValue();
+        this.handsB.updateSucceedDrawB(value, deck);
+        this.handsA.updateSucceedDrawB(value, deck);
+        this.deck.updateSucceedDrawB(value);
+    }
+
+    public Map.Entry<Boolean, Integer> getValue() {
+        return value;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/resources/SucceedSelectA.java b/src/main/java/resources/SucceedSelectA.java
new file mode 100644
index 0000000..fcb96a7
--- /dev/null
+++ b/src/main/java/resources/SucceedSelectA.java
@@ -0,0 +1,24 @@
+package resources;
+
+import java.util.*;
+
+public class SucceedSelectA {
+    private HandsB handsB;
+    private HandsA handsA;
+    private Map.Entry<Boolean, Map.Entry<Integer, Integer>> value;
+
+    public SucceedSelectA(HandsB handsB, HandsA handsA) {
+        this.handsB = handsB;
+        this.handsA = handsA;
+    }
+
+    public void inputSelectA(int guess, int attacker, int target) {
+        this.value = new AbstractMap.SimpleEntry<>((handsB.getValue().get(target).getKey() == guess), new AbstractMap.SimpleEntry<>(target, attacker));
+        this.handsA.updateSucceedSelectA(value);
+        this.handsB.updateSucceedSelectA(value);
+    }
+
+    public Map.Entry<Boolean, Map.Entry<Integer, Integer>> getValue() {
+        return value;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/resources/SucceedSelectB.java b/src/main/java/resources/SucceedSelectB.java
new file mode 100644
index 0000000..8cc154c
--- /dev/null
+++ b/src/main/java/resources/SucceedSelectB.java
@@ -0,0 +1,24 @@
+package resources;
+
+import java.util.*;
+
+public class SucceedSelectB {
+    private HandsA handsA;
+    private HandsB handsB;
+    private Map.Entry<Boolean, Map.Entry<Integer, Integer>> value;
+
+    public SucceedSelectB(HandsA handsA, HandsB handsB) {
+        this.handsA = handsA;
+        this.handsB = handsB;
+    }
+
+    public void inputSelectB(int guess, int attacker, int target) {
+        this.value = new AbstractMap.SimpleEntry<>((handsA.getValue().get(target).getKey() == guess), new AbstractMap.SimpleEntry<>(target, attacker));
+        this.handsB.updateSucceedSelectB(value);
+        this.handsA.updateSucceedSelectB(value);
+    }
+
+    public Map.Entry<Boolean, Map.Entry<Integer, Integer>> getValue() {
+        return value;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/views/CardButton.java b/src/main/java/views/CardButton.java
index 3aacc4e..10b5b49 100644
--- a/src/main/java/views/CardButton.java
+++ b/src/main/java/views/CardButton.java
@@ -10,39 +10,43 @@
 
 public class CardButton extends JButton {
     private Status status;
-    final int UNSELECTED_THICKNESS=1;
-    final int SELECTED_THICKNESS=4;
+    final int UNSELECTED_THICKNESS = 1;
+    final int SELECTED_THICKNESS = 4;
+
     public CardButton(String text) {
         this.setText(text);
         this.setBorder(new LineBorder(UNSELECTED_COLOR, UNSELECTED_THICKNESS, true));
         this.setPreferredSize(new Dimension(CARD_WIDTH, CARD_HEIGHT));
         this.setFont(new Font("ＭＳ ゴシック", Font.BOLD, 14));
     }
+
     //選択状態の切り替え
-    public void setEnabledSelection(boolean enabledSelection){
-       if(enabledSelection){
-           this.setBorder(new LineBorder(SELECTED_COLOR, SELECTED_THICKNESS,true));
-       }else {
-           this.setBorder(new LineBorder(UNSELECTED_COLOR, UNSELECTED_THICKNESS, true));
-       }
+    public void setEnabledSelection(boolean enabledSelection) {
+        if (enabledSelection) {
+            this.setBorder(new LineBorder(SELECTED_COLOR, SELECTED_THICKNESS, true));
+        } else {
+            this.setBorder(new LineBorder(UNSELECTED_COLOR, UNSELECTED_THICKNESS, true));
+        }
     }
-    public void setStatus(Status status){
-        switch (status){
-            case OPEN :
+
+    public void setStatus(Status status) {
+        switch (status) {
+            case OPEN:
                 this.setBackground(OPEN_COLOR);
                 this.setForeground(CLOSED_COLOR);
-            break;
-            case CLOSED :
+                break;
+            case CLOSED:
                 this.setBackground(CLOSED_COLOR);
                 this.setForeground(OPEN_COLOR);
-            break;
-            case MY_CLOSED :
+                break;
+            case MY_CLOSED:
                 this.setContentAreaFilled(false);
                 this.setFocusPainted(false); // used for demonstration
                 this.setForeground(OPEN_COLOR);
-            break;
+                break;
         }
     }
+
     @Override
     protected void paintComponent(Graphics g) {
         final Graphics2D g2 = (Graphics2D) g.create();
@@ -56,7 +60,8 @@
 
         super.paintComponent(g);
     }
-    public enum Status{
+
+    public enum Status {
         OPEN,       //開示されている
         CLOSED,     //開示されていない
         MY_CLOSED   //開示されていない(ただし自分専用)
diff --git a/src/main/java/views/Constants.java b/src/main/java/views/Constants.java
index 4d61b87..2c062bc 100644
--- a/src/main/java/views/Constants.java
+++ b/src/main/java/views/Constants.java
@@ -4,10 +4,11 @@
 import java.awt.*;
 
 public class Constants {
-    public static final int CARD_WIDTH=50;
-    public static final int CARD_HEIGHT=75;
+    public static final int CARD_WIDTH = 50;
+    public static final int CARD_HEIGHT = 75;
     public Step STEP;
-    public enum Step{
+
+    public enum Step {
         SelectMyHands,
         SelectOpponentHands,
         Declare,
@@ -17,14 +18,15 @@
         OpponentJudge,
         OpponentConfirm
     }
-    public static String CLOSED_SYMBOL="?";
-    public static int DECK_COUNT=11;
-    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(){
+
+    public static String CLOSED_SYMBOL = "?";
+    public static int DECK_COUNT = 11;
+    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/GamePanel.java b/src/main/java/views/GamePanel.java
index 1522187..49dc2d0 100644
--- a/src/main/java/views/GamePanel.java
+++ b/src/main/java/views/GamePanel.java
@@ -1,9 +1,8 @@
 package views;
 
-import models.Algo;
+import resources.Algo;
 
 import javax.swing.*;
-import java.util.ArrayList;
 import java.util.List;
 
 public class GamePanel extends JPanel {
@@ -12,15 +11,18 @@
     public GamePanel(Algo algo) {
 
     }
-    public void setSelectableButtons(Area area){
+
+    public void setSelectableButtons(Area area) {
 
     }
-    public enum Area{
+
+    public enum Area {
         HANDS_A,
         HANDS_B,
         DECK
     }
-    public enum Step{
+
+    public enum Step {
         PREPARATION,
         SELECTION,
         DECLARATION,
diff --git a/src/main/java/views/MainFrame.java b/src/main/java/views/MainFrame.java
index fdd34fa..d1f9c47 100644
--- a/src/main/java/views/MainFrame.java
+++ b/src/main/java/views/MainFrame.java
@@ -1,7 +1,6 @@
 package views;
 
 import controls.StepScheduler;
-import models.Algo;
 
 import javax.swing.*;
 import java.awt.*;
@@ -11,7 +10,7 @@
 public class MainFrame extends JFrame {
     StepScheduler stepScheduler;
 
-    public MainFrame(){
+    public MainFrame() {
         super("Algolike");
         stepScheduler = new StepScheduler();
         var mainPanel = new MainPanel(stepScheduler);
diff --git a/src/main/java/views/MainPanel.java b/src/main/java/views/MainPanel.java
index 02334f2..c075c5a 100644
--- a/src/main/java/views/MainPanel.java
+++ b/src/main/java/views/MainPanel.java
@@ -35,8 +35,8 @@
     int guess;
     int attacker;
     int target;
-    int indexForMyHands=0;
-    int indexForOpponent =0;
+    int indexForMyHands = 0;
+    int indexForOpponent = 0;
     private JPanel deckButtonPanel;
 
     public MainPanel(StepScheduler stepScheduler) {
@@ -61,9 +61,9 @@
         opponentPanel.add(opponentAttackerPanel);
         opponentPanel.add(opponentButtonsPanel);
 
-        if(!stepScheduler.isDeckLess()){        //デッキが存在する場合
-            var cardButton =new JButton("deck");
-            cardButton.setPreferredSize(new Dimension(CARD_HEIGHT,CARD_WIDTH));
+        if (!stepScheduler.isDeckLess()) {        //デッキが存在する場合
+            var cardButton = new JButton("deck");
+            cardButton.setPreferredSize(new Dimension(CARD_HEIGHT, CARD_WIDTH));
             deckButtonPanel.add(cardButton);
         }
         repaintField(stepScheduler);
@@ -71,74 +71,75 @@
          * setButton末尾にあった処理をコンストラクタ内へ。
          *
          */
-        add(deckButtonPanel,BorderLayout.WEST);
+        add(deckButtonPanel, BorderLayout.WEST);
         //add(myHandButtonsPanel, BorderLayout.SOUTH);
-        add(myPanel,BorderLayout.SOUTH);
+        add(myPanel, BorderLayout.SOUTH);
 
         //add(opponentButtonsPanel, BorderLayout.NORTH);
-        add(opponentPanel,BorderLayout.NORTH);
+        add(opponentPanel, BorderLayout.NORTH);
         opponentHandButtons.stream().filter(x -> x.getText().equals(CLOSED_SYMBOL)).forEach(x -> {
             x.setEnabled(true);
         });
         repaint();
     }
-    void botBehave(IAttack iAttack){
-        iAttack.shiftTurn();
+
+    void botBehave(IAttack iAttack) {
+        iAttack.updateTurn();
         var bot = new BotIntelligence();
 
-        JOptionPane.showMessageDialog(null,"Botのターンです。");
+        JOptionPane.showMessageDialog(null, "Botのターンです。");
         var selectText = "";
-        var atk =0;
-        if(!iAttack.isDeckLess()){ //デッキにカードが存在するとき
+        var atk = 0;
+        if (!iAttack.isDeckLess()) { //デッキにカードが存在するとき
             paintDrawCard(iAttack);//デッキから引いたカードを描画する
             selectText = "Botはカードをドローしました。";
-        }else{
-            atk= bot.selectAttacker(iAttack);
+        } else {
+            atk = bot.selectAttacker(iAttack);
             opponentHandButtons.get(atk).setEnabledSelection(true);
             selectText = "Botはアタックに使用するカードを選びました。";
         }
-        JOptionPane.showMessageDialog(null,selectText);
+        JOptionPane.showMessageDialog(null, selectText);
 
         var targetText = "";
         var tar = bot.selectTarget(iAttack);
         myHandButtons.get(tar).setEnabledSelection(true);
-        JOptionPane.showMessageDialog(null,"Botはこのカードを対象にしました。");
+        JOptionPane.showMessageDialog(null, "Botはこのカードを対象にしました。");
 
 
-        var dec =  bot.declareNumber(iAttack, tar);
-        JOptionPane.showMessageDialog(null,"Botは\""+ dec +"\"を宣言しました。");
+        var dec = bot.declareNumber(iAttack, tar);
+        JOptionPane.showMessageDialog(null, "Botは\"" + dec + "\"を宣言しました。");
 
-        iAttack.Attack(dec, atk, tar);
-        boolean isSucceed=iAttack.isSucceedLatestAttack();
+        iAttack.attack(dec, atk, tar);
+        boolean isSucceed = iAttack.isSucceedLatestAttack();
 
-        String resultMessage="Botのアタックは ";
-        resultMessage+=isSucceed?"成功しました。":"失敗しました。";
-        JOptionPane.showMessageDialog(null,resultMessage);
+        String resultMessage = "Botのアタックは ";
+        resultMessage += isSucceed ? "成功しました。" : "失敗しました。";
+        JOptionPane.showMessageDialog(null, resultMessage);
 
         myHandButtons.get(tar).setEnabledSelection(false);
         repaintField(iAttack);
-        if(isGameOver(iAttack)){
+        if (isGameOver(iAttack)) {
             finishGame(iAttack);
             return;
         }
-        iAttack.shiftTurn();
+        iAttack.updateTurn();
         playerBehave(iAttack);
     }
 
-    void paintDrawCard(IAttack iAttack){
-        var deckTopCard=iAttack.getTopCard();
+    void paintDrawCard(IAttack iAttack) {
+        var deckTopCard = iAttack.getTopCard();
 
-        if(!iAttack.isDeckLess()){    //デッキが存在する場合にデッキトップのカードを表示する処理
-            var cardButton =new CardButton(deckTopCard.getKey().toString());
-            cardButton.setBounds(0,100,CARD_WIDTH,CARD_HEIGHT);
-            if(iAttack.isATurn()){
+        if (!iAttack.isDeckLess()) {    //デッキが存在する場合にデッキトップのカードを表示する処理
+            var cardButton = new CardButton(deckTopCard.getKey().toString());
+            cardButton.setBounds(0, 100, CARD_WIDTH, CARD_HEIGHT);
+            if (iAttack.isATurn()) {
                 myHandAttackerPanel.add(cardButton);
-                isDecidedAttacker=true;
-            }else {
+                isDecidedAttacker = true;
+            } else {
                 cardButton.setText(CLOSED_SYMBOL);
                 opponentAttackerPanel.add(cardButton);
             }
-            if(iAttack.getDeckNumber()==1){
+            if (iAttack.getDeckNumber() == 1) {
                 deckButtonPanel.removeAll();
             }
         }
@@ -146,7 +147,8 @@
         validate();
         repaint();
     }
-    void repaintField(IAttack iAttack){
+
+    void repaintField(IAttack iAttack) {
 
         var myHands = iAttack.getMyHands();
         var opponentHands = iAttack.getOpponentHands();
@@ -154,7 +156,7 @@
         /**
          * 初期化処理(する必要があるのかどうかは知らない)
          */
-        isDecidedAttacker=false;
+        isDecidedAttacker = false;
         myHandButtonsPanel.removeAll();//
         myHandButtons.clear();
         myHandAttackerPanel.removeAll();
@@ -165,28 +167,28 @@
         /**
          * 自分の手札に関する処理
          */
-        indexForMyHands=0;
+        indexForMyHands = 0;
         for (var i : myHands) {
             var cardButton = new CardButton(i.getKey().toString());
-            cardButton.setStatus(i.getValue()? CardButton.Status.OPEN: CardButton.Status.MY_CLOSED);
+            cardButton.setStatus(i.getValue() ? CardButton.Status.OPEN : CardButton.Status.MY_CLOSED);
 
             myHandButtons.add(cardButton);
             //myHandButtonsPanel.add(cardButton, BorderLayout.WEST);
             myHandButtonsPanel.add(cardButton);
-            final var a=indexForMyHands;//actionPerformedの中に書くと、クリックされて初めて、回しきったindexForMyHandsを参照してしまうため、ここで一時変数に格納する
+            final var a = indexForMyHands;//actionPerformedの中に書くと、クリックされて初めて、回しきったindexForMyHandsを参照してしまうため、ここで一時変数に格納する
             cardButton.addActionListener(new ActionListener() {
                 @Override
                 public void actionPerformed(ActionEvent e) {
-                    if(!iAttack.isDeckLess())return;//デッキがあるときは何も反応しないように
-                    for(var my:myHandButtons)my.setEnabledSelection(false);
+                    if (!iAttack.isDeckLess()) return;//デッキがあるときは何も反応しないように
+                    for (var my : myHandButtons) my.setEnabledSelection(false);
                     cardButton.setEnabledSelection(true);
                     var option = JOptionPane.showConfirmDialog(null, "このカードを使ってアタックをしますか?", "confirmation", 2);
 
 
-                    if (option == JOptionPane.YES_OPTION){
-                        attacker=a;
-                        isDecidedAttacker=true;
-                    }else {
+                    if (option == JOptionPane.YES_OPTION) {
+                        attacker = a;
+                        isDecidedAttacker = true;
+                    } else {
                         cardButton.setEnabledSelection(false);
                     }
                 }
@@ -198,16 +200,17 @@
         /**
          *相手のカードに関する処理
          */
-        indexForOpponent=0;
+        indexForOpponent = 0;
         for (var i : opponentHands) {
-            var cardButton = new CardButton(i.getValue() ? i.getKey().toString() :CLOSED_SYMBOL);
-            cardButton.setStatus(i.getValue()? CardButton.Status.OPEN: CardButton.Status.CLOSED);
+            var cardButton = new CardButton(i.getValue() ? i.getKey().toString() : CLOSED_SYMBOL);
+            cardButton.setStatus(i.getValue() ? CardButton.Status.OPEN : CardButton.Status.CLOSED);
             cardButton.setEnabled(!i.getValue());
             cardButton.addActionListener(new ActionListener() {
-                final int index=indexForOpponent;
+                final int index = indexForOpponent;
+
                 public void actionPerformed(ActionEvent e) {
-                    if(!iAttack.isDeckLess())isDecidedAttacker=true;
-                    if(!isDecidedAttacker){
+                    if (!iAttack.isDeckLess()) isDecidedAttacker = true;
+                    if (!isDecidedAttacker) {
                         JOptionPane.showMessageDialog(null, "あなたの手札からアタックに使用するカードを選んでください. ", "Warn",
                                 JOptionPane.WARNING_MESSAGE);
                         return;
@@ -218,7 +221,7 @@
                     //相手のカードを選択したときに確認用ダイアログを出す
                     var option = JOptionPane.showConfirmDialog(null, "このカードを選びますか?", "confirmation", 2);
                     if (option == JOptionPane.YES_OPTION) {
-                        target = opponentHands.size()-index;//画面上,相手の手札も自分の手札と同じように左から右へ並べられているため,それを補正するために反転させている
+                        target = opponentHands.size() - index;//画面上,相手の手札も自分の手札と同じように左から右へ並べられているため,それを補正するために反転させている
                         var t = index;
                         opponentHandButtons.stream().filter(x -> x.getText().equals(CLOSED_SYMBOL)).forEach(x -> {
                             x.setEnabled(false);
@@ -233,31 +236,31 @@
                                 null,
                                 optionsToChoose,
                                 optionsToChoose[0]);
-                        if(getDeclaredNumber!=null) {   //数字を宣言して、承認したとき
+                        if (getDeclaredNumber != null) {   //数字を宣言して、承認したとき
                             guess = Integer.parseInt(getDeclaredNumber);
-                            var g= Integer.parseInt(getDeclaredNumber);
-                            iAttack.Attack(g, attacker, t);
+                            var g = Integer.parseInt(getDeclaredNumber);
+                            iAttack.attack(g, attacker, t);
 
-                            boolean isSucceed=iAttack.isSucceedLatestAttack();
+                            boolean isSucceed = iAttack.isSucceedLatestAttack();
 
-                            String resultMessage="あなたのアタックは";
-                            resultMessage+=isSucceed?"成功しました。":"失敗しました。";
-                            JOptionPane.showMessageDialog(null,resultMessage);
-                        }else{
+                            String resultMessage = "あなたのアタックは";
+                            resultMessage += isSucceed ? "成功しました。" : "失敗しました。";
+                            JOptionPane.showMessageDialog(null, resultMessage);
+                        } else {
                             opponentHandButtons.stream().filter(x -> x.getText().equals(CLOSED_SYMBOL)).forEach(x -> {
                                 x.setEnabled(true);
                             });
                             return;
                         }
 
-                    }else{
+                    } else {
                         cardButton.setEnabledSelection(false);
                         return;
                     }
-                    for(var my:myHandButtons)my.setEnabledSelection(false);
+                    for (var my : myHandButtons) my.setEnabledSelection(false);
                     cardButton.setEnabledSelection(false);
                     repaintField(iAttack);
-                    if(isGameOver(iAttack)){
+                    if (isGameOver(iAttack)) {
                         finishGame(iAttack);
                         return;
                     }
@@ -273,46 +276,48 @@
         repaint();
     }
 
-    public void playerBehave(IAttack iAttack){
-        isDecidedAttacker=false;
-        JOptionPane.showMessageDialog(null,"あなたのターンです。");
+    public void playerBehave(IAttack iAttack) {
+        isDecidedAttacker = false;
+        JOptionPane.showMessageDialog(null, "あなたのターンです。");
         var selectText = "";
-        var atk =0;
-        if(!iAttack.isDeckLess()){ //デッキにカードが存在するとき
-            selectText = "あなたは数字\""+ iAttack.getTopCard().getKey()+"\"のカードをドローしました。";
-        }else{
+        var atk = 0;
+        if (!iAttack.isDeckLess()) { //デッキにカードが存在するとき
+            selectText = "あなたは数字\"" + iAttack.getTopCard().getKey() + "\"のカードをドローしました。";
+        } else {
             selectText = "アタックに使用するカードを手札から選んでください。";
         }
         paintDrawCard(iAttack);
 
-        JOptionPane.showMessageDialog(null,selectText);
+        JOptionPane.showMessageDialog(null, selectText);
 
-        if(!iAttack.isDeckLess())JOptionPane.showMessageDialog(null,"アタックする対象を相手の手札から選んでください。");
+        if (!iAttack.isDeckLess()) JOptionPane.showMessageDialog(null, "アタックする対象を相手の手札から選んでください。");
 
     }
 
     /**
      * ゲームが終了しているか
+     *
      * @param iAttack
      */
-    boolean isGameOver(IAttack iAttack){
+    boolean isGameOver(IAttack iAttack) {
 
-        if(iAttack.isALose()){
+        if (iAttack.isALose()) {
             return true;
-        }else if(iAttack.isBLose()){
+        } else if (iAttack.isBLose()) {
             return true;
         }
 
         return false;
     }
-    void finishGame(IAttack iAttack){
+
+    void finishGame(IAttack iAttack) {
         var myHands = iAttack.getMyHands();
         var opponentHands = iAttack.getOpponentHands();
 
         /**
          * 初期化処理(する必要があるのかどうかは知らない)
          */
-        isDecidedAttacker=false;
+        isDecidedAttacker = false;
         myHandButtonsPanel.removeAll();//
         myHandButtons.clear();
         opponentButtonsPanel.removeAll();//
@@ -320,14 +325,14 @@
         /**
          * 自分の手札に関する処理
          */
-        indexForMyHands=0;
+        indexForMyHands = 0;
         for (var i : myHands) {
             var cardButton = new CardButton(i.getKey().toString());
-            cardButton.setStatus(i.getValue()? CardButton.Status.OPEN: CardButton.Status.MY_CLOSED);
+            cardButton.setStatus(i.getValue() ? CardButton.Status.OPEN : CardButton.Status.MY_CLOSED);
             myHandButtons.add(cardButton);
             myHandButtonsPanel.add(cardButton, BorderLayout.WEST);
 
-            final var a=indexForMyHands;//actionPerformedの中に書くと、クリックされて初めて、回しきったindexForMyHandsを参照してしまうため、ここで一時変数に格納する
+            final var a = indexForMyHands;//actionPerformedの中に書くと、クリックされて初めて、回しきったindexForMyHandsを参照してしまうため、ここで一時変数に格納する
             indexForMyHands++;
         }
         //ここまでが自分のカードに関する処理
@@ -335,10 +340,10 @@
         /**
          *相手のカードに関する処理
          */
-        indexForOpponent=0;
+        indexForOpponent = 0;
         for (var i : opponentHands) {
-            var cardButton = new CardButton(i.getValue() ? i.getKey().toString() :CLOSED_SYMBOL);
-            cardButton.setStatus(i.getValue()? CardButton.Status.OPEN: CardButton.Status.CLOSED);
+            var 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);
             opponentButtonsPanel.add(cardButton, 0);//見た目の順序が逆になるように,0番目に挿入
@@ -347,10 +352,10 @@
         //ここまでが相手のカードに関する処理
         validate();
         repaint();
-        if(iAttack.isALose()){
-            JOptionPane.showMessageDialog(null,"Botが勝利しました。");
-        }else if(iAttack.isBLose()){
-            JOptionPane.showMessageDialog(null,"あなたが勝利しました。");
+        if (iAttack.isALose()) {
+            JOptionPane.showMessageDialog(null, "Botが勝利しました。");
+        } else if (iAttack.isBLose()) {
+            JOptionPane.showMessageDialog(null, "あなたが勝利しました。");
         }
 
     }
diff --git a/src/test/java/AlgoTest.java b/src/test/java/AlgoTest.java
index 3fdcc61..636248d 100644
--- a/src/test/java/AlgoTest.java
+++ b/src/test/java/AlgoTest.java
@@ -1,4 +1,4 @@
-import models.Algo;
+import resources.Algo;
 import org.junit.jupiter.api.Test;
 
 import java.util.AbstractMap;
@@ -14,6 +14,7 @@
         printAlgoState(algo);
         assertEquals(2, algo.getHandsA().size());
         assertEquals(2, algo.getHandsB().size());
+
     }
 
     @Test