RSokoban 0.74 → 0.76

data/lib/rsokoban/level.rb

@@ -1,9 +1,8 @@
 module RSokoban
 
 	# I am a level of the game.
-	# To complete a level, place each crate ('$') on a storage location ('.').
 	class Level
-		attr_reader :floor, :man, :crates, :storages, :title
+		attr_reader :title
 		
 		# Get map width of this level, in cells
 		# @return [Fixnum]
@@ -13,39 +12,55 @@ module RSokoban
 		# @return [Fixnum]
 		attr_reader :height
 		
+		attr_accessor :number
+		
 		# I build the level from a RawLevel object.
-		# @example a RawLevel object
-		#   A RawLevel object have got one title and one 'picture'. A 'picture' is an array of string.
-		#   Each string contain one line of the level map.
-		#	  'Level 1', ['#####', '#.o@#', '#####']
-		# 
-		# * '#' is a wal
-		# * '.' is a storage location
-		# * '$' is a crate
-		# * '*' is a crate on storage location
-		# * '@' is the man
-		# * ' ' is an empty floor
-		#
-		# @param [RawLevel] rawLevel
-		def initialize rawLevel
-			@title = rawLevel.title
-			init_dimension rawLevel.map
-			@floor = init_floor rawLevel.map
-			@man = init_man rawLevel.map
-			@crates = []
-			@storages = []
-			init_crates_and_storages rawLevel.map
+		# @param [RawLevel] raw_level A RawLevel object, containing a title and a map.
+		def initialize raw_level
+			@title = raw_level.title
+			@width = raw_level.map.width
+			@height = raw_level.map.height
+			@layered_map = LayeredMap.new raw_level.map
 			@move = 0
 			@map = nil
 			@move_recorder = MoveRecorder.new
 		end
 		
-		# Two Level objects are equals if their @title, @floor, @man, @crates and @storages are equals.
+		def set_filename= filename
+			begin
+				full_path = File.join(RECORD_FOLDER, filename + '.yaml')
+				@record = Record.load_file full_path
+			rescue ArgumentError => e
+				@record = Record.create full_path
+			end
+		end
+		
+		def record
+			@record.record_of_level @number
+		end
+		
+		def storages
+			@layered_map.storages
+		end
+		
+		def floor
+			@layered_map.floor
+		end
+		
+		def man
+			@layered_map.man
+		end
+		
+		def crates
+			@layered_map.crates
+		end
+		
+		# Two Level objects are equals if their @title, @floor, @layered_map.man, @layered_map.crates and @layered_map.storages are equals.
 		# @param [Object] obj
 		# @return [false|true]
 		def ==(obj)
 			return false unless obj.kind_of?(Level)
-			@floor == obj.floor and @man == obj.man and @crates == obj.crates and @storages == obj.storages and @title == obj.title
+			@layered_map.floor == obj.floor and @layered_map.man == obj.man and @layered_map.crates == obj.crates and @layered_map.storages == obj.storages and @title == obj.title
 		end
 		
 		# Synonym of #==
@@ -56,12 +71,8 @@ module RSokoban
 		
 		# Get an instant map of the game.
 		# @return [Map] the map, after X turns of game.
-		def map
-			@map = init_floor @floor
-			draw_crates
-			draw_storages
-			draw_man
-			@map
+		def map_as_array
+			@layered_map.map_as_array
 		end
 		
 		# Move the man one box +direction+.
@@ -72,10 +83,10 @@ module RSokoban
 			return MoveResult.new(:status => :error, :message => 'wall behind crate') if wall_behind_crate?(direction)
 			return MoveResult.new(:status => :error, :message => 'double crate') if double_crate?(direction)
 			@move += 1
-			@man.send(direction)
-			if @crates.include?(Crate.new(@man.x, @man.y))
-				i = @crates.index(Crate.new(@man.x, @man.y))
-				@crates[i].send(direction)
+			@layered_map.man.send(direction)
+			if @layered_map.crates.include?(Crate.new(@layered_map.man.x, @layered_map.man.y))
+				idx = @layered_map.crates.index(Crate.new(@layered_map.man.x, @layered_map.man.y))
+				@layered_map.crates[idx].send(direction)
 				@move_recorder.record direction, :push
 			else
 				@move_recorder.record direction
@@ -95,11 +106,11 @@ module RSokoban
 					when :left, :LEFT then direction = :left
 					when :right, :RIGHT then direction = :right
 				end
-				@man.send(direction)
+				@layered_map.man.send(direction)
 				@move += 1
-				if @crates.include?(Crate.new(@man.x, @man.y))
-					i = @crates.index(Crate.new(@man.x, @man.y))
-					@crates[i].send(direction)
+				if @layered_map.crates.include?(Crate.new(@layered_map.man.x, @layered_map.man.y))
+					idx = @layered_map.crates.index(Crate.new(@layered_map.man.x, @layered_map.man.y))
+					@layered_map.crates[idx].send(direction)
 				end
 			rescue EmptyRedoError
 				# Nothing to do
@@ -111,26 +122,26 @@ module RSokoban
 		def undo
 			begin
 				case @move_recorder.undo
-					when :up then @man.down
-					when :down then @man.up
-					when :left then @man.right
-					when :right then @man.left
+					when :up then @layered_map.man.down
+					when :down then @layered_map.man.up
+					when :left then @layered_map.man.right
+					when :right then @layered_map.man.left
 					when :UP
-						i = @crates.index(Crate.new(@man.x, @man.y-1))
-						@crates[i].down
-						@man.down
+						idx = @layered_map.crates.index(Crate.new(@layered_map.man.x, @layered_map.man.y-1))
+						@layered_map.crates[idx].down
+						@layered_map.man.down
 					when :DOWN
-						i = @crates.index(Crate.new(@man.x, @man.y+1))
-						@crates[i].up
-						@man.up
+						idx = @layered_map.crates.index(Crate.new(@layered_map.man.x, @layered_map.man.y+1))
+						@layered_map.crates[idx].up
+						@layered_map.man.up
 					when :LEFT
-						i = @crates.index(Crate.new(@man.x-1, @man.y))
-						@crates[i].right
-						@man.right
+						idx = @layered_map.crates.index(Crate.new(@layered_map.man.x-1, @layered_map.man.y))
+						@layered_map.crates[idx].right
+						@layered_map.man.right
 					when :RIGHT
-						i = @crates.index(Crate.new(@man.x+1, @man.y))
-						@crates[i].left
-						@man.left
+						idx = @layered_map.crates.index(Crate.new(@layered_map.man.x+1, @layered_map.man.y))
+						@layered_map.crates[idx].left
+						@layered_map.man.left
 				end
 				@move -= 1
 			rescue EmptyMoveQueueError
@@ -146,13 +157,18 @@ module RSokoban
 			@move
 		end
 		
+		# @since 0.76
+		def update_record
+			@record.add @number, @move
+		end
+		
 		private
 		
 		# @return true if all crates are on a storage location
 		def win?
-			return false if @crates.size == 0 # needed for testing purpose.
-			@crates.each {|c|
-				return false unless @storages.include?(c)
+			return false if @layered_map.crates.size == 0 # needed for testing purpose.
+			@layered_map.crates.each {|crate|
+				return false unless @layered_map.storages.include?(crate)
 			}
 			true
 		end
@@ -163,13 +179,13 @@ module RSokoban
 		def wall? direction
 			case direction
 				when :up
-					box = what_is_on(@man.x, @man.y-1)
+					box = @layered_map.what_is_on(@layered_map.man.x, @layered_map.man.y-1)
 				when :down
-					box = what_is_on(@man.x, @man.y+1)
+					box = @layered_map.what_is_on(@layered_map.man.x, @layered_map.man.y+1)
 				when :left
-					box = what_is_on(@man.x-1, @man.y)
+					box = @layered_map.what_is_on(@layered_map.man.x-1, @layered_map.man.y)
 				when :right
-					box = what_is_on(@man.x+1, @man.y)
+					box = @layered_map.what_is_on(@layered_map.man.x+1, @layered_map.man.y)
 			end
 			return(box == WALL)
 		end
@@ -180,19 +196,19 @@ module RSokoban
 		def wall_behind_crate?(direction)
 			case direction
 				when :up
-					near = crate?(@man.x, @man.y-1)
-					boxBehind = what_is_on(@man.x, @man.y-2)
+					near = crate_up?
+					box_behind = @layered_map.what_is_on(@layered_map.man.x, @layered_map.man.y-2)
 				when :down
-					near = crate?(@man.x, @man.y+1)
-					boxBehind = what_is_on(@man.x, @man.y+2)
+					near = crate_down?
+					box_behind = @layered_map.what_is_on(@layered_map.man.x, @layered_map.man.y+2)
 				when :left
-					near = crate?(@man.x-1, @man.y)
-					boxBehind = what_is_on(@man.x-2, @man.y)
+					near = crate_left?
+					box_behind = @layered_map.what_is_on(@layered_map.man.x-2, @layered_map.man.y)
 				when :right
-					near = crate?(@man.x+1, @man.y)
-					boxBehind = what_is_on(@man.x+2, @man.y)
+					near = crate_right?
+					box_behind = @layered_map.what_is_on(@layered_map.man.x+2, @layered_map.man.y)
 			end
-			return(near and boxBehind == WALL)
+			near and box_behind == WALL
 		end
 		
 		# Is there a crate followed by a crate near the man, in the direction pointed to by +direction+ ?
@@ -200,122 +216,52 @@ module RSokoban
 		# @return [true|nil]
 		def double_crate?(direction)
 			case direction
-				when :up
-					true if crate?(@man.x, @man.y-1) and crate?(@man.x, @man.y-2)
-				when :down
-					true if crate?(@man.x, @man.y+1) and crate?(@man.x, @man.y+2)
-				when :left
-					true if crate?(@man.x-1, @man.y) and crate?(@man.x-2, @man.y)
-				when :right
-					true if crate?(@man.x+1, @man.y) and crate?(@man.x+2, @man.y)
+				when :up then crate_up? and crate_two_steps_up?
+				when :down then crate_down? and crate_two_steps_down?
+				when :left then crate_left? and crate_two_steps_left?
+				when :right then crate_right? and crate_two_steps_right?
 			end
 		end
 		
-		# Is there a crate ('o' or '*') in the box pointed to by x, y ?
-		# @param [Fixnum] x x coordinate in the map
-		# @param [Fixnum] y y coordinate in the map
+		# Is there a crate ('o' or '*') in the box pointed to by x_coord, y_coord ?
+		# @param [Fixnum] x_coord x coordinate in the map
+		# @param [Fixnum] y_coord y coordinate in the map
 		# @return [true|false]
-		def crate?(x, y)
-			box = what_is_on(x, y)
+		def crate?(x_coord, y_coord)
+			box = @layered_map.what_is_on(x_coord, y_coord)
 			box == CRATE or box == CRATE_ON_STORAGE
 		end
 		
-		# Draw the man for map output
-		def draw_man
-			box = what_is_on @man.x, @man.y
-			put_man_in_map if box == FLOOR
-			put_man_on_storage_in_map if box == STORAGE
+		def crate_up?
+			crate?(@layered_map.man.x, @layered_map.man.y-1)
 		end
 		
-		def put_man_in_map
-			@map[@man.y][@man.x] = MAN
+		def crate_two_steps_up?
+			crate?(@layered_map.man.x, @layered_map.man.y-2)
 		end
 		
-		def put_man_on_storage_in_map
-			@map[@man.y][@man.x] = MAN_ON_STORAGE
+		def crate_down?
+			crate?(@layered_map.man.x, @layered_map.man.y+1)
 		end
 		
-		# Draw the crates for map output
-		def draw_crates
-			@crates.each {|crate| @map[crate.y][crate.x] = what_is_on(crate.x, crate.y) }
+		def crate_two_steps_down?
+			crate?(@layered_map.man.x, @layered_map.man.y+2)
 		end
 		
-		# Draw the storages location for map output
-		def draw_storages
-			@storages.each {|st| @map[st.y][st.x] = what_is_on(st.x, st.y) }
-		end
-
-		# Get the content of box x, y
-		# @param [Fixnum] x x coordinate in the map
-		# @param [Fixnum] y y coordinate in the map
-		# @return [' ' | '#' | '.' | 'o' | '*']
-		def what_is_on x, y
-			box = (@floor[y][x]).chr
-			if box == FLOOR
-				s = Storage.new(x, y)
-				c = Crate.new(x, y)
-				if @storages.include?(s) and @crates.include?(c)
-					box = CRATE_ON_STORAGE 
-				elsif @storages.include?(s)
-					box = STORAGE
-				elsif @crates.include?(c)
-					box = CRATE
-				end
-			end
-			box
+		def crate_left?
+			crate?(@layered_map.man.x-1, @layered_map.man.y)
 		end
 		
-		# Removes all storages locations, all crates and the man, leaving only walls and floor.
-		#
-		# @param [Map] map 
-		# @return [Map] map with only walls and floor
-		def init_floor map
-			floor = []
-			map.each {|x| floor.push x.tr("#{STORAGE}#{CRATE}#{MAN}#{CRATE_ON_STORAGE}", FLOOR) }
-			floor
+		def crate_two_steps_left?
+			crate?(@layered_map.man.x-2, @layered_map.man.y)
 		end
 		
-		# Initialize map width and map height of this level
-		def init_dimension map
-			@width = 0
-			map.each {|y| @width = y.size if y.size > @width }
-			@height = map.size
+		def crate_right?
+			crate?(@layered_map.man.x+1, @layered_map.man.y)
 		end
 		
-		# Find the man's position, at the begining of the level.
-		#
-		# @param [Map] map
-		# @return [Man] an initialised man
-		def init_man map
-			x = y = 0
-			map.each {|line| 
-				if line.include?(MAN)
-					x = line.index(MAN)
-					break
-				end
-				y += 1
-			}
-			Man.new x, y
-		end
-		
-		# Find position of crates and storages, at the begining of the level.
-		#
-		# @param [Map] map
-		def init_crates_and_storages map
-			y = 0
-			map.each do |line| 
-				count = 0
-				line.each_char do |c| 
-					@crates.push Crate.new(count, y) if c == CRATE
-					@storages.push Storage.new(count, y) if c == STORAGE
-					if c == CRATE_ON_STORAGE
-						@crates.push Crate.new(count, y)
-						@storages.push Storage.new(count, y)
-					end
-					count += 1
-				end
-				y += 1
-			end
+		def crate_two_steps_right?
+			crate?(@layered_map.man.x+2, @layered_map.man.y)
 		end
 		
 	end

data/lib/rsokoban/level_set.rb

@@ -23,17 +23,17 @@ module RSokoban
 		attr_accessor :title
 		# @param [String] description get/set the description of this level set.
 		attr_accessor :description
-		# @param [Array<RawLevel>] rawLevels get/set the raw levels of this set
-		attr_accessor :rawLevels
+		# @param [Array<RawLevel>] raw_levels get/set the raw levels of this set
+		attr_accessor :raw_levels
 		
 		def initialize
 			@title = 'Unknown set title'
 			@description = 'Empty description'
-			@rawLevels = []
+			@raw_levels = []
 		end
 		
 		def size
-			@rawLevels.size
+			@raw_levels.size
 		end
 		
 	end

data/lib/rsokoban/man.rb

@@ -6,10 +6,9 @@ module RSokoban
 	class Man < Position
 		include RSokoban::Moveable
 		
-		# @param [Fixnum] x la coordonnée x
-		# @param [Fixnum] y la coordonnée y
-		def initialize x, y
-			super(x, y)
+		# Coordinates must be Fixnum
+		def initialize x_coord, y_coord
+			super(x_coord, y_coord)
 		end
 		
 	end

data/lib/rsokoban/map.rb

@@ -1,38 +1,60 @@
 module RSokoban
 
 	# I am the map of a level.
+	# I am constructed from an array of strings, taken from an xsb file. I transform
+	# this array to equalize the length of all strings and I put a speciam mark in all
+	# cells that are outside of the walls.
+	#
+	# @example the first map from the original levels
+	#		level_1 = [
+	#		'    #####',
+	#		'    #   #',
+	#		'    #$  #',
+	#		'  ###  $##',
+	#		'  #  $ $ #',
+	#		'### # ## #   ######',
+	#		'#   # ## #####  ..#',
+	#		'# $  $          ..#',
+	#		'##### ### #@##  ..#',
+	#		'    #     #########',
+	#		'    #######']
+	#
+	#		map = Map.new level_1
+	#		map.rows =>
+	#		[
+	#		'oooo#####oooooooooo',
+	#		'oooo#   #oooooooooo',
+	#		'oooo#$  #oooooooooo',
+	#		'oo###  $##ooooooooo',
+	#		'oo#  $ $ #ooooooooo',
+	#		'### # ## #ooo######',
+	#		'#   # ## #####  ..#',
+	#		'# $  $          ..#',
+	#		'##### ### #@##  ..#',
+	#		'oooo#     #########',
+	#		'oooo#######oooooooo']
 	# @since 0.73
 	class Map
 		# @param [Array<String>]
 		attr_reader :rows
+		
+		attr_reader :width
 	
-		# Construct a map from an array of strings.
-		# @example very simple maps
-		#   map1 = Map.new['###', '#@#', '###']
-		#
-		#   map2 = Map.new
-		#   map2.rows = ['###', '#@#', '###']
-		#
 		# @param [Array<String>]
 		def initialize rows = []
+			raise ArgumentError unless rows.instance_of?(Array)
 			@rows= rows
-			@width = 0
+			transform
 		end
 		
 		def rows=(rows)
-			@rows = rows
-			@width = 0
-			@rows.each {|row| @width = row.size if row.size > @width }
+			initialize rows
 		end
 		
 		def height
 			@rows.size
 		end
 		
-		def width
-			@width
-		end
-		
 		def [](num)
 			@rows[num]
 		end
@@ -46,6 +68,60 @@ module RSokoban
 			@rows == obj.rows
 		end
 		
+		private
+		
+		def transform
+			compute_width
+			mark_outside
+		end
+		
+		def compute_width
+			@width = 0
+			@rows.each {|row| @width = row.size if row.size > @width }
+		end
+		
+		# Mark the cells of floor which live outside of the walls, and make all rows the same size.
+		def mark_outside
+			mark_start_and_end_of_rows
+			mark_middle_of_rows
+		end
+		
+		def mark_start_and_end_of_rows
+			(0...@rows.size).each do |num|
+				mark_start_of_the_row num
+				mark_end_of_the_row num
+			end
+		end
+		
+		def mark_start_of_the_row num
+			first_wall = @rows[num].index(WALL)
+			@rows[num][0, first_wall] = OUTSIDE * first_wall
+		end
+		
+		def mark_end_of_the_row num
+			@rows[num] = @rows[num] + OUTSIDE * (@width - @rows[num].size)
+		end
+		
+		def mark_middle_of_rows
+			@rows.each_with_index do |row, y|
+				x = 0
+				row.each_char do |cell|
+					if cell == FLOOR
+						@rows[y][x] = OUTSIDE if neighbors_outside?(x, y)
+					end
+					x += 1
+				end
+			end
+		end
+		
+		def neighbors_outside? x, y
+			neighbors_out_of_map?(y) or (@rows[y-1][x].chr == OUTSIDE) or (@rows[y+1][x].chr == OUTSIDE)
+		end
+		
+		def neighbors_out_of_map? y
+			(y < 1) or (y+1 >= @rows.size)
+		end
+		
 	end
 
 end

data/lib/rsokoban/move_result.rb

@@ -13,8 +13,8 @@ module RSokoban
 			@hash = hash
 		end
 		
-		def [](k)
-			@hash[k]
+		def [](key)
+			@hash[key]
 		end
 		
 		# @return true if move is ok

data/lib/rsokoban/option.rb

@@ -67,12 +67,12 @@ class Option
 		print_help_output if @options[:help_output]
 	end
 	
-	def [](k)
-		@options[k]
+	def [](key)
+		@options[key]
 	end
 	
-	def interface=(k)
-		@options[:ui] = k
+	def interface=(value)
+		@options[:ui] = value
 	end
 	
 private

data/lib/rsokoban/position.rb

@@ -1,10 +1,10 @@
 module RSokoban
 
 	# I represent an x,y coordinate.
-	# @todo document
 	class Position
 		attr_reader :x, :y
 		
+		# Coordinates must be Fixnum
 		def initialize x = 0, y = 0
 			@x = x
 			@y = y

data/lib/rsokoban/raw_level.rb

@@ -2,16 +2,25 @@ module RSokoban
 
 	# I figure out a level in a very simple format.
 	# I have a title and a map.
-	# @todo document and give some examples
 	class RawLevel
+		# @return [Map]
 		attr_reader :map
 		attr_accessor :title
 		
+		# If map is an array of string, it will be converted to a Map object.
+		# @param [String] title
+		# @param [Map|Array<String>] map
 		def initialize title = 'Unknown level title', map = Map.new
 			@title = title
-			@map = map
+			if map.instance_of?(Map)
+				@map = map
+			else
+				@map = Map.new map
+			end
 		end
 		
+		# If val is an array of string, it will be converted to a Map object.
+		# @param [Map|Array<String>] val
 		def map=(val)
 			if val.kind_of?(Map)
 				@map = val

data/lib/rsokoban/record.rb

@@ -0,0 +1,51 @@
+require "fileutils"
+require 'yaml'
+
+module RSokoban
+
+	# I keep trace of your records !
+	# @since 0.76
+	class Record
+	
+		# Load the yaml file named <tt>filename</tt>, which keep trace of all records from a
+		# special set of levels. <tt>filename</tt> must have the same name that the xsb file but
+		# with the <tt>.yaml</tt> extension.
+		# @param [String] filename Full path of the yaml file
+		# @raise ArgumentError if <tt>filename</tt> doesn't exist.
+		def initialize filename
+			raise ArgumentError unless File.exist? filename
+			@filename = filename
+			@dict = YAML.load_file(filename)
+			# because yaml returns nil/false if filename is empty.
+			@dict = {} unless @dict
+		end
+		
+		# @see #initialize
+		def self.load_file filename
+			new filename
+		end
+		
+		# Get the record for the level number <tt>num</tt>.
+		def record_of_level num
+			@dict[num]
+		end
+		
+		# Create the file <tt>filename</tt> before loading it as in {#initialize}.
+		# @raise ArgumentError if <tt>filename</tt> exist.
+		def self.create filename
+			raise ArgumentError if File.exist? filename
+			FileUtils.touch filename
+			new filename
+		end
+		
+		# Add or update the record for level number <tt>level_number</tt>
+		def add level_number, moves
+			@dict.merge!({level_number => moves})
+			f = File.new(@filename, "w")
+			f.write @dict.to_yaml
+			f.close
+		end
+		
+	end
+
+end