meiro 0.0.1

data/lib/meiro/floor.rb

@@ -0,0 +1,198 @@
+module Meiro
+  class FloorError < StandardError; end
+  class TrySeparateLimitError < FloorError; end
+
+  class Floor
+
+    TRY_SEPARATE_LIMIT = 1000000
+
+    attr_reader :dungeon, :width, :height,
+                :min_room_width, :min_room_height,
+                :max_room_width, :max_room_height
+
+    class Config < Options
+      option :width,  Integer, nil, lambda {|w,o| !w.nil? && w >= FLOOR_MIN_WIDTH }
+      option :height, Integer, nil, lambda {|h,o| !h.nil? && h >= FLOOR_MIN_HEIGHT }
+      option :min_room_width,  Integer, nil, lambda {|w,o| !w.nil? && w >= ROOM_MIN_WIDTH }
+      option :min_room_height, Integer, nil, lambda {|h,o| !h.nil? && h >= ROOM_MIN_HEIGHT }
+      option :max_room_width,  Integer, nil, lambda {|w,o| !w.nil? && w >= o[:min_room_width] }
+      option :max_room_height, Integer, nil, lambda {|h,o| !h.nil? && h >= o[:min_room_height] }
+    end
+
+    def initialize(d, w, h, min_rw, min_rh, max_rw, max_rh)
+      opts = {
+        width: w,
+        height: h,
+        min_room_width:  min_rw,
+        min_room_height: min_rh,
+        max_room_width:  max_rw,
+        max_room_height: max_rh,
+      }
+      config = Config.new(opts)
+      @dungeon = d
+      @min_room_width  = config.min_room_width
+      @min_room_height = config.min_room_height
+      @max_room_width  = config.max_room_width
+      @max_room_height = config.max_room_height
+      @root_block = Block.new(self, 0, 0, config.width, config.height)
+      fill_floor_by_wall(config.width, config.height)
+    end
+
+    def width
+      @base_map.width
+    end
+
+    def height
+      @base_map.height
+    end
+
+    def [](x, y)
+      @base_map[x, y]
+    end
+
+    def all_blocks
+      @root_block.flatten
+    end
+
+    def all_rooms
+      @all_rooms ||= all_blocks.map{|b| b.room }.compact
+    end
+
+    def each_line(&block)
+      @base_map.each_line(&block)
+    end
+
+    def each_tile(&block)
+      @base_map.each_tile(&block)
+    end
+
+    # このフロアに属するすべての部屋のマスのxy座標を返す
+    def all_room_tiles_xy
+      res = []
+      all_rooms.each do |room|
+        res << room.get_all_abs_coordinate
+      end
+      res.flatten(1)
+    end
+
+    # 指定したx座標、y座標を含むBlockを返す。そのBlockが親(分割済)であっ
+    # た場合は、分割されたいずれかのうち、x座標、y座標を含む方を返す。
+    # 該当するものがない場合はnilを返す。
+    def get_block(x, y, from=nil)
+      from ||= @root_block
+      if from.include?(x, y)
+        if from.separated?
+          get_block(x, y, from.upper_left) ||
+            get_block(x, y, from.lower_right)
+        else
+          from
+        end
+      else
+        nil
+      end
+    end
+
+    # 指定したx座標、y座標を含むRoomを返す。
+    # 該当するものがない場合はnilを返す。
+    def get_room(x, y)
+      block = get_block(x, y)
+      return nil if block.nil?
+      if block.room && block.room.include?(x, y)
+        block.room
+      else
+        nil
+      end
+    end
+
+    def classify!(type=:rogue_like)
+      @base_map.classify!(type)
+    end
+
+    def to_s
+      res = []
+      @base_map.each_line do |line|
+        res << (line.map(&:to_s) << "\n").join
+      end
+      res.join
+    end
+
+    def fill_floor_by_wall(w, h)
+      @base_map = BaseMap.new(w, h, Tile.wall)
+    end
+
+    # ランダムで部屋と通路を生成する
+    def generate_random_room(r_min, r_max, factor, randomizer)
+      separate_blocks(r_min, r_max, factor, randomizer)
+      all_blocks.each do |block|
+        block.put_room(randomizer)
+      end
+      connect_rooms(randomizer)
+      apply_rooms_to_map
+      self
+    end
+
+    # このFloorに設置された部屋に対し、互いを通路で結ぶ処理をかける
+    def connect_rooms(randomizer=nil)
+      randomizer ||= Random.new(Time.now.to_i)
+      all_rooms.each do |room|
+        room.create_passage(randomizer)
+      end
+    end
+
+    # このFloorに設置された部屋全てとそれに紐づく通路・出口を@base_map
+    # に反映させる
+    def apply_rooms_to_map
+      all_rooms.each do |room|
+        @base_map.apply_room(room, Tile.flat)
+      end
+      @base_map.apply_passage(all_rooms, Tile.gate, Tile.passage)
+    end
+
+    # 設定された部屋数のMIN,MAXの範囲に収まるよう区画をランダムで分割
+    def separate_blocks(r_min, r_max, factor, randomizer)
+      new_block = [@root_block]
+      try_count = 0
+
+      while new_block.any?
+        tried = []
+        separated = []
+        next_new_block = []
+
+        while b = new_block.shift
+          if b.separatable? && do_separate?(b, factor, randomizer)
+            b.separate
+            separated << b
+            next_new_block << b.upper_left
+            next_new_block << b.lower_right
+          end
+          tried << b
+        end
+
+        block_num = @root_block.flatten.size
+        if block_num > r_max
+          # MAXを越えてしまったら直前の分割を取り消してやり直し
+          separated.each {|b| b.unify }
+          new_block = tried
+        elsif next_new_block.empty? && block_num < r_min
+          # 全ての分割が完了し、MINに到達しない場合は直前の分割をやり直し
+          new_block = tried
+        else
+          new_block = next_new_block
+        end
+
+        try_count += 1
+        if try_count > TRY_SEPARATE_LIMIT
+          raise TrySeparateLimitError, "could not create expected floor"
+        end
+      end
+      self
+    end
+
+    private
+
+    def do_separate?(block, factor, randomizer)
+      # Blockが細分化するほど、分割されづらくなる
+      block.generation / factor < randomizer.rand(10)
+    end
+  end
+end

data/lib/meiro/map_layer.rb

@@ -0,0 +1,117 @@
+module Meiro
+  class MapLayer
+    def initialize(width, height)
+      @map = Array.new(height)
+      @map.map! {|line| Array.new(width) }
+    end
+
+    def [](x, y)
+      if 0 <= x && 0 <= y && x < width && y < height
+        @map[y][x]
+      else
+        nil
+      end
+    end
+
+    def []=(x, y, obj)
+      @map[y][x] = obj
+    end
+
+    def width
+      @map.first.size
+    end
+
+    def height
+      @map.size
+    end
+
+    def each_line(&block)
+      @map.each do |line|
+        yield(line)
+      end
+    end
+
+    def each_tile(&block)
+      @map.each_with_index do |line, y|
+        line.each_with_index do |tile, x|
+          yield(x, y, tile)
+        end
+      end
+    end
+
+    def get_around(x, y)
+      new = MapLayer.new(width, height)
+      around = [
+       [self[x-1, y-1], self[  x, y-1], self[x+1, y-1]],
+       [self[x-1,   y], self[  x,   y], self[x+1,   y]],
+       [self[x-1, y+1], self[  x, y+1], self[x+1, y+1]],
+      ]
+      new.instance_variable_set(:@map, around)
+      new
+    end
+
+    def dup
+      new = self.class.new(width, height)
+      new.each_tile do |x, y, tile|
+        new[x, y] = self[x, y].dup
+      end
+    end
+  end
+
+  class BaseMap < MapLayer
+    def initialize(width, height, klass=nil)
+      proc = klass.nil? ? lambda { nil } : lambda { klass.new }
+      @map = Array.new(height)
+      @map.map! {|line| Array.new(width).map! {|e| proc.call } }
+    end
+
+    def fill_rect(x1, y1, x2, y2, klass)
+      x_begin, x_end = x1 <= x2 ? [x1, x2] : [x2, x1]
+      y_begin, y_end = y1 <= y2 ? [y1, y2] : [y2, y1]
+
+      (y_begin..y_end).each do |y|
+        (x_begin..x_end).each do |x|
+          self[x, y] = klass.new
+        end
+      end
+    end
+
+    def apply_room(room, klass)
+      room.each_coordinate do |x, y|
+        self[x, y] = klass.new
+      end
+    end
+
+    def apply_passage(rooms, gate_klass, pass_klass)
+      all_pass = []
+      all_gates = []
+      rooms.each do |room|
+        all_pass << room.all_pass
+        all_gates << room.gate_coordinates
+      end
+
+      all_pass.flatten.uniq.each do |p|
+        self.fill_rect(p.start_x, p.start_y, p.end_x, p.end_y, pass_klass)
+      end
+
+      all_gates.flatten(1).each do |x, y|
+        self[x, y] = gate_klass.new
+      end
+    end
+
+    def classify(type=:rogue_like)
+      res = self.class.new(width, height)
+      res.each_tile do |x, y, tile|
+        res[x, y] = Tile.classify(self.get_around(x, y), type)
+      end
+      res
+    end
+
+    def classify!(type=:rogue_like)
+      self.each_tile do |x, y, tile|
+        self[x, y] = Tile.classify(self.get_around(x, y), type)
+      end
+      self
+    end
+  end
+end

data/lib/meiro/options.rb

@@ -0,0 +1,56 @@
+module Meiro
+  class Options
+    class << self
+      attr_reader :keys, :validators
+
+      def option(symbol, klass, default=nil, check=nil)
+        @keys ||= []
+        @keys << symbol
+        @validators ||= {}
+        @validators[symbol] ||= {}
+        @validators[symbol][:class] = klass
+        @validators[symbol][:check] = check if check && check.kind_of?(Proc)
+        define_method(symbol) do
+          option_value = @config[symbol] ||
+            (default.kind_of?(Proc) ? default.call(self) : default)
+          @applied_config[symbol] = option_value
+        end
+      end
+    end
+
+    def initialize(config)
+      @config = validate(config)
+      @applied_config = {}
+    end
+
+    def keys
+      self.class.keys
+    end
+
+    private
+
+    def validate(config)
+      validate_keys(config)
+      validate_values(config)
+      config
+    end
+
+    def validate_keys(config)
+      valid_symbols = self.class.keys
+      config.each_key do |k|
+        raise "Invalid option: #{k}" unless valid_symbols.include? k
+      end
+    end
+
+    def validate_values(config)
+      validators = self.class.validators
+      config.each do |k, v|
+        klass = validators[k][:class]
+        proc = validators[k][:check] || lambda {|v, config| true }
+        unless v.kind_of?(klass) && proc.call(v, config)
+          raise "Invalid option: #{k}(#{klass}) => #{v}"
+        end
+      end
+    end
+  end
+end

data/lib/meiro/partition.rb

@@ -0,0 +1,20 @@
+module Meiro
+  class Partition
+    attr_reader :x, :y, :length
+
+    def initialize(x, y, length, shape)
+      @x = x
+      @y = y
+      @length = length
+      @shape = shape
+    end
+
+    def horizontal?
+      @shape == :horizontal
+    end
+
+    def vertical?
+      @shape == :vertical
+    end
+  end
+end

data/lib/meiro/passage.rb

@@ -0,0 +1,24 @@
+module Meiro
+  class Passage
+    def initialize(x1, y1, x2, y2)
+      @start = [x1, y1]
+      @end = [x2, y2]
+    end
+
+    def start_x
+      @start[0]
+    end
+
+    def start_y
+      @start[1]
+    end
+
+    def end_x
+      @end[0]
+    end
+
+    def end_y
+      @end[1]
+    end
+  end
+end

data/lib/meiro/room.rb

@@ -0,0 +1,233 @@
+module Meiro
+  class Room
+    attr_reader :relative_x, :relative_y,
+                :width, :height, :block
+    attr_accessor :connected_rooms, :all_pass
+
+    def initialize(width, height)
+      if width < ROOM_MIN_WIDTH || height < ROOM_MIN_HEIGHT
+        raise "width/height is too small for Meiro::Room"
+      end
+      @width = width
+      @height = height
+      @connected_rooms = {}
+      @all_pass = []
+    end
+
+    # floorにおける絶対x座標
+    # ブロックのx座標に、ブロックのx座標を基準とした相対x座標を足しあわ
+    # せたものを返す
+    def x
+      return nil if @block.nil?
+      @block.x + @relative_x
+    end
+
+    # floorにおける絶対y座標
+    # ブロックのy座標に、ブロックのy座標を基準とした相対y座標を足しあわ
+    # せたものを返す
+    def y
+      return nil if @block.nil?
+      @block.y + @relative_y
+    end
+
+    # ブロックのx座標を基準とした相対x座標
+    def relative_x=(x)
+      if @block
+        if x < available_x_min || x > available_x_max
+          raise "could not set relative_x-coordinate [#{x}] in this block.\n" \
+                "you can use #{available_x_min}..#{available_x_max}"
+        end
+      end
+      @relative_x = x
+    end
+
+    # ブロックのy座標を基準とした相対y座標
+    def relative_y=(y)
+      if @block
+        if y < available_y_min || y > available_y_max
+          raise "could not set relative_y-coordinate [#{y}] in this block.\n" \
+                "you can use #{available_y_min}..#{available_y_max}"
+        end
+      end
+      @relative_y = y
+    end
+
+    # 部屋のマスの全ての絶対xy座標を返す
+    def get_all_abs_coordinate
+      res = []
+      self.each_coordinate do |_x, _y|
+        res << [_x, _y]
+      end
+      res
+    end
+
+    # 引数で渡した座標を部屋の内部に含むかどうかを返す
+    def include?(_x, _y)
+      self.get_all_abs_coordinate.include?([_x, _y])
+    end
+
+    def block=(block)
+      @block = block
+      if @relative_x && @relative_y
+        begin
+          # 再代入して x, y が適切かチェック
+          self.relative_x = @relative_x
+          self.relative_y = @relative_y
+        rescue => e
+          @block = nil
+          raise e
+        end
+      end
+      @block
+    end
+
+    def set_random_coordinate(randomizer=nil)
+      if @block.nil?
+        raise "Block is not found"
+      else
+        randomizer ||= Random.new(Time.now.to_i)
+        self.relative_x = randomizer.rand(available_x_min..available_x_max)
+        self.relative_y = randomizer.rand(available_y_min..available_y_max)
+      end
+      return [@relative_x, @relative_y]
+    end
+
+    def available_x_min
+      Block::MARGIN
+    end
+
+    def available_x_max
+      @block.width - (@width + Block::MARGIN)
+    end
+
+    def available_y_min
+      Block::MARGIN
+    end
+
+    def available_y_max
+      @block.height - (@height + Block::MARGIN)
+    end
+
+    def each_coordinate(&block)
+      @height.times do |h|
+        @width.times do |w|
+          yield(x + w, y + h)
+        end
+      end
+    end
+
+    def generation
+      @block.generation if @block
+    end
+
+    def partition
+      @block.partition if @block
+    end
+
+    def brother
+      @block.brother.room if @block && @block.brother
+    end
+
+    def gate_coordinates
+      @connected_rooms.keys
+    end
+
+    def all_connected_rooms
+      @connected_rooms.values
+    end
+
+    def create_passage(randomizer=nil)
+      randomizer ||= Random.new(Time.now.to_i)
+      connectable_rooms.each do |room|
+        create_passage_to(room, randomizer)
+      end
+    end
+
+    # この部屋と通路で接続可能な部屋を返す
+    def connectable_rooms
+      rooms = []
+      # 隣接するブロックに所属する部屋を接続可能とする
+      @block.neighbors.each do |b|
+        rooms << b.room if b.has_room?
+      end
+      rooms
+    end
+
+    # 接続対象の部屋との仕切り(Partition)を返す
+    def select_partition(room)
+      @block.find_ancestor(room.block).partition
+    end
+
+    # 部屋からPartitionに向けて伸ばす通路の出口を決める
+    def get_random_gate(partition, randomizer=nil)
+      randomizer ||= Random.new(Time.now.to_i)
+      if partition.horizontal?
+        if self.y < partition.y
+          # Partitionがこの部屋より下にある
+          gate_y = self.y + @height
+        else
+          # Partitionがこの部屋より上にある
+          gate_y = self.y - 1
+        end
+        gate_x = randomizer.rand((self.x + 1)...(self.x + @width - 1))
+        checker = [[1, 0], [-1, 0]]
+      else
+        if self.x < partition.x
+          # Partitionがこの部屋より右にある
+          gate_x = self.x + @width
+        else
+          # Partitionがこの部屋より左にある
+          gate_x = self.x - 1
+        end
+        gate_y = randomizer.rand((self.y + 1)...(self.y + @height - 1))
+        checker = [[0, 1], [0, -1]]
+      end
+
+      retry_flg = false
+      checker.each do |dx, dy|
+        # となり合うGateが作られた場合はやり直し
+        retry_flg |= true if @connected_rooms[[gate_x + dx, gate_y + dy]]
+      end
+      gate_x, gate_y = get_random_gate(partition, randomizer) if retry_flg
+
+      [gate_x, gate_y]
+    end
+
+    # 自身と引数で渡した部屋とを接続する通路を作成する
+    def create_passage_to(room, randomizer=nil)
+      # 接続済みの部屋とは何もしない
+      return true if all_connected_rooms.include?(room)
+      # 同じ親の同世代の部屋と接続済みなら何もしない
+      return true if brother && brother.all_connected_rooms.include?(room)
+
+      randomizer ||= Random.new(Time.now.to_i)
+      partition = select_partition(room)
+
+      # 部屋から通路への出口を決定
+      gate_xy = self.get_random_gate(partition, randomizer)
+      o_gate_xy = room.get_random_gate(partition, randomizer)
+
+      created_pass = []
+      # 各部屋のGateからPartitionへ伸びる通路を作成
+      [gate_xy, o_gate_xy].each do |gx, gy|
+        if partition.horizontal?
+          created_pass << Passage.new(gx, gy, gx, partition.y)
+        else
+          created_pass << Passage.new(gx, gy, partition.x, gy)
+        end
+      end
+
+      # 上で作られた通路同士を連結する通路を作成
+      created_pass << Passage.new(created_pass[0].end_x, created_pass[0].end_y,
+                                  created_pass[1].end_x, created_pass[1].end_y)
+
+      created_pass.each do |p|
+        @all_pass << p
+        room.all_pass << p
+      end
+      @connected_rooms[gate_xy] = room
+      room.connected_rooms[o_gate_xy] = self
+      true
+    end
+  end
+end