RSokoban 0.74 → 0.76

data/test/tc_level.rb

@@ -1,5 +1,6 @@
 
 class TC_Level < Test::Unit::TestCase
+	include RSokoban
 
 	Text1 = [ '#####',
             '#.$@#',
@@ -18,14 +19,14 @@ class TC_Level < Test::Unit::TestCase
 	          '####']
 	
 	def setup
-		@text_1 = RSokoban::Level.new(RSokoban::RawLevel.new('1', Text1))
-		@text_2 = RSokoban::Level.new(RSokoban::RawLevel.new('1', Text2))
-		@text_3 = RSokoban::Level.new(RSokoban::RawLevel.new('1', Text3))
-		@original_1 = RSokoban::Level.new(RSokoban::RawLevel.new('1', Level1))
+		@text_1 = Level.new(RawLevel.new('1', Text1))
+		@text_2 = Level.new(RawLevel.new('1', Text2))
+		@text_3 = Level.new(RawLevel.new('1', Text3))
+		@original_1 = Level.new(RawLevel.new('1', Level1))
 	end
 	
 	def test_instance
-		assert_equal true, @text_1.instance_of?(RSokoban::Level), "Must be an instance of RSokoban::Level"
+		assert_equal true, @text_1.instance_of?(Level), "Must be an instance of Level"
 	end
 	
 	def test_move_number
@@ -62,7 +63,7 @@ class TC_Level < Test::Unit::TestCase
 	end
 	
 	def test_crates_contains_some_crate
-		assert_equal true, @text_1.crates[0].instance_of?(RSokoban::Crate)
+		assert_equal true, @text_1.crates[0].instance_of?(Crate)
 	end
 	
 	def test_crates_with_Text2_must_be_of_size_3
@@ -101,7 +102,7 @@ class TC_Level < Test::Unit::TestCase
 	end
 	
 	def test_storages_contains_some_storage
-		assert_equal true, @text_1.storages[0].instance_of?(RSokoban::Storage)
+		assert_equal true, @text_1.storages[0].instance_of?(Storage)
 	end
 	
 	def test_storages_positions
@@ -124,7 +125,7 @@ class TC_Level < Test::Unit::TestCase
 	end
 	
 	def test_equality
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', Text3))
+		ins = Level.new(RawLevel.new('1', Text3))
 		assert ins == @text_3
 	end
 	
@@ -141,7 +142,7 @@ class TC_Level < Test::Unit::TestCase
 '    #######']
 
 	def test_rawLevel
-		assert_equal Level1, @original_1.map
+		assert_equal Level1, @original_1.map_as_array
 	end
 	
 	def test_width
@@ -152,22 +153,23 @@ class TC_Level < Test::Unit::TestCase
 		assert_equal 11, @original_1.height
 	end
 	
-	Level1_u = ['    #####',
-'    #   #',
-'    #$  #',
-'  ###  $##',
-'  #  $ $ #',
-'### # ## #   ######',
+	Level1_u = [
+'oooo#####oooooooooo',
+'oooo#   #oooooooooo',
+'oooo#$  #oooooooooo',
+'oo###  $##ooooooooo',
+'oo#  $ $ #ooooooooo',
+'### # ## #ooo######',
 '#   # ## #####  ..#',
 '# $  $     @    ..#',
 '##### ### # ##  ..#',
-'    #     #########',
-'    #######']
+'oooo#     #########',
+'oooo#######oooooooo']
 
 	def test_rawLevel_after_move_up
 		ins = @original_1
 		ins.move(:up)
-		assert_equal Level1_u, ins.map
+		assert_equal Level1_u, ins.map_as_array
 	end
 	
 	Text4 = [ '####',
@@ -177,7 +179,7 @@ class TC_Level < Test::Unit::TestCase
 	          '####']
 	
 	def test_crate_on_storage_at_startup
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', Text4))
+		ins = Level.new(RawLevel.new('1', Text4))
 		result = ins.move(:up)
 		assert_equal :win, result[:status]
 		assert_equal 1, result[:move_number]
@@ -196,7 +198,7 @@ class TC_Level < Test::Unit::TestCase
 									'###']
 	               
 	def test_CanMoveUp1
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveUp1))
+		ins = Level.new(RawLevel.new('1', CanMoveUp1))
 		result = ins.move(:up)
 		assert_equal :ok, result[:status]
 		assert_equal 1, result[:move_number]
@@ -205,9 +207,9 @@ class TC_Level < Test::Unit::TestCase
 	end
 	
 	def test_AfterMoveUp1
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveUp1))
+		ins = Level.new(RawLevel.new('1', CanMoveUp1))
 		ins.move(:up)
-		assert_equal AfterMoveUp1, ins.map
+		assert_equal AfterMoveUp1, ins.map_as_array
 	end
 	
 	CanMoveUp2 = ['###',
@@ -221,7 +223,7 @@ class TC_Level < Test::Unit::TestCase
 									'###']
 	              
 	def test_CanMoveUp2
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveUp2))
+		ins = Level.new(RawLevel.new('1', CanMoveUp2))
 		result = ins.move(:up)
 		assert_equal :ok, result[:status]
 		assert_equal 1, result[:move_number]
@@ -230,9 +232,9 @@ class TC_Level < Test::Unit::TestCase
 	end
 	
 	def test_AfterMoveUp2
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveUp2))
+		ins = Level.new(RawLevel.new('1', CanMoveUp2))
 		ins.move(:up)
-		assert_equal AfterMoveUp2, ins.map
+		assert_equal AfterMoveUp2, ins.map_as_array
 	end
 	
 	CanMoveUp3 = ['###',
@@ -248,7 +250,7 @@ class TC_Level < Test::Unit::TestCase
 									'###'] 
 	
 	def test_CanMoveUp3
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveUp3))
+		ins = Level.new(RawLevel.new('1', CanMoveUp3))
 		result = ins.move(:up)
 		assert_equal :ok, result[:status]
 		assert_equal 1, result[:move_number]
@@ -257,9 +259,9 @@ class TC_Level < Test::Unit::TestCase
 	end
 	
 	def test_AfterMoveUp3
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveUp3))
+		ins = Level.new(RawLevel.new('1', CanMoveUp3))
 		ins.move(:up)
-		assert_equal AfterMoveUp3, ins.map
+		assert_equal AfterMoveUp3, ins.map_as_array
 	end
 	
 	CanMoveUp4 = ['###',
@@ -275,7 +277,7 @@ class TC_Level < Test::Unit::TestCase
 									'###']
 	              
 	def test_CanMoveUp4
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveUp4))
+		ins = Level.new(RawLevel.new('1', CanMoveUp4))
 		result = ins.move(:up)
 		assert_equal :win, result[:status]
 		assert_equal 1, result[:move_number]
@@ -284,9 +286,9 @@ class TC_Level < Test::Unit::TestCase
 	end
 	
 	def test_AfterMoveUp4
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveUp4))
+		ins = Level.new(RawLevel.new('1', CanMoveUp4))
 		ins.move(:up)
-		assert_equal AfterMoveUp4, ins.map
+		assert_equal AfterMoveUp4, ins.map_as_array
 	end
 	
 	CannotMoveUp1 = ['###',
@@ -294,11 +296,11 @@ class TC_Level < Test::Unit::TestCase
 									 '###']
 	
 	def test_CannotMoveUp1
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CannotMoveUp1))
+		ins = Level.new(RawLevel.new('1', CannotMoveUp1))
 		result = ins.move(:up)
 		assert_equal :error, result[:status]
 		assert_equal 'wall', result[:message]
-		assert_equal CannotMoveUp1, ins.map
+		assert_equal CannotMoveUp1, ins.map_as_array
 	end
 	
 	CannotMoveUp2 = ['###',
@@ -307,11 +309,11 @@ class TC_Level < Test::Unit::TestCase
 									 '###']
 	
 	def test_CannotMoveUp2
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CannotMoveUp2))
+		ins = Level.new(RawLevel.new('1', CannotMoveUp2))
 		result = ins.move(:up)
 		assert_equal :error, result[:status]
 		assert_equal 'wall behind crate', result[:message]
-		assert_equal CannotMoveUp2, ins.map
+		assert_equal CannotMoveUp2, ins.map_as_array
 	end
 	
 	CannotMoveUp3 = ['###',
@@ -322,11 +324,11 @@ class TC_Level < Test::Unit::TestCase
 									 '###']
 	
 	def test_CannotMoveUp3
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CannotMoveUp3))
+		ins = Level.new(RawLevel.new('1', CannotMoveUp3))
 		result = ins.move(:up)
 		assert_equal :error, result[:status]
 		assert_equal 'double crate', result[:message]
-		assert_equal CannotMoveUp3, ins.map
+		assert_equal CannotMoveUp3, ins.map_as_array
 	end
 	
 	CannotMoveUp4 = ['###',
@@ -337,11 +339,11 @@ class TC_Level < Test::Unit::TestCase
 									 '###']
 	
 	def test_CannotMoveUp4
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CannotMoveUp4))
+		ins = Level.new(RawLevel.new('1', CannotMoveUp4))
 		result = ins.move(:up)
 		assert_equal :error, result[:status]
 		assert_equal 'double crate', result[:message]
-		assert_equal CannotMoveUp4, ins.map
+		assert_equal CannotMoveUp4, ins.map_as_array
 	end
 	
 	CannotMoveUp5 = ['###',
@@ -352,11 +354,11 @@ class TC_Level < Test::Unit::TestCase
 									 '###']
 	
 	def test_CannotMoveUp5
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CannotMoveUp5))
+		ins = Level.new(RawLevel.new('1', CannotMoveUp5))
 		result = ins.move(:up)
 		assert_equal :error, result[:status]
 		assert_equal 'double crate', result[:message]
-		assert_equal CannotMoveUp5, ins.map
+		assert_equal CannotMoveUp5, ins.map_as_array
 	end
 	
 	CannotMoveUp6 = ['###',
@@ -367,11 +369,11 @@ class TC_Level < Test::Unit::TestCase
 									 '###']
 	
 	def test_CannotMoveUp6
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CannotMoveUp6))
+		ins = Level.new(RawLevel.new('1', CannotMoveUp6))
 		result = ins.move(:up)
 		assert_equal :error, result[:status]
 		assert_equal 'double crate', result[:message]
-		assert_equal CannotMoveUp6, ins.map
+		assert_equal CannotMoveUp6, ins.map_as_array
 	end
 	
 	### Move down ##############################################
@@ -387,16 +389,16 @@ class TC_Level < Test::Unit::TestCase
 										'###']
 	               
 	def test_CanMoveDown1
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveDown1))
+		ins = Level.new(RawLevel.new('1', CanMoveDown1))
 		result = ins.move(:down)
 		assert_equal :ok, result[:status]
 		assert_equal 1, result[:move_number]
 	end
 	
 	def test_AfterMoveDown1
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveDown1))
+		ins = Level.new(RawLevel.new('1', CanMoveDown1))
 		ins.move(:down)
-		assert_equal AfterMoveDown1, ins.map
+		assert_equal AfterMoveDown1, ins.map_as_array
 	end
 	
 	CanMoveDown2 = ['###',
@@ -410,16 +412,16 @@ class TC_Level < Test::Unit::TestCase
 										'###']
 	              
 	def test_CanMoveDown2
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveDown2))
+		ins = Level.new(RawLevel.new('1', CanMoveDown2))
 		result = ins.move(:down)
 		assert_equal :ok, result[:status]
 		assert_equal 1, result[:move_number]
 	end
 	
 	def test_AfterMoveDown2
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveDown2))
+		ins = Level.new(RawLevel.new('1', CanMoveDown2))
 		ins.move(:down)
-		assert_equal AfterMoveDown2, ins.map
+		assert_equal AfterMoveDown2, ins.map_as_array
 	end
 	
 	CanMoveDown3 = ['###',
@@ -435,16 +437,16 @@ class TC_Level < Test::Unit::TestCase
 										'###'] 
 	
 	def test_CanMoveDown3
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveDown3))
+		ins = Level.new(RawLevel.new('1', CanMoveDown3))
 		result = ins.move(:down)
 		assert_equal :ok, result[:status]
 		assert_equal 1, result[:move_number]
 	end
 	
 	def test_AfterMoveDown3
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveDown3))
+		ins = Level.new(RawLevel.new('1', CanMoveDown3))
 		ins.move(:down)
-		assert_equal AfterMoveDown3, ins.map
+		assert_equal AfterMoveDown3, ins.map_as_array
 	end
 	
 	CanMoveDown4 = ['###',
@@ -460,16 +462,16 @@ class TC_Level < Test::Unit::TestCase
 										'###']
 	              
 	def test_CanMoveDown4
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveDown4))
+		ins = Level.new(RawLevel.new('1', CanMoveDown4))
 		result = ins.move(:down)
 		assert_equal :win, result[:status]
 		assert_equal 1, result[:move_number]
 	end
 	
 	def test_AfterMoveDown4
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveDown4))
+		ins = Level.new(RawLevel.new('1', CanMoveDown4))
 		ins.move(:down)
-		assert_equal AfterMoveDown4, ins.map
+		assert_equal AfterMoveDown4, ins.map_as_array
 	end
 	
 	CannotMoveDown1 = ['###',
@@ -477,11 +479,11 @@ class TC_Level < Test::Unit::TestCase
 										 '###']
 	
 	def test_CannotMoveDown1
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CannotMoveDown1))
+		ins = Level.new(RawLevel.new('1', CannotMoveDown1))
 		result = ins.move(:down)
 		assert_equal :error, result[:status]
 		assert_equal 'wall', result[:message]
-		assert_equal CannotMoveDown1, ins.map
+		assert_equal CannotMoveDown1, ins.map_as_array
 	end
 	
 	CannotMoveDown2 = ['###',
@@ -490,11 +492,11 @@ class TC_Level < Test::Unit::TestCase
 										 '###']
 	
 	def test_CannotMoveDown2
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CannotMoveDown2))
+		ins = Level.new(RawLevel.new('1', CannotMoveDown2))
 		result = ins.move(:down)
 		assert_equal :error, result[:status]
 		assert_equal 'wall behind crate', result[:message]
-		assert_equal CannotMoveDown2, ins.map
+		assert_equal CannotMoveDown2, ins.map_as_array
 	end
 	
 	CannotMoveDown3 = ['###',
@@ -505,11 +507,11 @@ class TC_Level < Test::Unit::TestCase
 										 '###']
 	
 	def test_CannotMoveDown3
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CannotMoveDown3))
+		ins = Level.new(RawLevel.new('1', CannotMoveDown3))
 		result = ins.move(:down)
 		assert_equal :error, result[:status]
 		assert_equal 'double crate', result[:message]
-		assert_equal CannotMoveDown3, ins.map
+		assert_equal CannotMoveDown3, ins.map_as_array
 	end
 	
 	CannotMoveDown4 = ['###',
@@ -520,11 +522,11 @@ class TC_Level < Test::Unit::TestCase
 										 '###']
 	
 	def test_CannotMoveDown4
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CannotMoveDown4))
+		ins = Level.new(RawLevel.new('1', CannotMoveDown4))
 		result = ins.move(:down)
 		assert_equal :error, result[:status]
 		assert_equal 'double crate', result[:message]
-		assert_equal CannotMoveDown4, ins.map
+		assert_equal CannotMoveDown4, ins.map_as_array
 	end
 	
 	CannotMoveDown5 = ['###',
@@ -535,11 +537,11 @@ class TC_Level < Test::Unit::TestCase
 										 '###']
 	
 	def test_CannotMoveDown5
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CannotMoveDown5))
+		ins = Level.new(RawLevel.new('1', CannotMoveDown5))
 		result = ins.move(:down)
 		assert_equal :error, result[:status]
 		assert_equal 'double crate', result[:message]
-		assert_equal CannotMoveDown5, ins.map
+		assert_equal CannotMoveDown5, ins.map_as_array
 	end
 	
 	CannotMoveDown6 = ['###',
@@ -550,11 +552,11 @@ class TC_Level < Test::Unit::TestCase
 										 '###']
 	
 	def test_CannotMoveDown6
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CannotMoveDown6))
+		ins = Level.new(RawLevel.new('1', CannotMoveDown6))
 		result = ins.move(:down)
 		assert_equal :error, result[:status]
 		assert_equal 'double crate', result[:message]
-		assert_equal CannotMoveDown6, ins.map
+		assert_equal CannotMoveDown6, ins.map_as_array
 	end
 	
 	### Move left ##############################################
@@ -568,16 +570,16 @@ class TC_Level < Test::Unit::TestCase
 										'####']
 	               
 	def test_CanMoveLeft1
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveLeft1))
+		ins = Level.new(RawLevel.new('1', CanMoveLeft1))
 		result = ins.move(:left)
 		assert_equal :ok, result[:status]
 		assert_equal 1, result[:move_number]
 	end
 	
 	def test_AfterMoveLeft1
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveLeft1))
+		ins = Level.new(RawLevel.new('1', CanMoveLeft1))
 		ins.move(:left)
-		assert_equal AfterMoveLeft1, ins.map
+		assert_equal AfterMoveLeft1, ins.map_as_array
 	end
 	
 	CanMoveLeft2 = ['####',
@@ -589,16 +591,16 @@ class TC_Level < Test::Unit::TestCase
 									  '####']
 	              
 	def test_CanMoveLeft2
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveLeft2))
+		ins = Level.new(RawLevel.new('1', CanMoveLeft2))
 		result = ins.move(:left)
 		assert_equal :ok, result[:status]
 		assert_equal 1, result[:move_number]
 	end
 	
 	def test_AfterMoveLeft2
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveLeft2))
+		ins = Level.new(RawLevel.new('1', CanMoveLeft2))
 		ins.move(:left)
-		assert_equal AfterMoveLeft2, ins.map
+		assert_equal AfterMoveLeft2, ins.map_as_array
 	end
 	
 	CanMoveLeft3 = ['#####',
@@ -610,16 +612,16 @@ class TC_Level < Test::Unit::TestCase
 									  '#####']
 	
 	def test_CanMoveLeft3
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveLeft3))
+		ins = Level.new(RawLevel.new('1', CanMoveLeft3))
 		result = ins.move(:left)
 		assert_equal :ok, result[:status]
 		assert_equal 1, result[:move_number]
 	end
 	
 	def test_AfterMoveLeft3
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveLeft3))
+		ins = Level.new(RawLevel.new('1', CanMoveLeft3))
 		ins.move(:left)
-		assert_equal AfterMoveLeft3, ins.map
+		assert_equal AfterMoveLeft3, ins.map_as_array
 	end
 	
 	CanMoveLeft4 = ['#####',
@@ -631,16 +633,16 @@ class TC_Level < Test::Unit::TestCase
 										'#####']
 	              
 	def test_CanMoveLeft4
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveLeft4))
+		ins = Level.new(RawLevel.new('1', CanMoveLeft4))
 		result = ins.move(:left)
 		assert_equal :win, result[:status]
 		assert_equal 1, result[:move_number]
 	end
 	
 	def test_AfterMoveLeft4
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveLeft4))
+		ins = Level.new(RawLevel.new('1', CanMoveLeft4))
 		ins.move(:left)
-		assert_equal AfterMoveLeft4, ins.map
+		assert_equal AfterMoveLeft4, ins.map_as_array
 	end
 	
 	CannotMoveLeft1 = ['###',
@@ -648,11 +650,11 @@ class TC_Level < Test::Unit::TestCase
 										 '###']
 	
 	def test_CannotMoveLeft1
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CannotMoveLeft1))
+		ins = Level.new(RawLevel.new('1', CannotMoveLeft1))
 		result = ins.move(:left)
 		assert_equal :error, result[:status]
 		assert_equal 'wall', result[:message]
-		assert_equal CannotMoveLeft1, ins.map
+		assert_equal CannotMoveLeft1, ins.map_as_array
 	end
 	
 	CannotMoveLeft2 = ['####',
@@ -660,11 +662,11 @@ class TC_Level < Test::Unit::TestCase
 										 '####']
 	
 	def test_CannotMoveLeft2
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CannotMoveLeft2))
+		ins = Level.new(RawLevel.new('1', CannotMoveLeft2))
 		result = ins.move(:left)
 		assert_equal :error, result[:status]
 		assert_equal 'wall behind crate', result[:message]
-		assert_equal CannotMoveLeft2, ins.map
+		assert_equal CannotMoveLeft2, ins.map_as_array
 	end
 	
 	CannotMoveLeft3 = ['######',
@@ -672,11 +674,11 @@ class TC_Level < Test::Unit::TestCase
 										 '######']
 	
 	def test_CannotMoveLeft3
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CannotMoveLeft3))
+		ins = Level.new(RawLevel.new('1', CannotMoveLeft3))
 		result = ins.move(:left)
 		assert_equal :error, result[:status]
 		assert_equal 'double crate', result[:message]
-		assert_equal CannotMoveLeft3, ins.map
+		assert_equal CannotMoveLeft3, ins.map_as_array
 	end
 	
 	### Move right ##############################################
@@ -690,16 +692,16 @@ class TC_Level < Test::Unit::TestCase
 										 '####']
 	               
 	def test_CanMoveRight1
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveRight1))
+		ins = Level.new(RawLevel.new('1', CanMoveRight1))
 		result = ins.move(:right)
 		assert_equal :ok, result[:status]
 		assert_equal 1, result[:move_number]
 	end
 	
 	def test_AfterMoveRight1
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveRight1))
+		ins = Level.new(RawLevel.new('1', CanMoveRight1))
 		ins.move(:right)
-		assert_equal AfterMoveRight1, ins.map
+		assert_equal AfterMoveRight1, ins.map_as_array
 	end
 	
 	CanMoveRight2 = ['####',
@@ -711,16 +713,16 @@ class TC_Level < Test::Unit::TestCase
 									   '####']
 	              
 	def test_CanMoveRight2
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveRight2))
+		ins = Level.new(RawLevel.new('1', CanMoveRight2))
 		result = ins.move(:right)
 		assert_equal :ok, result[:status]
 		assert_equal 1, result[:move_number]
 	end
 	
 	def test_AfterMoveRight2
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveRight2))
+		ins = Level.new(RawLevel.new('1', CanMoveRight2))
 		ins.move(:right)
-		assert_equal AfterMoveRight2, ins.map
+		assert_equal AfterMoveRight2, ins.map_as_array
 	end
 	
 	CanMoveRight3 = ['#####',
@@ -732,16 +734,16 @@ class TC_Level < Test::Unit::TestCase
 									   '#####']
 	
 	def test_CanMoveRight3
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveRight3))
+		ins = Level.new(RawLevel.new('1', CanMoveRight3))
 		result = ins.move(:right)
 		assert_equal :ok, result[:status]
 		assert_equal 1, result[:move_number]
 	end
 	
 	def test_AfterMoveRight3
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveRight3))
+		ins = Level.new(RawLevel.new('1', CanMoveRight3))
 		ins.move(:right)
-		assert_equal AfterMoveRight3, ins.map
+		assert_equal AfterMoveRight3, ins.map_as_array
 	end
 	
 	CanMoveRight4 = ['#####',
@@ -753,16 +755,16 @@ class TC_Level < Test::Unit::TestCase
 										 '#####']
 	              
 	def test_CanMoveRight4
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveRight4))
+		ins = Level.new(RawLevel.new('1', CanMoveRight4))
 		result = ins.move(:right)
 		assert_equal :win, result[:status]
 		assert_equal 1, result[:move_number]
 	end
 	
 	def test_AfterMoveRight4
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CanMoveRight4))
+		ins = Level.new(RawLevel.new('1', CanMoveRight4))
 		ins.move(:right)
-		assert_equal AfterMoveRight4, ins.map
+		assert_equal AfterMoveRight4, ins.map_as_array
 	end
 	
 	CannotMoveRight1 = ['###',
@@ -770,11 +772,11 @@ class TC_Level < Test::Unit::TestCase
 										 '###']
 	
 	def test_CannotMoveRight1
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CannotMoveRight1))
+		ins = Level.new(RawLevel.new('1', CannotMoveRight1))
 		result = ins.move(:right)
 		assert_equal :error, result[:status]
 		assert_equal 'wall', result[:message]
-		assert_equal CannotMoveRight1, ins.map
+		assert_equal CannotMoveRight1, ins.map_as_array
 	end
 	
 	CannotMoveRight2 = ['####',
@@ -782,11 +784,11 @@ class TC_Level < Test::Unit::TestCase
 										  '####']
 	
 	def test_CannotMoveRight2
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CannotMoveRight2))
+		ins = Level.new(RawLevel.new('1', CannotMoveRight2))
 		result = ins.move(:right)
 		assert_equal :error, result[:status]
 		assert_equal 'wall behind crate', result[:message]
-		assert_equal CannotMoveRight2, ins.map
+		assert_equal CannotMoveRight2, ins.map_as_array
 	end
 	
 	CannotMoveRight3 = ['######',
@@ -794,11 +796,11 @@ class TC_Level < Test::Unit::TestCase
 										  '######']
 	
 	def test_CannotMoveRight3
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CannotMoveRight3))
+		ins = Level.new(RawLevel.new('1', CannotMoveRight3))
 		result = ins.move(:right)
 		assert_equal :error, result[:status]
 		assert_equal 'double crate', result[:message]
-		assert_equal CannotMoveRight3, ins.map
+		assert_equal CannotMoveRight3, ins.map_as_array
 	end
 	
 	### WIN ########################################################
@@ -808,7 +810,7 @@ class TC_Level < Test::Unit::TestCase
 	        '#####']
 	
 	def test_solution_avec_une_seule_caisse
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', Win1))
+		ins = Level.new(RawLevel.new('1', Win1))
 		result = ins.move(:right)
 		assert_equal :win, result[:status]
 		assert_equal 1, result[:move_number]
@@ -831,15 +833,15 @@ class TC_Level < Test::Unit::TestCase
 										  '###']
 	
 	def test_bug_first
-		ins = RSokoban::Level.new(RSokoban::RawLevel.new('1', CannotMoveUpBug1))
+		ins = Level.new(RawLevel.new('1', CannotMoveUpBug1))
 		# Changing 'o' to '*'
 		def ins.addStorage
-			@storages.push RSokoban::Storage.new(1, 1)
+			@layered_map.storages.push Storage.new(1, 1)
 		end
 		ins.addStorage
 		
 		# I need to be sure that coord 1, 1 is '*'
-		assert_equal '#*#', ins.map[1]
+		assert_equal '#*#', ins.map_as_array[1]
 		
 		result = ins.move(:up)
 		assert_equal :error, result[:status]