rdgc-dm 0.1.0

data/spec/rdgc/maker/03_divide_dungeon_maker_divide_spec.rb

@@ -0,0 +1,224 @@
+# coding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '../../../spec_helper')
+
+include RDGC::Map
+include RDGC::Maker
+
+describe RDGC::Maker::DivideDungeonMaker, 'is divide block by recursive' do
+
+  describe "each acceptable params" do
+
+    it "min_room_size, max_room_size" do
+      maker = DivideDungeonMaker.new
+      maker.min_room_size.should be_nil
+      maker.max_room_size.should be_nil
+
+      maker.params[:min_room_size] = 5
+      maker.params[:max_room_size] = 20
+
+      maker.min_room_size.should == 5
+      maker.max_room_size.should == 20
+    end
+
+    it "min_block_size" do
+      # デフォルト
+      maker = DivideDungeonMaker.new
+      maker.min_block_size.should == Util::Config.min_block_size
+
+      # デフォルトより小さいとデフォルト
+      maker = DivideDungeonMaker.new
+      maker.params[:min_block_size] = 1
+      maker.min_block_size.should == Util::Config.min_block_size
+
+      maker = DivideDungeonMaker.new
+      maker.params[:min_block_size] = 10
+      maker.min_block_size.should == 10
+
+      # 一度読むと書き換えできない
+      maker.params[:min_block_size] = 20
+      maker.min_block_size.should == 10
+
+      # min_room_sizeが存在し、min_block_sizeが存在しない場合、影響を受ける
+      maker = DivideDungeonMaker.new
+      maker.params[:min_room_size] = 5
+      maker.min_block_size.should == 8
+    end
+
+    it "min_room_count" do
+      # デフォルトは2
+      maker = DivideDungeonMaker.new
+      maker.min_room_count.should == 2
+
+      # 値は一度だけセットできる
+      maker = DivideDungeonMaker.new
+      maker.params[:min_room_count] = 3
+      maker.min_room_count.should == 3
+      maker.params[:min_room_count] = 5
+      maker.min_room_count.should == 3
+
+      # 明示的に1を指定すると1
+      maker = DivideDungeonMaker.new
+      maker.params[:min_room_count] = 1
+      maker.min_room_count.should == 1
+
+      # 0以下ならデフォルト
+      maker = DivideDungeonMaker.new
+      maker.params[:min_room_count] = 0
+      maker.min_room_count.should == 2
+    end
+
+    it "max_room_count" do
+      maker = DivideDungeonMaker.new
+      maker.max_room_count.should == 0
+
+      maker.params[:max_room_count] = 8
+      maker.max_room_count.should == 8
+    end
+
+    it "max_depth" do
+      maker = DivideDungeonMaker.new
+      maker.max_depth.should == 0
+
+      maker.params[:max_depth] = 3
+      maker.max_depth.should == 3
+    end
+
+    it "cross_road_ratio" do
+      # デフォルトは2
+      maker = DivideDungeonMaker.new
+      maker.cross_road_ratio.should == DivideDungeonMaker::DEFAULT_CROSS_ROAD_RATIO
+
+      # 値は一度だけセットできる
+      maker = DivideDungeonMaker.new
+      maker.params[:cross_road_ratio] = 3
+      maker.cross_road_ratio.should == 3
+      maker.params[:cross_road_ratio] = 5
+      maker.cross_road_ratio.should == 3
+
+      # 0未満ならデフォルト
+      maker = DivideDungeonMaker.new
+      maker.params[:cross_road_ratio] = -1
+      maker.cross_road_ratio.should == 2
+
+      # 0はセット可能
+      maker = DivideDungeonMaker.new
+      maker.params[:cross_road_ratio] = 0
+      maker.cross_road_ratio.should == 0
+
+      # 9を超えるならデフォルト
+      maker = DivideDungeonMaker.new
+      maker.params[:cross_road_ratio] = 10
+      maker.cross_road_ratio.should == 2
+    end
+
+  end
+
+  describe "divide whole_block" do
+
+    it "divide_queue store dividable block, and done_queue store divided block" do
+      maker = DivideDungeonMaker.new
+      maker.queue_size.should == 0
+
+      maker.divide_queue << DivideTempBlock.create_whole_block(20, 20)
+      maker.divide_queue.size.should == 1
+      maker.queue_size.should == 1
+
+      maker.done_queue << DivideTempBlock.create_whole_block(20, 20)
+      maker.done_queue.size.should == 1
+      maker.queue_size.should == 2
+    end
+
+    it "#finish? will check divide end" do
+      maker = DivideDungeonMaker.new
+      maker.finish?.should be_true
+
+      maker.done_queue << DivideTempBlock.create_whole_block(20, 20)
+      maker.finish?.should be_true
+
+      maker.divide_queue << DivideTempBlock.create_whole_block(20, 20)
+      maker.finish?.should be_false
+
+      maker.params[:max_block_count] = 3
+      maker.finish?.should be_false
+
+      maker.done_queue << DivideTempBlock.create_whole_block(20, 20)
+      maker.finish?.should be_true
+    end
+
+    it "#dividable_block? check block dividable" do
+      # max_depthの指定がない場合
+      maker = DivideDungeonMaker.new
+      b = DivideTempBlock.create_whole_block(20, 20)
+
+      maker.dividable_block?(b).should be_false
+      b.dividable
+      maker.dividable_block?(b).should be_true
+
+      # max_depthが指定されている場合
+      maker = DivideDungeonMaker.new
+      maker.params[:max_depth] = 3
+      b = DivideTempBlock.create_whole_block(20, 20)
+
+      b.dividable
+      maker.dividable_block?(b).should be_true
+      b.depth = 3
+      maker.dividable_block?(b).should be_false
+    end
+
+    it "create_whole_block" do
+      maker = DivideDungeonMaker.new
+      tb = maker.create_whole_block(30, 40)
+      tb.should be_an_instance_of(DivideTempBlock)
+      tb.width.should == 30
+      tb.height.should == 40
+      tb.min_size.should == Util::Config.min_block_size
+      tb.dividable?.should be_true
+    end
+
+    it "divide block" do
+      each_create_block do |b|
+        b.should be_an_instance_of(DivideTempBlock)
+      end
+    end
+
+    it "min_block_size/max_block_count/max_depth affect divide as possible" do
+      10.times do
+        each_create_block(:min_block_size, 6) do |b|
+          b.should be_an_instance_of(DivideTempBlock)
+          b.width.should >= 6
+          b.height.should >= 6
+        end
+      end
+
+      10.times do
+        count = 0
+        each_create_block(:max_block_count, 5) do |b|
+          b.should be_an_instance_of(DivideTempBlock)
+          count += 0
+        end
+        count.should <= 5
+      end
+
+      10.times do
+        count = 0
+        each_create_block(:max_depth, 3) do |b|
+          b.should be_an_instance_of(DivideTempBlock)
+          b.depth <= 3
+          count += 1
+        end
+        count.should <= 8
+      end
+    end
+
+    def each_create_block(name = nil, val = nil)
+      maker = DivideDungeonMaker.new
+      maker.params[name] = val if name && val
+      tb = maker.create_whole_block(40, 40)
+      bl = maker.make_blocks(tb)
+
+      bl.each{|b| yield(b)}
+    end
+
+  end
+
+end

data/spec/rdgc/maker/04_divide_dungeon_maker_create_spec.rb

@@ -0,0 +1,244 @@
+# coding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '../../../spec_helper')
+
+include RDGC::Map
+include RDGC::Maker
+
+describe RDGC::Maker::DivideDungeonMaker, 'create room/road for each block' do
+
+  describe "create room" do
+
+    it "create_room by default" do
+      10.times do
+        maker = create_maker_with_blocks
+        maker.create_room
+
+        maker.blocks.each do |b|
+          rsl_room = b.has_room?
+          rsl_cross = b.has_cross_point?
+          (rsl_room || rsl_cross).should be_true
+          (rsl_room && rsl_cross).should be_false
+        end
+
+        maker.blocks.select{|b| b.has_room?}.size.should >= 2
+      end
+    end
+
+    it "min_room_size/max_room_size affect room size" do
+      val = 5
+
+      10.times do
+        maker = create_maker_with_blocks(:min_room_size => val)
+        maker.create_room
+
+        maker.blocks.select{|b| b.has_room?}.map{|b| b.room}.each do |r|
+          r.width.should >= val
+          r.height.should >= val
+        end
+      end
+
+      10.times do
+        maker = create_maker_with_blocks(:max_room_size => val)
+        maker.create_room
+
+        maker.blocks.select{|b| b.has_room?}.map{|b| b.room}.each do |r|
+          r.width.should <= val
+          r.height.should <= val
+        end
+      end
+    end
+
+    it "min_room_count/max_room_count affect room count" do
+      10.times do
+        maker = create_maker_with_blocks(:min_room_count => 3)
+        maker.create_room
+        maker.blocks.select{|b| b.has_room?}.size.should >= 3
+      end
+
+      10.times do
+        maker = create_maker_with_blocks(:max_room_count => 3)
+        maker.create_room
+        maker.blocks.select{|b| b.has_room?}.size.should <= 3
+      end
+
+      10.times do
+        maker = create_maker_with_blocks(:min_room_count => 1, :max_room_count => 1)
+        maker.create_room
+        maker.blocks.select{|b| b.has_room?}.size.should == 1
+      end
+
+    end
+
+    it "cross_road_ratio affect room create" do
+      10.times do
+        maker = create_maker_with_blocks(:cross_road_ratio => 9)
+        maker.create_room
+
+        all_size = maker.blocks.size
+        maker.blocks.select{|b| b.has_room?}.size.should >= 2
+        maker.blocks.select{|b| b.has_cross_point?}.size.should <= all_size - 2
+      end
+
+      10.times do
+        maker = create_maker_with_blocks(:cross_road_ratio => 0)
+        maker.create_room
+
+        all_size = maker.blocks.size
+        maker.blocks.select{|b| b.has_room?}.size.should == all_size
+        maker.blocks.select{|b| b.has_cross_point?}.size.should == 0
+      end
+    end
+
+  end
+
+  describe "create road" do
+
+    it "room block should has roads, if min_room_count too big" do
+      10.times do
+        maker = create_maker_with_blocks(:min_room_count => 99)
+        maker.create_room
+        maker.create_road
+
+        maker.blocks.select{|b| b.has_room?}.each do |b|
+          b.has_road?.should be_true
+        end
+      end
+    end
+
+    it "no create road if only one block" do
+      maker = create_maker_with_blocks(:min_block_size => 99)
+      maker.create_room
+      maker.blocks.size.should == 1
+
+      maker.create_road
+      maker.blocks.select{|b| b.has_road?}.should be_empty
+    end
+
+    it "#move_room_and_connect spec" do
+
+      b1 = DivideTempBlock.create(0, 10, 0, 10)
+      b2 = DivideTempBlock.create(0, 10, 11, 20)
+      b3 = DivideTempBlock.create(0, 10, 21, 30)
+      b4 = DivideTempBlock.create(0, 10, 31, 40)
+
+      b1.create_room
+      b2.create_room
+      b4.create_room
+      b1.create_road_to(b2)
+      b2.add_remain_cling_blocks(b3)
+
+      maker = DivideDungeonMaker.new
+      maker.instance_eval do
+        @params = {:min_room_count => 10}
+        @blocks = [b1, b2, b3, b4]
+      end
+
+      maker.move_room_and_connect
+
+      b3.has_room?.should be_true
+      b3.has_road?.should be_true
+      b4.has_room?.should be_false
+      b4.has_road?.should be_false
+    end
+
+  end
+
+  describe "make all" do
+
+    it "create provide complete board" do
+      board = DivideDungeonMaker.create(40, 40)
+      board.should be_an_instance_of(Map::Board)
+      board.blocks.select{|b| b.has_room?}.each do |b|
+        b.should be_an_instance_of(Block)
+        b.should_not be_an_instance_of(DivideTempBlock)
+        b.has_road?.should be_true
+      end
+    end
+
+    it "create accept params" do
+      params = {}
+      params[:min_room_size] = 5
+      params[:max_room_size] = 10
+      params[:min_block_size] = 8
+      params[:min_room_count] = 3
+      params[:max_room_count] = 8
+      params[:max_depth] = 4
+      params[:cross_road_ratio] = 4
+
+      10.times do
+        board = DivideDungeonMaker.create(80, 80, params)
+        board.should be_an_instance_of(Map::Board)
+
+        board.blocks.size.should <= 16 # depth
+
+        room_count = 0
+        board.blocks.each do |b|
+          b.should be_an_instance_of(Block)
+          b.should_not be_an_instance_of(DivideTempBlock)
+
+          b.width.should >= params[:min_block_size]
+          b.height.should >= params[:min_block_size]
+
+          next unless b.has_room?
+          room = b.room
+
+          room.width.should >= params[:min_room_size]
+          room.width.should <= params[:max_room_size]
+          room.height.should >= params[:min_room_size]
+          room.height.should <= params[:max_room_size]
+
+          room_count += 1
+        end
+        room_count.should >= params[:min_room_count]
+        room_count.should <= params[:max_room_count]
+      end
+    end
+
+    it "only one block board" do
+      params = {}
+      params[:min_room_count] = 1
+      params[:max_room_count] = 1
+      params[:min_block_size] = 99
+
+      10.times do
+        board = DivideDungeonMaker.create(40, 40, params)
+        board.should be_an_instance_of(Map::Board)
+
+        board.blocks.size.should == 1
+        board.blocks.map(&:room).size.should == 1
+        board.blocks.inject([]){|l, b| l + b.roads}.should be_empty
+      end
+    end
+
+    it "only room board" do
+      10.times do
+        board = DivideDungeonMaker.create(40, 40, :cross_road_ratio => 0)
+        board.should be_an_instance_of(Map::Board)
+
+        board.blocks.each do |b|
+          b.has_room?.should be_true
+          b.has_road?.should be_true
+          b.has_cross_point?.should be_false
+        end
+      end
+    end
+
+  end
+
+  def create_maker_with_blocks(params = nil)
+    maker = DivideDungeonMaker.new
+    maker.instance_eval do
+      @params = params
+    end
+
+    tb = maker.create_whole_block(40, 40)
+    bl = maker.make_blocks(tb)
+
+    bl.each do |b|
+      maker.blocks << b
+    end
+
+    maker
+  end
+
+end

data/spec/rdgc/map/01_tile_spec.rb

@@ -0,0 +1,56 @@
+# coding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '../../../spec_helper')
+
+include RDGC::Map
+
+describe RDGC::Map::Tile do
+
+  it "created for :out" do
+    t = Tile.new(:out)
+    t.out?.should be_true
+    t.movable?.should be_false
+  end
+
+  it "created for :wall" do
+    t = Tile.new(:wall)
+    t.wall?.should be_true
+    t.movable?.should be_false
+  end
+
+  it "created for :room" do
+    t = Tile.new(:room)
+    t.room?.should be_true
+    t.movable?.should be_true
+  end
+
+  it "created for :road" do
+    t = Tile.new(:road)
+    t.road?.should be_true
+    t.movable?.should be_true
+  end
+
+  it "TileType::OUT behaves for :out" do
+    t = TileType::OUT
+    t.out?.should be_true
+    t.movable?.should be_false
+  end
+
+  it "TileType::WALL behaves for :wall" do
+    t = TileType::WALL
+    t.wall?.should be_true
+    t.movable?.should be_false
+  end
+
+  it "TileType::ROOM behaves for :room" do
+    t = TileType::ROOM
+    t.room?.should be_true
+    t.movable?.should be_true
+  end
+
+  it "TileType::ROAD behaves for :road" do
+    t = TileType::ROAD
+    t.road?.should be_true
+    t.movable?.should be_true
+  end
+
+end

data/spec/rdgc/map/02_area_spec.rb

@@ -0,0 +1,118 @@
+# coding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '../../../spec_helper')
+
+include RDGC::Map
+
+describe RDGC::Map::Area, "provide area, filled with Tile" do
+
+  before(:all) do
+    @top = 8
+    @bottom = 10
+    @left = 11
+    @right = 19
+
+    @area = Area.new
+    @area.top = @top
+    @area.bottom = @bottom
+    @area.left = @left
+    @area.right = @right
+  end
+
+  it "top <= bottom, left <= right" do
+    (@top <= @bottom).should be_true
+    (@left <= @right).should be_true
+  end
+
+  it "#height should be (bottom - top + 1)" do
+    @area.height.should == (@bottom - @top + 1)
+  end
+
+  it "#width should be (right - left + 1)" do
+    @area.width.should == (@right - @left + 1)
+  end
+
+  it "#coordinates/#to_co puts params" do
+    expect = "t:#{@top} b:#{@bottom} l:#{@left} r:#{@right} / w:#{@area.width} h:#{@area.height}"
+    @area.coordinates.should == expect
+    @area.to_co.should == expect
+  end
+
+  it "#has_xy? should be true if in area, false out of area, for (x, y)" do
+    @area.has_xy?(@left, @top).should be_true
+    @area.has_xy?(@left-1, @top).should be_false
+    @area.has_xy?(@left, @top-1).should be_false
+    @area.has_xy?(@right, @bottom).should be_true
+    @area.has_xy?(@right+1, @bottom).should be_false
+    @area.has_xy?(@right, @bottom+1).should be_false
+  end
+
+  it "#each_x provides each left to right" do
+    last = nil
+    @area.each_x.with_index do |x, i|
+      x.should == @left + i
+      last = @left + i
+    end
+    last.should == @right
+  end
+
+  it "#each_y provides each top to bottom" do
+    last = nil
+    @area.each_y.with_index do |y, i|
+      y.should == @top + i
+      last = @top + i
+    end
+    last.should == @bottom
+  end
+
+  it "#each provides all coordinates" do
+    @area.each do |x, y|
+      @area.has_xy?(x, y).should be_true
+    end
+
+    cs = @area.each
+    cs.should be_kind_of(Enumerable)
+    cs.each do |x, y|
+      @area.has_xy?(x, y).should be_true
+    end
+  end
+
+  it "#fill_tile set tile for all coordinates" do
+    @area.fill_tile(TileType::WALL)
+    @area.each do |x, y|
+      @area.tile(x, y).should  == TileType::WALL
+    end
+  end
+
+  it "#each_tile provides each coordinate's tile" do
+    @area.fill_tile(TileType::ROAD)
+    @area.each_tile do |x, y, t|
+      t.should == TileType::ROAD
+    end
+
+    ts = @area.each_tile
+    ts.should be_kind_of(Enumerable)
+    tiles = ts.to_a.map{|a| a.last}
+    tiles.all?{|t| t == TileType::ROAD}
+  end
+
+  it "#set_tile will set tile object for (x, y)" do
+    @area.set_tile(@left, @top, TileType::ROOM).should be_an_instance_of(Tile)
+    t = @area.tile(@left, @top)
+    t.should be_an_instance_of(Tile)
+    t.should == TileType::ROOM
+  end
+
+  it "#set_tile failed, and #tile is nil, if out of area" do
+    @area.set_tile(@left-1, @top-1, TileType::ROOM).should be_nil
+    t = @area.tile(@left-1, @top-1)
+    t.should be_nil
+  end
+
+  it "#random_point provides random point in area" do
+    10.times do
+      x, y = @area.random_point
+      @area.has_xy?(x, y).should be_true
+    end
+  end
+
+end

data/spec/rdgc/map/03_road_spec.rb

@@ -0,0 +1,23 @@
+# coding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '../../../spec_helper')
+
+include RDGC::Map
+
+describe RDGC::Map::Road, "is Area, filled with TileType::ROAD" do
+
+  before do
+    @top = 8
+    @bottom = 8
+    @left = 11
+    @right = 19
+
+    @road = Road.create(@top, @bottom, @left, @right)
+  end
+
+  it "filled with TileType::ROAD" do
+    @road.each_tile do |x, y, t|
+      t.should == TileType::ROAD
+    end
+  end
+
+end