diff --git a/src/main/java/controls/StepScheduler.java b/src/main/java/controls/StepScheduler.java
index eee1ccc..cef3b56 100644
--- a/src/main/java/controls/StepScheduler.java
+++ b/src/main/java/controls/StepScheduler.java
@@ -21,19 +21,19 @@
     public void attack(int guess, int attacker, int target) {
         if (isATurn) {
             if (isDeckLess()) {
-                algo.inputSelectA(guess, attacker, target);
-                isSucceedLatestAttack = algo.getSucceedSelectA().getKey();
+                algo.selectAndAttackA(attacker, target, guess);
+                isSucceedLatestAttack = algo.getResultBySelectingA().getKey();
             } else {
-                algo.inputDrawA(guess, target);
-                isSucceedLatestAttack = algo.getSucceedDrawA().getKey();
+                algo.drawAndAttackA(target, guess);
+                isSucceedLatestAttack = algo.getResultByDrawingA().getKey();
             }
         } else {
             if (isDeckLess()) {
-                algo.inputSelectB(guess, attacker, target);
-                isSucceedLatestAttack = algo.getSucceedSelectB().getKey();
+                algo.selectAndAttackB(attacker, target, guess);
+                isSucceedLatestAttack = algo.getResultBySelectingB().getKey();
             } else {
-                algo.inputDrawB(guess, target);
-                isSucceedLatestAttack = algo.getSucceedDrawB().getKey();
+                algo.drawAndAttackB(target, guess);
+                isSucceedLatestAttack = algo.getResultByDrawingB().getKey();
             }
         }
         turnCount++;
diff --git a/src/main/java/controls/TurnBot.java b/src/main/java/controls/TurnBot.java
index 31bbf8e..2288124 100644
--- a/src/main/java/controls/TurnBot.java
+++ b/src/main/java/controls/TurnBot.java
@@ -10,11 +10,11 @@
     @Override
     public void attack(int guess, int attacker, int target) {
         if (isDeckLess()) {
-            algo.inputSelectB(guess, attacker, target);
-            isSucceedLatestAttack = algo.getSucceedSelectB().getKey();
+            algo.selectAndAttackB(attacker, target, guess);
+            isSucceedLatestAttack = algo.getResultBySelectingB().getKey();
         } else {
-            algo.inputDrawB(guess, target);
-            isSucceedLatestAttack = algo.getSucceedDrawB().getKey();
+            algo.drawAndAttackB(target, guess);
+            isSucceedLatestAttack = algo.getResultByDrawingB().getKey();
         }
     }
 }
diff --git a/src/main/java/controls/TurnPlayer.java b/src/main/java/controls/TurnPlayer.java
index f157c4c..6f8bc31 100644
--- a/src/main/java/controls/TurnPlayer.java
+++ b/src/main/java/controls/TurnPlayer.java
@@ -10,11 +10,11 @@
     @Override
     public void attack(int guess, int attacker, int target) {
         if (isDeckLess()) {
-            algo.inputSelectA(guess, attacker, target);
-            isSucceedLatestAttack = algo.getSucceedSelectA().getKey();
+            algo.selectAndAttackA(attacker, target, guess);
+            isSucceedLatestAttack = algo.getResultBySelectingA().getKey();
         } else {
-            algo.inputDrawA(guess, target);
-            isSucceedLatestAttack = algo.getSucceedDrawA().getKey();
+            algo.drawAndAttackA(target, guess);
+            isSucceedLatestAttack = algo.getResultByDrawingA().getKey();
         }
     }
 }
diff --git a/src/main/java/resources/Algo.java b/src/main/java/resources/Algo.java
index 8d371e0..f5e9ec3 100644
--- a/src/main/java/resources/Algo.java
+++ b/src/main/java/resources/Algo.java
@@ -13,10 +13,10 @@
     private LoseA loseA;
     private HandsA handsA;
     private Deck deck;
-    private SucceedDrawA succeedDrawA;
-    private SucceedDrawB succeedDrawB;
-    private SucceedSelectA succeedSelectA;
-    private SucceedSelectB succeedSelectB;
+    private ResultByDrawingA resultByDrawingA;
+    private ResultByDrawingB resultByDrawingB;
+    private ResultBySelectingA resultBySelectingA;
+    private ResultBySelectingB resultBySelectingB;
     int turnCount = 0;
     boolean isATurn;
 
@@ -27,48 +27,52 @@
         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);
+        resultByDrawingA = new ResultByDrawingA(handsB, deck, handsA);
+        resultByDrawingB = new ResultByDrawingB(deck, handsB, handsA);
+        resultBySelectingA = new ResultBySelectingA(handsB, handsA);
+        resultBySelectingB = new ResultBySelectingB(handsA, handsB);
         //追加分
         isATurn = true;
         deck.init(DECK_COUNT);
 
     }
 
-    public void inputSelectA(int guess, int attacker, int target) {
-        this.succeedSelectA.inputSelectA(guess, attacker, target);
+    public void drawAndAttackA(int target, int guess) {
+        this.resultByDrawingA.drawAndAttackA(target, guess);
     }
 
-    public void inputDrawA(int guess, int target) {
-        this.succeedDrawA.inputDrawA(guess, target);
+    public void selectAndAttackA(int attacker, int target, int guess) {
+        this.resultBySelectingA.selectAndAttackA(attacker, target, guess);
     }
 
-    public void inputDrawB(int guess, int target) {
-        this.succeedDrawB.inputDrawB(guess, target);
+    public void drawAndAttackB(int target, int guess) {
+        this.resultByDrawingB.drawAndAttackB(target, guess);
     }
 
-    public void inputSelectB(int guess, int attacker, int target) {
-        this.succeedSelectB.inputSelectB(guess, attacker, target);
+    public void selectAndAttackB(int attacker, int target, int guess) {
+        this.resultBySelectingB.selectAndAttackB(attacker, target, guess);
     }
 
-    public Map.Entry<Boolean, Map.Entry<Integer, Integer>> getSucceedSelectB() {
-        return succeedSelectB.getValue();
+    public Map.Entry<Boolean, Integer> getResultByDrawingA() {
+        return resultByDrawingA.getValue();
     }
 
-    public Map.Entry<Boolean, Map.Entry<Integer, Integer>> getSucceedSelectA() {
-        return succeedSelectA.getValue();
+    public Map.Entry<Boolean, Integer> getResultByDrawingB() {
+        return resultByDrawingB.getValue();
+    }
+
+    public Map.Entry<Boolean, Map.Entry<Integer, Integer>> getResultBySelectingA() {
+        return resultBySelectingA.getValue();
+    }
+
+    public Map.Entry<Boolean, Map.Entry<Integer, Integer>> getResultBySelectingB() {
+        return resultBySelectingB.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();
     }
@@ -77,18 +81,16 @@
         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();
+    public List<Map.Entry<Integer, Boolean>> getHandsB() {
+        return handsB.getValue();
     }
 
+
+
     //追加分
     /**
      * 各プレイヤーに手札を配るメソッド
diff --git a/src/main/java/resources/ResultByDrawingA.java b/src/main/java/resources/ResultByDrawingA.java
new file mode 100644
index 0000000..1977bd8
--- /dev/null
+++ b/src/main/java/resources/ResultByDrawingA.java
@@ -0,0 +1,31 @@
+package resources;
+
+
+import java.util.AbstractMap;
+import java.util.List;
+import java.util.Map;
+
+public class ResultByDrawingA {
+    private HandsB handsB;
+    private Deck deck;
+    private HandsA handsA;
+    private Map.Entry<Boolean, Integer> value;
+
+    public ResultByDrawingA(HandsB handsB, Deck deck, HandsA handsA) {
+        this.handsB = handsB;
+        this.deck = deck;
+        this.handsA = handsA;
+    }
+
+    public void drawAndAttackA(int target, int guess) {
+        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/ResultByDrawingB.java b/src/main/java/resources/ResultByDrawingB.java
new file mode 100644
index 0000000..3fcbc91
--- /dev/null
+++ b/src/main/java/resources/ResultByDrawingB.java
@@ -0,0 +1,31 @@
+package resources;
+
+import java.util.AbstractMap;
+import java.util.List;
+import java.util.Map;
+
+public class ResultByDrawingB {
+    private Deck deck;
+    private HandsB handsB;
+    private HandsA handsA;
+    private Map.Entry<Boolean, Integer> value;
+
+    public ResultByDrawingB(Deck deck, HandsB handsB, HandsA handsA) {
+        this.deck = deck;
+        this.handsB = handsB;
+        this.handsA = handsA;
+    }
+
+    public void drawAndAttackB(int target, int guess) {
+        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/ResultBySelectingA.java b/src/main/java/resources/ResultBySelectingA.java
new file mode 100644
index 0000000..bed0714
--- /dev/null
+++ b/src/main/java/resources/ResultBySelectingA.java
@@ -0,0 +1,25 @@
+package resources;
+
+import java.util.AbstractMap;
+import java.util.Map;
+
+public class ResultBySelectingA {
+    private HandsB handsB;
+    private HandsA handsA;
+    private Map.Entry<Boolean, Map.Entry<Integer, Integer>> value;
+
+    public ResultBySelectingA(HandsB handsB, HandsA handsA) {
+        this.handsB = handsB;
+        this.handsA = handsA;
+    }
+
+    public void selectAndAttackA(int attacker, int target, int guess) {
+        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/ResultBySelectingB.java b/src/main/java/resources/ResultBySelectingB.java
new file mode 100644
index 0000000..36adb18
--- /dev/null
+++ b/src/main/java/resources/ResultBySelectingB.java
@@ -0,0 +1,25 @@
+package resources;
+
+import java.util.AbstractMap;
+import java.util.Map;
+
+public class ResultBySelectingB {
+    private HandsA handsA;
+    private HandsB handsB;
+    private Map.Entry<Boolean, Map.Entry<Integer, Integer>> value;
+
+    public ResultBySelectingB(HandsA handsA, HandsB handsB) {
+        this.handsA = handsA;
+        this.handsB = handsB;
+    }
+
+    public void selectAndAttackB(int attacker, int target, int guess) {
+        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/SucceedDrawA.java b/src/main/java/resources/SucceedDrawA.java
deleted file mode 100644
index d817ebc..0000000
--- a/src/main/java/resources/SucceedDrawA.java
+++ /dev/null
@@ -1,31 +0,0 @@
-package resources;
-
-
-import java.util.AbstractMap;
-import java.util.List;
-import java.util.Map;
-
-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
deleted file mode 100644
index 09bda57..0000000
--- a/src/main/java/resources/SucceedDrawB.java
+++ /dev/null
@@ -1,31 +0,0 @@
-package resources;
-
-import java.util.AbstractMap;
-import java.util.List;
-import java.util.Map;
-
-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
deleted file mode 100644
index b14c24d..0000000
--- a/src/main/java/resources/SucceedSelectA.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package resources;
-
-import java.util.AbstractMap;
-import java.util.Map;
-
-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
deleted file mode 100644
index 827721e..0000000
--- a/src/main/java/resources/SucceedSelectB.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package resources;
-
-import java.util.AbstractMap;
-import java.util.Map;
-
-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/test/java/AlgoTest.java b/src/test/java/AlgoTest.java
index 66619a0..b3d2aea 100644
--- a/src/test/java/AlgoTest.java
+++ b/src/test/java/AlgoTest.java
@@ -1,8 +1,6 @@
 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;
@@ -42,7 +40,7 @@
         var target = 0;
         //テスト対象メソッド
         //algo.drawA(guess, target);
-        algo.inputDrawA(guess,target);
+        algo.drawAndAttackA(target, guess);
 
         printAlgoState(algo);
         //Aはデッキから引いているので,実行前と比べて枚数が1枚増えているか
@@ -69,7 +67,7 @@
         var top = algo.getDeck().get(0);
         //テスト対象メソッド
      //   algo.drawA(guess, target);
-        algo.inputDrawA(guess, target);
+        algo.drawAndAttackA(target, guess);
         printAlgoState(algo);
         //Aはデッキから引いているので,実行前と比べて枚数が1枚増えている
 
@@ -97,7 +95,7 @@
         var target = 0;
         //テスト対象メソッド
      //   algo.drawB(guess, target);
-        algo.inputDrawB(guess, target);
+        algo.drawAndAttackB(target, guess);
         printAlgoState(algo);
         //Aはデッキから引いているので,実行前と比べて枚数が1枚増えているか
         assertEquals(iniHandsBNum+1,algo.getHandsB().size());
@@ -122,7 +120,7 @@
 
         //テスト対象メソッド
         //algo.selectA(guess, attacker, target);
-        algo.inputSelectA(guess, attacker, target);
+        algo.selectAndAttackA(attacker, target, guess);
         printAlgoState(algo);
         //Aによってアタックを成功されたBのカードが表になっているか
         assertEquals(true, algo.getHandsB().get(target).getValue());
@@ -144,7 +142,7 @@
         var guess = algo.getHandsB().get(target).getKey()+1;
         //テスト対象メソッド
        // algo.selectA(guess, attacker, target);
-        algo.inputSelectA(guess, attacker, target);
+        algo.selectAndAttackA(attacker, target, guess);
         printAlgoState(algo);
         //Aによってアタックを成功されたBのカードが表になっていないか
         assertEquals(false, algo.getHandsB().get(target).getValue());
@@ -174,12 +172,12 @@
         //Aはカードを1枚引き,アタックを成功させる.
         //Bはアタックされたカードを表にする.
 
-        algo.inputDrawA(guess, target);
+        algo.drawAndAttackA(target, guess);
         printViewA(algo);
 
         //Bはカードを1枚引き,アタックが失敗する.
         //Bはアタックに使用したカードを表にする.
-        algo.inputDrawB(guess,target);
+        algo.drawAndAttackB(target, guess);
         printViewA(algo);
 
         int tar=0, gue=0;
@@ -193,7 +191,7 @@
         //Aはカードを1枚引き,アタックを成功させる.
         //Bは全てのカードが表になるので,ゲームが終了する
 
-        algo.inputDrawA(gue, tar);
+        algo.drawAndAttackA(tar, gue);
         printViewA(algo);
     }
     
diff --git a/src/test/java/MainTest.java b/src/test/java/MainTest.java
index c9da560..4d6d42e 100644
--- a/src/test/java/MainTest.java
+++ b/src/test/java/MainTest.java
@@ -13,46 +13,46 @@
         printAlgoState(algo);
 
         //Aはカードを1枚引き、Bの0番目のカードに対して「1」を宣言する。
-        algo.inputDrawA(3, 0);
+        algo.drawAndAttackA(0, 3);
 
         //アタックは失敗する。
-        assertEquals(false, algo.getSucceedDrawA().getKey());
+        assertEquals(false, algo.getResultByDrawingA().getKey());
 
         assertEquals(false, algo.getLoseA());
         assertEquals(false, algo.getLoseB());
 
         //Bはカードを1枚引き、Aの2番目のカードに対して「2」を宣言する。
-        algo.inputDrawB(2,2);
+        algo.drawAndAttackB(2, 2);
 
         //アタックは失敗する。
-        assertEquals(false, algo.getSucceedDrawB().getKey());
+        assertEquals(false, algo.getResultByDrawingB().getKey());
 
         assertEquals(false, algo.getLoseA());
         assertEquals(false, algo.getLoseB());
 
         //Aはカードを1枚引き、Bの1番目のカードに対して「3」を宣言する。
-        algo.inputDrawA(3, 1);
+        algo.drawAndAttackA(1, 3);
 
         //アタックは成功する。
-        assertEquals(true, algo.getSucceedDrawA().getKey());
+        assertEquals(true, algo.getResultByDrawingA().getKey());
 
         assertEquals(false, algo.getLoseA());
         assertEquals(false, algo.getLoseB());
 
         //Bはカードを1枚引き、Aの0番目のカードに対して「2」を宣言する。
-        algo.inputDrawB(2,0);
+        algo.drawAndAttackB(0, 2);
 
         //アタックは失敗する。
-        assertEquals(false, algo.getSucceedDrawB().getKey());
+        assertEquals(false, algo.getResultByDrawingB().getKey());
 
         assertEquals(false, algo.getLoseA());
         assertEquals(false, algo.getLoseB());
 
         //Aは手札の0番目のカードアタックに使用し、Bの0番目のカードに対して「1」を宣言する。
-        algo.inputSelectA(1, 0, 0);
+        algo.selectAndAttackA(0, 0, 1);
 
         //アタックは成功する。
-        assertEquals(true, algo.getSucceedSelectA().getKey());
+        assertEquals(true, algo.getResultBySelectingA().getKey());
 
         //Bの手札が全て表になったので、Bは敗北する。
         assertEquals(false, algo.getLoseA());
diff --git a/src/test/java/controls/BotIntelligenceTest.java b/src/test/java/controls/BotIntelligenceTest.java
index 81f11b2..72b8957 100644
--- a/src/test/java/controls/BotIntelligenceTest.java
+++ b/src/test/java/controls/BotIntelligenceTest.java
@@ -42,7 +42,7 @@
         var target = 1;
         //テスト対象メソッド
 
-        algo.inputDrawA(guess,target);
+        algo.drawAndAttackA(target, guess);
 
         stepScheduler.isATurn = false;
         printAlgoState(algo);