@@ -236,9 +236,9 @@
 			if(this[y,x] == 'L' || this[y,x] == 'O')
 				return false;
 		return true;
 	}
-	
+
 	Tuple!(int,bool) command(char c, int turn)
 	{
 		assert( this[robot] == 'R' );
 		if(c=='R') return move( 0, +1, turn);
@@ -349,9 +349,9 @@
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-
+/*
 class Game
 {
 	mixin DeriveShow;
 
@@ -443,4 +443,377 @@
 		int hige_until_rise() { return map.hige.until_rise(turn); }
 		int hp() { return map.waterproof - under_water; }
 	}
 }
+*/
+
+////////////////////////////////////////////////////////////////////////////////
+
+class Game
+{
+public:
+	this(File input)
+	{
+		// Read map data
+		string[] map_data_lines;
+		for(string line; !(line=input.readln().chomp()).empty; )
+			map_data_lines ~= line;
+
+		// H*W
+		H_ = map_data_lines.length;
+		W_ = 0;
+		foreach(mdl; map_data_lines)
+			W_ = max(W_, mdl.length);
+
+		// Copy to modifiable buffer and adjust coordinates.
+		raw_data_ = new char[][H_+1];
+		foreach(i,mdl; map_data_lines) {
+			char[] buf = new char[mdl.length+1];
+			buf[0] = '#';
+			buf[1..$] = mdl[];
+			raw_data_[H_-i] = buf;
+		}
+
+		// Detect objects
+		for(int y=1; y<=H_; ++y)
+		for(int x=1; x<raw_data_[y].length; ++x)
+		{
+			char c = raw_data_[y][x];
+			switch(c)
+			{
+			case '#':
+			case '.':
+			case ' ':
+				break;
+			case 'L':
+			case 'O':
+				lift_pos_ = new Pos(y,x);
+				break;
+			case 'A': .. case 'I':
+			case '1': .. case '9':
+				trampoline_pos_[c] = new Pos(y,x);
+				break;
+			case '!':
+				razor_pos_ ~= new Pos(y,x);
+				break;
+			case '\\':
+				lambda_pos_ ~= new Pos(y,x);
+				break;
+
+			// Moving objects are erased from raw_data_
+			case 'R':
+				robot_pos_ = new Pos(y,x);
+				raw_data_[y][x] = ' ';
+				break;
+			case '*':
+			case 'W':
+				dynamic_objects_[new Pos(y,x)] = c;
+				raw_data_[y][x] = ' ';
+				if(c=='*')
+					may_update_[new Pos(y,x)] = true;
+				break;
+			default:
+				assert(false);
+			}
+		}
+
+		// Read other parameters
+		for(string line; !(line=input.readln()).empty; )
+		{
+			string[] ss = line.split();
+			if( ss.length == 2 )
+				switch(ss[0])
+				{
+				case "Water":      water_base_ = ss[1].to!int(); break;
+				case "Flooding":   water_pace_ = ss[1].to!int(); break;
+				case "Waterproof": max_air_    = ss[1].to!int(); break;
+				case "Growth":     hige_pace_  = ss[1].to!int(); break;
+				case "Razors":     num_razor_  = ss[1].to!int(); break;
+				default: assert(false);
+				}
+			if( ss.length == 4 && ss[0]=="Trampoline" && ss[2]=="targets" )
+			{
+				char fr=ss[1][0], to=ss[3][0];
+				trampoline_[fr] = to;
+				if(to !in trampoline_rev_) trampoline_rev_[to] = [];
+				trampoline_rev_[to] ~= fr;
+			}
+		}
+
+		air_left_ = max_air_;
+	}
+
+	@property const {
+		int H() { return H_; }
+		int W() { return W_; }
+		char trampoline(char c) { return (c in trampoline_ ? trampoline_[c] : 0); }
+		int water_level() {
+			return water_pace_ ? water_base_ + turn_/water_pace_ : water_base_;
+		}
+		int water_until_rise() {
+			return water_pace_ ? water_pace_ - turn_%water_pace_ : int.max;
+		}
+		int hige_until_rise() {
+			return hige_pace_ ? hige_pace_ - turn_%hige_pace_ : int.max;
+		}
+		bool is_hige_turn() {
+			return hige_pace_ ? turn_%hige_pace_ == hige_pace_-1 : false;
+		}
+		int hp() { return air_left_; }
+		int num_razor() { return num_razor_; }
+		bool cleared() { return cleared_; }
+		bool dead() { return dead_; }
+		long score() { return num_lambda_*(dead_ ? 25L : cleared_ ? 75L : 50L) - turn_; }
+	}
+	const {
+		char opIndex(in Pos p) { return opIndex(p.y, p.x); }
+		char opIndex(int y, int x) { return map_get(y, x); }
+	}
+
+public:
+	void command(char c)
+	{
+		if(dead || cleared)
+			return;
+
+		if(c == 'U') command_move(+1, 0);
+		if(c == 'D') command_move(-1, 0);
+		if(c == 'L') command_move(0, -1);
+		if(c == 'R') command_move(0, +1);
+		if(c == 'S') use_razor();
+		if(c == 'W') {}
+
+		if(cleared)
+			return;
+
+		map_update();
+		water_update();
+		turn_ ++;
+	}
+
+	void command_move(int dy, int dx)
+	{
+		int y = robot_pos_.y, x = robot_pos_.x;
+		char c = this[y+dy, x+dx];
+		Pos p = new Pos(y+dy, x+dx);
+
+		switch(c){
+		case 'O':
+			cleared_ = true;
+			move_robot_to(p);
+			break;
+		case '\\':
+			take_lambda_at(p);
+			move_robot_to(p);
+			break;
+		case '!':
+			take_razor_at(p);
+			move_robot_to(p);
+			break;
+		case 'A': .. case 'I':
+			enter_trampoline_at(p, c);
+			break;
+		case ' ':
+		case '.':
+			move_robot_to(p);
+			break;
+		case '*':
+			if(dy!=0 || this[y,x+dx*2]!=' ')
+				break;
+			move_robot_to(p);
+			push_rock(p, new Pos(y,x+dx*2));
+			break;
+		default:
+			break;
+		}
+	}
+
+	void use_razor()
+	{
+		if(num_razor_ == 0)
+			return;
+		num_razor_ --;
+
+		for(int dy=-1; dy<=+1; ++dy)
+		for(int dx=-1; dx<=+1; ++dx) if(dy||dx)
+		{
+			Pos p = new Pos(robot_pos_.y+dy, robot_pos_.x+dx);
+			if(auto it = p in dynamic_objects_)
+				if(*it == 'W') {
+					something_gone(p);
+					dynamic_objects_.remove(p);
+				}
+		}
+	}
+
+	void take_lambda_at(Pos p)
+	{
+		map_set_empty(p);
+		num_lambda_ ++;
+		lambda_pos_ = lambda_pos_.erase(p);
+	}
+
+	void take_razor_at(Pos p)
+	{
+		map_set_empty(p);
+		num_razor_ ++;
+		razor_pos_ = razor_pos_.erase(p);
+	}
+
+	void enter_trampoline_at(Pos p, char c)
+	{
+		char d = trampoline(c);
+		foreach(cc; trampoline_rev_[d]) {
+			Pos pp = trampoline_pos_[cc];
+			something_gone(pp);
+			map_set_empty(pp);
+		}
+		move_robot_to(trampoline_pos_[d]);
+	}
+
+	void move_robot_to(Pos p)
+	{
+		something_gone(robot_pos_);
+		map_set_empty(p.y, p.x);
+		robot_pos_ = p;
+	}
+
+	void push_rock(Pos fr, Pos to)
+	{
+		dynamic_objects_.remove(fr);
+		dynamic_objects_[to] = '*';
+		may_update_[to] = true;
+	}
+
+	void something_gone(Pos p)
+	{
+		for(int dy=0;  dy<=+1; ++dy)
+		for(int dx=-1; dx<=+1; ++dx) if(dy||dx)
+			may_update_[new Pos(p.y+dy,p.x+dx)] = true;
+	}
+
+	void map_update()
+	{
+		Pos[] may_update_list;
+		foreach(p,_; may_update_)
+			if(this[p] == '*')
+				may_update_list ~= p;
+		may_update_ = null;
+
+		if( is_hige_turn() )
+			foreach(p,c; dynamic_objects_)
+				if(c == 'W')
+					may_update_list ~= p;
+
+		sort(may_update_list);
+		char[Pos] to_be_written;
+		foreach(p; may_update_list)
+			if(is_hige_turn() && this[p]=='W')
+			{
+				for(int dy=-1; dy<=+1; ++dy)
+				for(int dx=-1; dx<=+1; ++dx) {
+					Pos q = new Pos(p.y+dy,p.x+dx);
+					if( this[q] == ' ' )
+						to_be_written[q] = 'W';
+				}
+			}
+			else
+			{
+				int y = p.y;
+				int x = p.x;
+				char below = this[y-1,x];
+				// *
+				// _
+				if(below==' ') {
+					Pos q = new Pos(y-1,x);
+					to_be_written[p] = ' ';
+					to_be_written[q] = '*';
+					may_update_[q] = true;
+				}
+				// *_      *_
+				// *_  or  \_
+				else if((below=='*'||below=='\\')&&this[y-1,x+1]==' '&&this[y,x+1]==' ') {
+					Pos q = new Pos(y-1,x+1);
+					to_be_written[p] = ' ';
+					to_be_written[q] = '*';
+					may_update_[q] = true;
+				}
+				// _*
+				// _*
+				else if(below=='*'&&this[y-1,x-1]==' '&&this[y,x-1]==' ') {
+					Pos q = new Pos(y-1,x-1);
+					to_be_written[p] = ' ';
+					to_be_written[q] = '*';
+					may_update_[q] = true;
+				}
+			}
+
+		foreach(p,c; to_be_written) {
+			dynamic_objects_[p] = c;
+			if(c=='*' && p.y==robot_pos_.y+1 && p.x==robot_pos_.x)
+				dead_ = true;
+		}
+
+		if(lambda_pos_.empty)
+			raw_data_[lift_pos_.y][lift_pos_.x] = 'O';
+	}
+
+	void water_update()
+	{
+		if( robot_pos_.y <= water_level() )
+			air_left_ --;
+		else
+			air_left_ = max_air_;
+		if( air_left_ < 0 )
+			dead_ = true;
+	}
+
+private:
+	char map_get(int y, int x) const
+	{
+		if( y<1 || H<y || x<1 || W<x ) return '#';
+		Pos p = new Pos(y,x);
+		if(p == robot_pos_)
+			return 'R';
+		if(auto it = (p in dynamic_objects_))
+			return *it;
+		if( x<0 || raw_data_[y].length<=x ) return ' ';
+		return raw_data_[y][x];
+	}
+
+	void map_set_empty(in Pos p)
+	{
+		return map_set_empty(p.y, p.x);
+	}
+
+	void map_set_empty(int y, int x)
+	{
+		if( y<1 || H<y || x<1 || W<x ) return;
+		if( x<0 || raw_data_[y].length<=x ) return;
+		raw_data_[y][x] = ' ';
+	}
+
+private:
+	int          H_;
+	int          W_;
+	char[][]     raw_data_;
+	Pos[char]    trampoline_pos_;
+	Pos[]        razor_pos_;
+	Pos[]        lambda_pos_;
+	Pos          lift_pos_;
+	Pos          robot_pos_;
+	char[Pos]    dynamic_objects_;
+	char[char]   trampoline_;
+	char[][char] trampoline_rev_;
+	int          water_base_ = 0;
+	int          water_pace_ = 0;
+	int          max_air_    = 10;
+	int          hige_pace_  = 25;
+	int          num_razor_  = 0;
+	int          num_lambda_ = 0;
+
+	int turn_     = 0;
+	int air_left_ = 0;
+	bool cleared_ = false;
+	bool dead_    = false;
+	bool[Pos] may_update_;
+}