diff --git a/src/main/java/controls/StepScheduler.java b/src/main/java/controls/StepScheduler.java
index 4be28e0..19ed6e5 100644
--- a/src/main/java/controls/StepScheduler.java
+++ b/src/main/java/controls/StepScheduler.java
@@ -24,15 +24,16 @@
     public void Attack(int guess, int attacker, int target) {
         if(isATurn){
             if(isDeckLess()){
-                algo.selectA(guess, attacker, target);
+                algo.inputSelectA(guess, attacker, target);
+
             }else{
-                algo.drawA(guess, target);
+                algo.inputDrawA(guess, target);
             }
         }else {
             if(isDeckLess()){
-                algo.selectB(guess, attacker, target);
+                algo.inputSelectB(guess, attacker, target);
             }else{
-                algo.drawB(guess, target);
+                algo.inputDrawB(guess, target);
             }
         }
         turnCount++;
diff --git a/src/main/java/models/Algo.java b/src/main/java/models/Algo.java
index 996140c..ad3aac8 100644
--- a/src/main/java/models/Algo.java
+++ b/src/main/java/models/Algo.java
@@ -10,13 +10,23 @@
 	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());
@@ -25,37 +35,33 @@
 		getHandsA().sort(Comparator.comparing(Map.Entry<Integer, Boolean>::getKey));
 		getHandsB().sort(Comparator.comparing(Map.Entry<Integer, Boolean>::getKey));
 	}
-	public void drawA(int guess,  int target) {
-		var b=getHandsB();
-		var d = getDeck();
-		this.handsA.drawA(guess, b, d, target);
-		this.handsB.drawA(guess, b, d, target);
-		this.deck.drawA(guess, b, d, target);
+	public void inputSelectA(int guess, int attacker,  int target) {
+		this.succeedSelectA.inputSelectA(guess, attacker, target);
 	}
-	public void selectA(int guess, int attacker, int target) {
-		var b=getHandsB();
-		this.handsA.selectA(guess, attacker, b, target);
-		this.handsB.selectA(guess, attacker, b, target);
+	public void inputDrawA(int guess, int target) {
+		this.succeedDrawA.inputDrawA(guess, target);
 	}
-	public void drawB(int guess,  int target) {
-		var a=getHandsA();
-		var d = getDeck();
-
-		this.handsB.drawB(guess, a, d, target);
-		this.handsA.drawB(guess, a, d, target);
-		this.deck.drawB(guess, a, d, target);
+	public void inputDrawB(int guess, int target) {
+		this.succeedDrawB.inputDrawB(guess,  target);
 	}
-	public void selectB(int guess, int attacker, int target) {
-		var a=getHandsA();
-		this.handsB.selectB(guess, attacker, a, target);
-		this.handsA.selectB(guess, attacker, a, 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();
 	}
@@ -68,4 +74,7 @@
 	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
new file mode 100644
index 0000000..9fd79ab
--- /dev/null
+++ b/src/main/java/models/Algotest.java
@@ -0,0 +1,65 @@
+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
index 5aa6f48..ef2441e 100644
--- a/src/main/java/models/Deck.java
+++ b/src/main/java/models/Deck.java
@@ -3,14 +3,9 @@
 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<>();
-	public void drawB(int guess, List<Map.Entry<Integer, Boolean>> a, List<Map.Entry<Integer, Boolean>>  d, int target) {
-		this.value = this.value.subList(1, this.value.size());
-	}
-
-	public void drawA(int guess, List<Map.Entry<Integer, Boolean>> b, List<Map.Entry<Integer, Boolean>>  d, int target) {
-		this.value = this.value.subList(1, this.value.size());
-	}
 	//added
 	public void reset(int num){
 		for(int i=0;i<num;i++){
@@ -27,4 +22,12 @@
 	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
index 63a1ea2..f3f62d9 100644
--- a/src/main/java/models/HandsA.java
+++ b/src/main/java/models/HandsA.java
@@ -3,60 +3,68 @@
 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 void selectA(int guess, int attacker, List<Map.Entry<Integer, Boolean>> b, int target) {
-		List<Map.Entry<Integer, Boolean>> temp_if6;
-		if ((b.get(target).getKey()==guess)) {
-			temp_if6 = this.value;
-		} else {
-			this.value.set(attacker,new AbstractMap.SimpleEntry<>(this.value.get(attacker).getKey(), true));
-			temp_if6 = this.value;
-		}
-		this.value = temp_if6;
-		this.loseA.updateHandsA(value);
-	}
-	public void drawB(int guess, List<Map.Entry<Integer, Boolean>> a, List<Map.Entry<Integer, Boolean>> d, int target) {
-		List<Map.Entry<Integer, Boolean>> temp_if5;
-		if ((this.value.get(target).getKey()==guess)) {
-			this.value.set(target,new AbstractMap.SimpleEntry<>(this.value.get(target).getKey(), true));
-			temp_if5 = this.value;
-		} else {
-			temp_if5 = this.value;
-		}
-		this.value = temp_if5;
-		this.loseA.updateHandsA(value);
-	}
-
-	public void drawA(int guess, List<Map.Entry<Integer, Boolean>> b, List<Map.Entry<Integer, Boolean>> d, int target) {
-		List<Map.Entry<Integer, Boolean>> temp_if7;
-		if ((b.get(target).getKey()==guess)) {
-			this.value.add(0, new AbstractMap.SimpleEntry<>(d.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<>(d.get(0).getKey(), true));
-			this.value.sort(Comparator.comparing(Map.Entry<Integer, Boolean>::getKey));
-			temp_if7 = this.value;
-		}
-		this.value = temp_if7;
-		this.loseA.updateHandsA(value);
-	}
-	public void selectB(int guess, int attacker, List<Map.Entry<Integer, Boolean>> a, int target) {
-		List<Map.Entry<Integer, Boolean>> temp_if4;
-		if ((this.value.get(target).getKey()==guess)) {
-			this.value.set(target,new AbstractMap.SimpleEntry<>(this.value.get(target).getKey(), true));
-			temp_if4 = this.value;
-		} else {
-			temp_if4 = this.value;
-		}
-		this.value = temp_if4;
-		this.loseA.updateHandsA(value);
-	}
 	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().getKey(),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
index 04a9649..0593382 100644
--- a/src/main/java/models/HandsB.java
+++ b/src/main/java/models/HandsB.java
@@ -3,61 +3,67 @@
 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 void selectA(int guess, int attacker, List<Map.Entry<Integer, Boolean>> b, int target) {
-		List<Map.Entry<Integer, Boolean>> temp_if2;
-		if ((this.value.get(target).getKey()==guess)) {
-			this.value.set(target,new AbstractMap.SimpleEntry<>(this.value.get(target).getKey(), true));
-			temp_if2 = this.value;
-		} else {
-			temp_if2 = this.value;
-		}
-		this.value = temp_if2;
-		this.loseB.updateHandsB(value);
-	}
-
-	public void drawB(int guess, List<Map.Entry<Integer, Boolean>> a, List<Map.Entry<Integer, Boolean>>  d, int target) {
-		List<Map.Entry<Integer, Boolean>> temp_if1;
-		if ((a.get(target).getKey()==guess)) {
-			this.value.add(0, new AbstractMap.SimpleEntry<>(d.get(0).getKey(), false));
-			this.value.sort(Comparator.comparing(Map.Entry<Integer, Boolean>::getKey));
-			temp_if1 = this.value;
-		} else {
-			this.value.add(0, new AbstractMap.SimpleEntry<>(d.get(0).getKey(), true));
-			this.value.sort(Comparator.comparing(Map.Entry<Integer, Boolean>::getKey));
-			temp_if1 = this.value;
-		}
-		this.value = temp_if1;
-		this.loseB.updateHandsB(value);
-	}
-	public void drawA(int guess, List<Map.Entry<Integer, Boolean>> b, List<Map.Entry<Integer, Boolean>> d, int target) {
-		List<Map.Entry<Integer, Boolean>> temp_if3;
-		if ((this.value.get(target).getKey()==guess)) {
-			this.value.set(target,new AbstractMap.SimpleEntry<>(this.value.get(target).getKey(), true));
-			temp_if3 = this.value;
-		} else {
-			temp_if3 = this.value;
-		}
-		this.value = temp_if3;
-		this.loseB.updateHandsB(value);
-	}
-
-	public void selectB(int guess, int attacker, List<Map.Entry<Integer, Boolean>> a, int target) {
-		List<Map.Entry<Integer, Boolean>> temp_if0;
-		if ((a.get(target).getKey()==guess)) {
-			temp_if0 = this.value;
-		} else {
-			this.value.set(attacker,new AbstractMap.SimpleEntry<>(this.value.get(attacker).getKey(), true));
-			temp_if0 = this.value;
-		}
-		this.value = temp_if0;
-		this.loseB.updateHandsB(value);
-	}
 	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().getKey(),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/SucceedDrawA.java b/src/main/java/models/SucceedDrawA.java
new file mode 100644
index 0000000..7596e8a
--- /dev/null
+++ b/src/main/java/models/SucceedDrawA.java
@@ -0,0 +1,26 @@
+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
new file mode 100644
index 0000000..d18e819
--- /dev/null
+++ b/src/main/java/models/SucceedDrawB.java
@@ -0,0 +1,26 @@
+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
new file mode 100644
index 0000000..9ff49e3
--- /dev/null
+++ b/src/main/java/models/SucceedSelectA.java
@@ -0,0 +1,21 @@
+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
new file mode 100644
index 0000000..9cfbbc1
--- /dev/null
+++ b/src/main/java/models/SucceedSelectB.java
@@ -0,0 +1,21 @@
+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/test/java/AlgoTest.java b/src/test/java/AlgoTest.java
index b0a8783..7d6c2c2 100644
--- a/src/test/java/AlgoTest.java
+++ b/src/test/java/AlgoTest.java
@@ -25,7 +25,8 @@
         var guess = algo.getHandsB().get(0).getKey();
         var target = 0;
         //テスト対象メソッド
-        algo.drawA(guess, target);
+        //algo.drawA(guess, target);
+        algo.inputDrawA(guess,target);
 
         printState(algo);
         //Aはデッキから引いているので,実行前と比べて枚数が1枚増えているか
@@ -47,8 +48,8 @@
         var target = 0;
         var top = algo.getDeck().get(0);
         //テスト対象メソッド
-        algo.drawA(guess, target);
-
+     //   algo.drawA(guess, target);
+        algo.inputDrawA(guess, target);
         printState(algo);
         //Aはデッキから引いているので,実行前と比べて枚数が1枚増えている
 
@@ -71,8 +72,8 @@
         var guess = algo.getHandsA().get(0).getKey();
         var target = 0;
         //テスト対象メソッド
-        algo.drawB(guess, target);
-
+     //   algo.drawB(guess, target);
+        algo.inputDrawB(guess, target);
         printState(algo);
         //Aはデッキから引いているので,実行前と比べて枚数が1枚増えているか
         assertEquals(iniHandsBNum+1,algo.getHandsB().size());
@@ -92,8 +93,8 @@
         var attacker = 0;
 
         //テスト対象メソッド
-        algo.selectA(guess, attacker, target);
-
+        //algo.selectA(guess, attacker, target);
+        algo.inputSelectA(guess, attacker, target);
         printState(algo);
         //Aによってアタックを成功されたBのカードが表になっているか
         assertEquals(true, algo.getHandsB().get(target).getValue());
@@ -110,8 +111,8 @@
         var attacker = 0;
         var guess = algo.getHandsB().get(target).getKey()+1;
         //テスト対象メソッド
-        algo.selectA(guess, attacker, target);
-
+       // algo.selectA(guess, attacker, target);
+        algo.inputSelectA(guess, attacker, target);
         printState(algo);
         //Aによってアタックを成功されたBのカードが表になっていないか
         assertEquals(false, algo.getHandsB().get(target).getValue());
@@ -129,12 +130,13 @@
         printViewA(algo);
         //Aはカードを1枚引き,アタックを成功させる.
         //Bはアタックされたカードを表にする.
-        algo.drawA(guess, target);
+
+        algo.inputDrawA(guess, target);
         printViewA(algo);
 
         //Bはカードを1枚引き,アタックが失敗する.
         //Bはアタックに使用したカードを表にする.
-        algo.drawB(guess,target);
+        algo.inputDrawB(guess,target);
         printViewA(algo);
 
         int tar=0, gue=0;
@@ -147,10 +149,12 @@
         }
         //Aはカードを1枚引き,アタックを成功させる.
         //Bは全てのカードが表になるので,ゲームが終了する
-        algo.drawA(gue, tar);
+
+        algo.inputDrawA(gue, tar);
         printViewA(algo);
     }
 
+
     void printState(Algo algo){
         String s="";
         s+="deck:\n";