Index: src/solver.d
==================================================================
--- src/solver.d
+++ src/solver.d
@@ -144,10 +144,12 @@
 
 		if(c == 'W')
 			wait_count++;
 		else
 			wait_count = 0;
+		if(wait_count==2)
+			c = 'A';
 		if(choke_count >= g.map.H)
 			c = 'A';
 
 		bool[char] choice;
 		foreach(t; cand)
@@ -313,90 +315,125 @@
 	}
 }
 
 class Solver_2(SubSolver) : Solver
 {
+	static const PredictFuture = 10;
+
+	Game      current_game;
+	SubSolver sub_solver;
+
+	enum {Tentative, Tentative_Stuck, Fixed};
 	string plan;
-	bool plan_broken = true;
+	int    plan_state;
 
-	Game g;
 	this(in Game g)
 	{
-		this.g = g.clone();
-		make_plan(g);
+		current_game = g.clone();
+		plan         = "";
+		plan_state   = Tentative;
+	}
+
+	char single_step()
+	{
+		if(current_game.dead || current_game.cleared)
+			return 'A';
+
+		// Make enough prediction.
+		while( plan_state==Tentative && plan.length<PredictFuture )
+			single_step_predict();
+
+		// If the future is bad, correct.
+		if( plan_state==Tentative_Stuck && plan.length<PredictFuture )
+			replan();
+
+		// Follow the predicted plan.
+		if( plan.empty )
+			return 'A';
+writeln(plan, " ", plan_state);
+		char c = plan[0];
+		plan = plan[1..$];
+		current_game.command(c);
+		return c;
 	}
 
-	Tuple!(SubSolver,string) run_sub_solver(in Game g)
+	void force(char c)
 	{
-		string log;
-		auto s = new SubSolver(g);
-		while(!g.cleared && !g.dead && plan.length<=g.map.H*g.map.W) {
-			char c = s.single_step();
-			if( c == 'A' )
-				break;
-			log ~= c;
+		if(plan.length>0 && plan[0]==c)
+		{
+			// If matching the plan, just go forward.
+			plan = plan[1..$];
+		}
+		else
+		{
+			// Discard the plan, otherwise.
+			plan_state = Tentative;
+			plan       = "";
+			sub_solver = null;
 		}
-		while(log.length>0 && log[$-1]=='W')
-			log.length--;
-		return tuple(s, log);
+		current_game.command(c);
 	}
 
-	void make_plan(in Game g) {
-		plan_broken = false;
-		Tuple!(SubSolver,string) x = run_sub_solver(g);
-		plan = x[1];
-		if(x[0].g.cleared)
-			return;
-		modify_plan(g, x[0].g.score);
+	void single_step_predict()
+	{
+		if(sub_solver is null) {
+			sub_solver = new SubSolver(current_game);
+			plan       = "";
+		}
+
+		char c = sub_solver.single_step();
+		if(c == 'A')
+			plan_state = Tentative_Stuck;
+		else {
+			plan ~= c;
+			plan_state = (sub_solver.g.dead ? Tentative_Stuck :
+			              sub_solver.g.cleared ? Fixed : Tentative);
+		}
 	}
 
-	void modify_plan(in Game ini, long unmod)
+	void replan()
 	{
-		int bp = max(0, (cast(int)plan.length)-10);
-		Game g = ini.clone();
-		for(int i=0; i<bp; ++i) g.command(plan[i]);
-
-		Tuple!(string,long) cand = tuple(plan, unmod);
-		for(int i=bp; i<plan.length; ++i) {
-			foreach(string c; ["U","D","L","R","UD","DU","LR","RL"])
-				if(c[0] != plan[i]) {
-					Tuple!(string,long) zz = try_plan(c, g);
-					if(cand[1]<zz[1])
-						cand = tuple(plan[0..i]~c~zz[0], zz[1]);
+writeln("replan!");
+		// Try to replace every step of the plan by another move.
+		Game g = current_game.clone();
+		Tuple!(long, SubSolver, string, int) cand =
+			tuple(sub_solver.g.score, sub_solver, plan, Tentative_Stuck);
+		for(int i=0; i<plan.length; ++i) {
+			foreach(string prefix; ["U","D","L","R","UD","DU","LR","RL"])
+				if(prefix[0] != plan[i]) {
+					Tuple!(long, SubSolver, string, int) r = try_plan(g, prefix);
+					if(cand[0] < r[0]) {
+						r[2] = plan[0..i] ~ prefix ~ r[2];
+						cand = r;
+					}
 				}
 			g.command(plan[i]);
 		}
-		plan = cand[0];
-	}
 
-	Tuple!(string,long) try_plan(string c, in Game g)
-	{
-		Game gg = g.clone();
-		foreach(cc;c)gg.command(cc);
-		Tuple!(SubSolver, string) x = run_sub_solver(gg);
-		return tuple(x[1], x[0].g.score);
+		sub_solver = cand[1];
+		plan       = cand[2];
+		plan_state = (plan.length < PredictFuture ? Fixed : cand[3]);
 	}
 
-	char single_step() {
-		if(plan_broken)
-			make_plan(g);
-		if(plan.empty)
-			return 'A';
-		char c = plan[0];
-		plan = plan[1..$];
-		g.command(c);
-		return c;
-	}
-
-	void force(char c) {
-		g.command(c);
-		if(plan.length==0 || plan[0]!=c) {
-			plan = "";
-			plan_broken = true;
+	Tuple!(long, SubSolver, string, int) try_plan(in Game g, string prefix)
+	{
+		SubSolver s = new SubSolver(g);
+		foreach(char c; prefix)
+			s.force(c);
+		string log;
+		int state = Tentative;
+		while(!s.g.cleared && !s.g.dead && log.length<=g.map.H*g.map.W) {
+			char c = s.single_step();
+			if( c == 'A' ) {
+				state = Tentative_Stuck;
+				break;
+			}
+			log ~= c;
 		}
-		else
-			plan = plan[1..$];
+		if(s.g.cleared) state = Fixed;
+		else if(s.g.dead) state = Tentative_Stuck;
+		return tuple(s.g.score, s, log, state);
 	}
 }
 
 class MasterSolver : Solver
 {
@@ -414,9 +451,9 @@
 	private Solver sub;
 	char single_step() { return sub.single_step(); }
 	void force(char c) { sub.force(c); }
 }
 
-alias MasterSolver MainSolver;
-//alias Solver_2!(Solver_1) MainSolver;
+//alias MasterSolver MainSolver;
+alias Solver_2!(Solver_1) MainSolver;
 //alias Solver_1 MainSolver;
 //alias Solver_0 MainSolver;