diff --git a/src/CheckersAI.java b/src/CheckersAI.java
index e728930..f761434 100644
--- a/src/CheckersAI.java
+++ b/src/CheckersAI.java
@@ -9,9 +9,31 @@ public CheckersAI(Evaluator e, int player){
         this.player = player;
     }
 
-    public Move minimax(CheckersGameState s, int ply){
+    private boolean stop(CheckersGameState state, boolean jumped, int depth){
+        CheckersGameState3 s = (CheckersGameState3) state;
+        if(!s.canJump() && !jumped && !s.canExchange() && depth == 3){
+           return true;
+        }
+        else if(!s.canJump() && !s.canExchange() && depth == 4){
+            return true;
+        }
+        else if(depth < 11 && !s.canJump()){
+            return true;
+        }
+        else if(depth < 20 && s.twoKings()){
+            return true;
+        }
+        else if(depth >=  20){
+            return true;
+        }
+        else{
+            return false;
+        }
+    }
+
+    public Move minimax(CheckersGameState s){
         int depth = 0;
-        if(s.isTerminal() || depth == ply){
+        if(s.isTerminal()){
             return null;
         }
         double alpha = Double.NEGATIVE_INFINITY;
@@ -21,7 +43,7 @@ public Move minimax(CheckersGameState s, int ply){
         Move max = null;
         // System.out.println(s.actions().size());
         for(Move a: s.actions()){
-            check = minValue(s.result(a), alpha, beta, ply, depth + 1);
+            check = minValue(s.result(a), alpha, beta, depth + 1, a.isJump());
             if(check > v){
                 v = check;
                 max = a;
@@ -34,15 +56,15 @@ public Move minimax(CheckersGameState s, int ply){
         return max;
     }
 
-   private double maxValue(CheckersGameState s, double alpha, double beta, int ply, int depth){
+   private double maxValue(CheckersGameState s, double alpha, double beta, int depth, boolean jumped){
 
-        if(s.isTerminal() || depth == ply){
+        if(s.isTerminal() || stop(s, jumped, depth)){
          return eval.evaluate(s, this.player); // if terminal, piece ratio should be infinite
         }
         double v = Double.NEGATIVE_INFINITY;
         double check;
         for(Move a: s.actions()){
-            check = minValue(s.result(a), alpha, beta, ply, depth + 1);
+            check = minValue(s.result(a), alpha, beta, depth + 1, a.isJump());
             if(check > v){
                 v = check;
             }
@@ -54,15 +76,15 @@ private double maxValue(CheckersGameState s, double alpha, double beta, int ply,
         return v;
     }
 
-   private double minValue(CheckersGameState s, double alpha, double beta, int ply, int depth){
+   private double minValue(CheckersGameState s, double alpha, double beta, int depth, boolean jumped){
 
-       if(s.isTerminal() || depth == ply){
+       if(s.isTerminal() || stop(s, jumped, depth)){
            return eval.evaluate(s, this.player);
         }
        double v = Double.POSITIVE_INFINITY;
        double check;
        for(Move a: s.actions()){
-           check = maxValue(s.result(a), alpha, beta, ply, depth + 1);
+           check = maxValue(s.result(a), alpha, beta, depth + 1, a.isJump());
            if(check < v){
                v = check;
             }
diff --git a/src/CheckersGameState3.java b/src/CheckersGameState3.java
index f078075..6593464 100644
--- a/src/CheckersGameState3.java
+++ b/src/CheckersGameState3.java
@@ -5,10 +5,13 @@ public class CheckersGameState3 implements CheckersGameState{
 
     int player;
     int[] board;
+    List<Move> actions;
 
     public CheckersGameState3(int player, int[] board){
         this.player = player;
         this.board = board;
+        //System.out.println(this.moves());
+        this.actions = this.moves();
     }
 
     public CheckersGameState3() {
@@ -23,14 +26,53 @@ public CheckersGameState3() {
         2,2,2,2,
         2,2,2,2
       };
+      this.actions = this.moves();
     }
 
     public CheckersGameState3(int player, String[] board){
         this.player = player;
         this.board = to_array(board);
+        this.actions = this.moves();
     }
 
-    public int convert(String s){
+
+    boolean canJump(){
+        //System.out.println(this.moves);
+        return this.actions.get(0).isJump();
+    }
+
+    boolean canExchange(){
+        if(canJump()){
+            for(Move m: this.actions){
+                if(m.captures().length == 1){
+                    for(Move n: this.result(m).actions()){
+                        if(n.captures().length == 1){
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+        return false;
+    }
+
+    boolean twoKings(){
+        int bkings = 0;
+        int wkings = 0;
+        for(int i = 0; i < board.length; i++){
+            if(board[i] == 3){
+                bkings++;
+            }
+            else if(board[i] == 4){
+                wkings++;
+            }
+        }
+        return Math.abs(bkings - wkings) >= 2;
+    }
+
+
+        public int convert(String s){
         if(s.equals("-")){
             return 0;
         }
@@ -144,6 +186,11 @@ private boolean any_jumps(int orig, int delta1, int delta2, int[] board, boolean
     }
 
     public List<Move> actions(){
+        return this.actions;
+    }
+
+
+    public List<Move> moves(){
         LinkedList<Move> moves = new LinkedList<Move>();
         LinkedList<Move> jumps = new LinkedList<Move>();
         for(int i = 0; i < this.board.length; i++){
@@ -166,6 +213,8 @@ public List<Move> actions(){
                 }
             }
         }
+        //System.out.println(jumps);
+        //System.out.println(moves);
         if(jumps.isEmpty()){
             return moves;
         }
@@ -285,8 +334,8 @@ public double pieceRatio(int player){
      double mypieces = 0.0;
      for(int i = 0; i<this.board.length; i++){
        if(i%9!=8){
-         if(this.board[i] != 0 )    total+=1.0;
          if(myPiece(this.board[i], player)) mypieces+=1.0;
+         else if(this.board[i] != 0 )    total+=1.0;
        }
      }
      //System.out.println("" + mypieces);
@@ -295,7 +344,7 @@ public double pieceRatio(int player){
 
    public boolean isTerminal(){
        double rat = pieceRatio(this.player);
-       return (rat == 0 || rat == 1);
+       return (rat == 0 || rat == Double.POSITIVE_INFINITY);
     }
 
    public void printState(){
diff --git a/src/Move.java b/src/Move.java
index 6f0e41b..fc1add5 100644
--- a/src/Move.java
+++ b/src/Move.java
@@ -7,4 +7,7 @@ public interface Move {
   // Returns the string representation of a move
   public String toString();
 
+  boolean isJump();
+
+
 }
diff --git a/src/Move3.java b/src/Move3.java
index 5c89bd3..b769fa1 100644
--- a/src/Move3.java
+++ b/src/Move3.java
@@ -37,6 +37,10 @@ public int[] captures(){
         return kills;
     }
 
+    public boolean isJump(){
+        return this.kills != null;
+    }
+
 //    private String convert(int pos){
 //        int x;
 //        int y;
diff --git a/src/RmCheckersClient.java b/src/RmCheckersClient.java
index 8c5d77c..5842136 100644
--- a/src/RmCheckersClient.java
+++ b/src/RmCheckersClient.java
@@ -144,7 +144,8 @@ else if(player == 2) { // white
         readAndEcho(); // move query
       }
       while(currentState.actions().size()>0){
-        Move myMove = ai.minimax(currentState, 8);
+        currentState.printState();
+        Move myMove = ai.minimax(currentState);
         writeMessageAndEcho(myMove.toString());
         if(!applyMove(myMove.toString())) {
           System.out.println("couldn't apply my move");