Index: maps/80x60.map
==================================================================
--- maps/80x60.map
+++ maps/80x60.map
@@ -35,48 +35,57 @@
 #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\!\.\..*.*.*.*.*.*.*.*.*.*#
 #.\.\.\.\.\.\.\.\W\.\.\.\.\.\.\.\.\.\.\*!*.*.*.*.*.*.*.*.*.#
 #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
 #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
 #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.A*!*.*.*.*.*.*.*.*.*.#
+#\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.B*!*.*.*.*.*.*.*.*.*.#
+#\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.C*!*.*.*.*.*.*.*.*.*.#
 #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.D*!*.*.*.*.*.*.*.*.*.#
 #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.E*!*.*.*.*.*.*.*.*.*.#
 #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.F*!*.*.*.*.*.*.*.*.*.#
 #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.G*!*.*.*.*.*.*.*.*.*.#
 #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.H*!*.*.*.*.*.*.*.*.*.#
 #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.I*!*.*.*.*.*.*.*.*.*.#
 #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
-#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
+#.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.1*!*.*.*.*.*.*.*.*.*.#
 ############################################################
 
 Flooding 80
+Trampoline A targets 1
+Trampoline B targets 1
+Trampoline C targets 1
+Trampoline D targets 1
+Trampoline E targets 1
+Trampoline F targets 1
+Trampoline G targets 1
+Trampoline H targets 1
+Trampoline I targets 1

Index: src/game.d
==================================================================
--- src/game.d
+++ src/game.d
@@ -120,11 +120,10 @@
 	Pos robot;
 	Pos lift;
 	int waterproof;
 	Pos[char] tr_target;
 	Pos[][char] tr_source;
-	const(Hige) hige;
 	int razor;
 	int collected_lambda;
 	int total_lambda;
 	bool cleared;
 	Pos[] may_update;
@@ -136,11 +135,10 @@
 		this.robot = m.robot.clone();
 		this.lift = m.lift.clone();
 		this.waterproof = m.waterproof;
 		this.tr_target = cast(Pos[char])m.tr_target;
 		this.tr_source = cast(Pos[][char])m.tr_source;
-		this.hige = m.hige.clone();
 		this.razor = m.razor;
 		this.collected_lambda = m.collected_lambda;
 		this.total_lambda = m.total_lambda;
 		this.may_update = (cast(Map)m).may_update.dup;
 		this.cleared = m.cleared;
@@ -182,11 +180,10 @@
 			tr_target[fr] = tr_pos[to];
 			if(to !in tr_source) tr_source[to] = [];
 			tr_source[to] ~= tr_pos[fr];
 		}
 
-		this.hige = Hige.load(params);
 		this.razor = params.get("Razors", "0").to!int();
 	}
 
 	const @property {
 		int H() { return data.length; }
@@ -236,20 +233,20 @@
 	Pos[] lambdas() const { return objects('\\'); }
 
 	bool command(char c, int turn, bool hige_day)
 	{
 		assert( this[robot] == 'R' );
-		if(c=='R') return move( 0, +1, turn, hige_day);
-		if(c=='L') return move( 0, -1, turn, hige_day);
-		if(c=='U') return move(+1,  0, turn, hige_day);
-		if(c=='D') return move(-1,  0, turn, hige_day);
-		if(c=='W') return move( 0,  0, turn, hige_day);
-		if(c=='S') return use_razor(turn, hige_day);
+		if(c=='R') return move( 0, +1, hige_day);
+		if(c=='L') return move( 0, -1, hige_day);
+		if(c=='U') return move(+1,  0, hige_day);
+		if(c=='D') return move(-1,  0, hige_day);
+		if(c=='W') return move( 0,  0, hige_day);
+		if(c=='S') return use_razor(hige_day);
 		assert(false);
 	}
 
-	bool use_razor(int turn, bool hige_day)
+	bool use_razor(bool hige_day)
 	{
 		if(razor) {
 			razor--;
 			for(int dy=-1; dy<=+1; ++dy)
 			for(int dx=-1; dx<=+1; ++dx)
@@ -257,11 +254,11 @@
 					emptified(new Pos(robot.y+dy,robot.x+dx));
 					this[robot.y+dy,robot.x+dx] = ' ';
 				}
 		}
 
-		return update(turn, hige_day);
+		return update(hige_day);
 	}
 
 	bool rocky(char c) { return c=='*' || c=='@'; }
 
 		void emptified(Pos p) {
@@ -268,13 +265,12 @@
 			for(int dy=0; dy<=+1; ++dy)
 			for(int dx=-1; dx<=+1; ++dx)
 				may_update ~= new Pos(p.y+dy, p.x+dx);
 		}
 
-	bool move(int dy, int dx, int turn, bool hige_day)
+	bool move(int dy, int dx, bool hige_day)
 	{
-
 		emptified(robot);
 
 		int y = robot.y;
 		int x = robot.x;
 		if( '\\' == this[y+dy,x+dx] )
@@ -301,14 +297,14 @@
 				this[p] = ' ';
 			}
 			this[tp] = 'R';
 			robot = tp;
 		}
-		return update(turn, hige_day);
+		return update(hige_day);
 	}
 
-	bool update(int turn, bool hige_day)
+	bool update(bool hige_day)
 	{
 		// Write after all the updates are processed.
 		Tuple!(int,int,char)[] write_buffer;
 		void write(int y, int x, char c) { write_buffer ~= tuple(y,x,c); }
 		void writep(Pos p, char c) { write_buffer ~= tuple(0+p.y,0+p.x,c); }
@@ -326,10 +322,17 @@
 		if(collected_lambda == total_lambda)
 			if(this[lift]=='L')
 				this[lift] = 'O';
 
 		bool dead = false;
+		if( hige_day ) {
+			for(int y=1; y<=H; ++y)
+			for(int x=1; x<=W; ++x)
+				if(this[y,x]=='W')
+					may_update ~= new Pos(y,x);
+		}
+
 		sort(may_update);
 		foreach(p; may_update) {
 			int y = p.y, x = p.x;
 			char rock = this[p];
 			if(rocky(this[p])) {
@@ -350,21 +353,17 @@
 					writep(p.L.D, (rock=='@'&&this[p.L.D.D]!=' ' ? '\\' : rock));
 					if(robot == p.L.D.D)
 						dead=true;
 				}
 			}
-		}
-
-		if( hige_day )
-		for(int y=1; y<=H; ++y)
-		for(int x=1; x<=W; ++x) {
-			Pos p = new Pos(y,x);
-			if(this[p]=='W') {
+			else if(this[p]=='W') {
+				if(hige_day) {
 					for(int dy=-1; dy<=+1; ++dy)
 					for(int dx=-1; dx<=+1; ++dx)
 						if(this[p.y+dy,p.x+dx] == ' ')
 							write(p.y+dy,p.x+dx,'W');
+				}
 			}
 		}
 
 		return dead;
 	}
@@ -395,16 +394,18 @@
 				trampo[ss[1][0]] = ss[3][0];
 		}
 
 		this.map   = new Map(raw_data, params, trampo);
 		this.water = Water.load(params);
+		this.hige  = Hige.load(params);
 	}
 
 	Game clone() const { return new Game(this); }
 	this(in Game g) {
 		map   = g.map.clone();
 		water = g.water.clone();
+		hige  = g.hige.clone();
 		turn  = g.turn;
 		dead  = g.dead;
 		under_water = g.under_water;
 	}
 
@@ -413,11 +414,11 @@
 		assert(c != 'A');
 		if(dead || cleared)
 			return;
 
 		// TODO: clarify the event order
-		bool dead_now = map.command(c, turn, map.hige.is_growing_turn(turn));
+		bool dead_now = map.command(c, turn, hige.is_growing_turn(turn));
 		if( dead_now )
 			dead = true;
 		if(!map.cleared) {
 			if( map.robot.y <= water_level )
 				++under_water;
@@ -429,10 +430,11 @@
 		turn += 1;
 	}
 
 	Map map;
 	Water water;
+	Hige hige;
 	int  turn = 0;
 	bool dead = false;
 	int  under_water = 0;
 	// TODO: when adding members, take care of clone().
 	// TODO: fix this poor design.
@@ -439,9 +441,9 @@
 
 @property const:
 	long score()           { return map.collected_lambda*(dead?25L:cleared?75L:50L)-turn; }
 	int water_level()      { return water.level(turn); }
 	int water_until_rise() { return water.until_rise(turn); }
-	int hige_until_rise()  { return map.hige.until_rise(turn); }
+	int hige_until_rise()  { return hige.until_rise(turn); }
 	int hp()               { return map.waterproof - under_water; }
 	bool cleared()         { return map.cleared; }
 }

Index: src/solver.d
==================================================================
--- src/solver.d
+++ src/solver.d
@@ -387,8 +387,8 @@
 		else
 			plan = plan[1..$];
 	}
 }
 
-alias Solver_2!(Solver_1) MainSolver;
-//alias Solver_1 MainSolver;
+//alias Solver_2!(Solver_1) MainSolver;
+alias Solver_1 MainSolver;
 //alias Solver_0 MainSolver;