rdgc-dm 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2010 parrot_studio<parrot *at* users.sourceforge.jp>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,148 @@
+= rdgc-dm
+Author:: parrot_studio <parrot *at* users.sourceforge.jp>
+License:: The MIT License
+
+* 要求されたサイズのランダムダンジョンを生成
+* ダンジョンは部屋と道で構成される
+
+== Install
+ gem install gemcutter # インストール済みなら不要
+ gem install rdgc-dm
+
+== Usage
+ require 'rubygems'
+ require 'rdgc-dm'
+ 
+ include RDGC::Maker
+ 
+ board = DivideDungeonMaker.create(30, 40) # width=30, height=40のMap::Boardを作る場合
+ board = DivideDungeonMaker.create(30, 40, :min_room_count = 4) # パラメータ指定（4つ以上の部屋数を期待）
+ 
+ board.each do |x, y|    # each で各座標を順に処理
+   t = board.tile(x, y)  # Tileオブジェクト取得
+   case
+   when t.wall?          # 壁
+     ...
+   when t.room?          # 部屋
+     ...
+   when t.road?          # 道
+     ...
+   end
+ end
+ 
+ board.each_tile do |x, y, t| # each_tileで座標とTileを一緒に取得
+   ...
+ end
+ 
+ rooms = board.rooms # Map::Roomオブジェクトの配列取得
+ roads = board.roads # Map::Roadオブジェクトの配列取得
+ 
+ r = rooms.choice
+ x, y = r.random_point # あるエリアのランダムな座標を取得
+ 
+ board.room?(2, 3)      # 指定座標(x, y)が部屋か判定
+ board.road?(2, 3)      # 指定座標(x, y)が道か判定
+ board.movable?(2, 3)   # 指定座標(x, y)が移動可能（=部屋or道）か判定
+ 
+ # その他、Map::Areaに定義されたメソッドは全て使える
+ 
+ # RDGC::Util::RandomUtilで定義され、top-levelにinclude済みのメソッド
+ # 数値は全て整数を指定すること
+
+ bool_rand            # trueかfalseを返す
+ range_rand(min, max) # minからmaxまでのどれかの整数値を返す
+ select_rand(:a => 3, :b => 2, :c => 1) # :aを3/(3+2+1)、:bを2/(3+2+1)...の確率で返す
+
+ dice(5, 10)      # 10面のサイコロを5回振った合計を返す
+ 5.dice(10)       # Integer#dice(max)が定義済みで、この場合はdice(5, 10)と同じ 
+ 5.d10            # TRPGプレイヤーにおなじみの書き方
+
+ # その他、細かなメソッドはソースやspec等参照
+
+== Create Parameters
+
+ 前提として、生成パラメータは努力目標
+ できるだけ指定を満たそうとはするが、ランダムなので保証はできない
+ 
+ まず全体を一つのBlockとして定義し、それを再帰的に分割した後、
+ 各Blockに部屋か交差点を作るため、Blockとは1:1の関係になる
+
+* :min_block_size  => 分割Blockの最低サイズ
+* :max_block_count => Blockの最大生成数
+* :min_room_size   => 部屋の最低サイズ（デフォルトは4で、4以下は強制的に4）
+* :max_room_size   => 部屋の最大サイズ
+* :min_room_count  => 部屋の最低生成数（デフォルトは2）
+* :max_room_count  => 部屋の最大生成数
+* :max_depth       => 分割再帰の深さ max_depth=nのとき、Blockの最大数は2^nになる
+* :cross_road_ratio => 交差点生成率（0 <= x <= 9）
+
+== FAQ
+
+=== パラメータが適用されない
+
+ パラメータには適用優先順位があります
+
+1. min_block_size 
+2. max_block_count 
+3. max_depth 
+4. min_room_count 
+5. max_room_count 
+6. cross_road_ratio 
+7. max_room_size 
+8. min_room_size 
+
+ 上位のパラメータに対し、下位のパラメータが矛盾した場合、
+ 無視はしませんが、保証はされません
+
+=== max_room_count=1なのに部屋が2個できる
+
+ min_room_countのデフォルト値が2なので、
+ 上記の優先順位に従い、部屋が2個できます
+ （デフォルトが2個なのは、スタート地点とゴール地点を作るためです）
+ 明示的にmin_room_count=1をあわせて指定すると、一つだけできるはずです
+
+=== 道に（部屋でない）行き止まりができる
+
+ 仕様です
+ 
+ それで片付けるのもあれなので補足すると、
+ つなげられそうな交差点を、できるだけつなぐようにしているものの、
+ 周囲に残りBlockがない等、どうしようもない場合に行き止まりができます
+ 
+ あまりたくさんできると問題ですが、
+ たまにあるくらいはゲームとしていいんじゃないかと
+
+=== 最大分割深度（max_depth）って何？
+
+ DivideDungeonMakerは最初のBlockを起点にして、再帰的な分割をしようとします
+ 
+ この分割回数の最大値がmax_depthの指定で、これを小さくすることで、
+ 小さいBlockだらけになるのを防げます
+ max_depth=nの時、作られるBlockの最大値は2^nです
+
+=== イベントやBOSS用に、広い部屋が1つだけ欲しい
+
+ min_room_sizeをx/y以上にしたうえで、
+ min_block_sizeをx/y以上にするか、max_block_count=1を指定してください
+ 全体が1Blockになり、限界までRoomを大きくしようとします
+
+=== スタートとゴール（階段）って無いの？
+
+ rdgc-dmはあくまで部屋と道（の座標系）を作るための仕組みです
+ スタートやゴールの概念は各ゲームによって異なるため、
+ rdgc-dmには含んでいません（RDGCとしては存在します）
+ 
+ Area#ramdom_pointで各Areaのランダムな座標が取れますので、
+ それを使ってスタートやゴールやモンスターを配置してください
+
+=== 自分でロジックを書きたい
+
+* RDGC::Maker::DungeonMakerをincludeしたクラス
+* RDGC::Maker::TempBlockを継承したクラス
+
+ これらを組み合わせると自分のロジックが書けます
+ 詳しくはDivideDungeonMaker/DivideTempBlockのソースを見てください
+
+== Copyright
+
+Copyright (c) 2010 parrot_studio. See LICENSE for details

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "rdgc-dm"
+    gem.summary = %Q{Random Dungeon Maker from RDGC}
+    gem.description = <<-TXT
+    This gem is part of RDGC - Ruby(Random) Dungeon Game Core.
+    RDGC is core of random dungeon game (like rogue), make dungeon, manage mnsters etc.
+    TXT
+    gem.email = "parrot@users.sourceforge.jp"
+    gem.homepage = "http://github.com/parrot-studio/rdgc-dm"
+    gem.authors = ["parrot_studio"]
+    gem.required_ruby_version = ">= 1.8.7"
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rdgc-dm #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/rdgc/maker/divide_dungeon_maker.rb

@@ -0,0 +1,371 @@
+# coding: UTF-8
+module RDGC
+  module Maker
+    class DivideDungeonMaker
+      include DungeonMaker
+
+      def self.create(width, height, params = nil)
+        dm = self.new
+        list = dm.make(width, height, params)
+        Map::Board.create_from_blocks(list)
+      end
+
+      DEFAULT_CROSS_ROAD_RATIO = 2
+
+      # override
+      def create_whole_block(width, height)
+        tb = DivideTempBlock.create_whole_block(width, height)
+        tb.min_size = min_block_size
+        tb.dividable
+        tb
+      end
+
+      def make_blocks(tb)
+        # 分割キューに最初のBlockを入れる
+        divide_queue << tb
+
+        # 再帰分割
+        divide
+
+        # 完了キューの中身を返す
+        done_queue
+      end
+
+      # override
+      def create_room
+        # 部屋と交差点を分ける
+        room_blocks = []
+        cross_blocks = []
+        force_room_blocks = []
+
+        param = {
+          :room => (10 - cross_road_ratio),
+          :cross => cross_road_ratio
+        }
+
+        blocks.each do |b|
+          # 初回分割のBlockは行き止まりになるので避ける
+          if b.depth < 2
+            force_room_blocks << b
+            next
+          end
+
+          r = select_rand(param)
+          case r
+          when :room
+            room_blocks << b
+          when :cross
+            cross_blocks << b
+          end
+        end
+
+        room_count = room_blocks.size + force_room_blocks.size
+        if max_room_count > 0 && room_count > max_room_count
+          # 超えた分だけ移動する
+          (room_count - max_room_count).times do
+            break if room_blocks.size + force_room_blocks.size <= 1
+            break if room_blocks.empty?
+            b = room_blocks.pickup!
+            cross_blocks << b if b
+          end
+        end
+
+        room_count = room_blocks.size + force_room_blocks.size
+        if room_count < min_room_count
+          # 足りない分を移動する
+          (min_room_count - room_count).times do
+            break if cross_blocks.empty?
+            b = cross_blocks.pickup!
+            room_blocks << b if b
+          end
+        end
+
+        # それぞれのblockを処理
+        [room_blocks, force_room_blocks].flatten.each do |b|
+          b.create_room(:min => min_room_size, :max => max_room_size)
+        end
+        cross_blocks.each{|b| b.create_cross_point}
+      end
+
+      # override
+      def create_road
+        return if blocks.size <= 1
+
+        # 再帰的に道を作成
+        recursive_road_create(blocks.choice)
+
+        # 道がない部屋で、既存と接しているところを処理
+        connect_cling_block_has_road
+
+        # 道がなく、孤立した部屋を移動
+        move_room_and_connect
+
+        # 行き止まりの交差点を処理
+        add_road_for_dead_end
+      end
+
+      # -------------------------------------------------------------
+
+      def min_block_size
+        unless @min_block_size
+          val = params[:min_block_size]
+          if val
+            # 指定がある場合はそれを評価
+            val = val.to_i
+          else
+            # 指定が無く、min_room_sizeが存在するならそちらに合わせる
+            val = (min_room_size ? min_room_size + 3 : 0)
+          end
+          val = Util::Config.min_block_size if val < Util::Config.min_block_size
+          @min_block_size = val
+        end
+        @min_block_size
+      end
+
+      def min_room_size
+        params[:min_room_size]
+      end
+
+      def max_room_size
+        params[:max_room_size]
+      end
+
+      def max_block_count
+        params[:max_block_count].to_i
+      end
+
+      def min_room_count
+        unless @min_room_count
+          val = params[:min_room_count].to_i
+          # 明示的に「1」という指定がない限り2部屋は作る
+          val = 2 if val <= 0
+          @min_room_count = val
+        end
+        @min_room_count
+      end
+
+      def max_room_count
+        params[:max_room_count].to_i
+      end
+
+      def max_depth
+        params[:max_depth].to_i
+      end
+
+      def cross_road_ratio
+        unless @cross_road_ratio
+          val = params[:cross_road_ratio]
+          if val
+            val = val.to_i
+            # 交差点生成率は 1<=x<=9 / 10
+            val = DEFAULT_CROSS_ROAD_RATIO if (val < 0 || val > 9)
+          else
+            # 指定なし => デフォルト
+            val = DEFAULT_CROSS_ROAD_RATIO
+          end
+          @cross_road_ratio = val
+        end
+        @cross_road_ratio
+      end
+
+      def divide_queue
+        @divide_queue ||= []
+        @divide_queue
+      end
+
+      def done_queue
+        @done_queue ||= []
+        @done_queue
+      end
+
+      def queue_size
+        divide_queue.size + done_queue.size
+      end
+
+      def finish?
+        return true if divide_queue.empty?
+        return true if (max_block_count > 0 && queue_size >= max_block_count)
+        false
+      end
+
+      def dividable_block?(b)
+        # そもそも分割対象ではない => false
+        return false unless b.dividable?
+
+        # 最大深度の指定がない => true
+        return true if max_depth <= 0
+
+        # 最大深度に達したら分割しない
+        b.depth >= max_depth ? false : true
+      end
+
+      def divide
+        # 再帰処理
+        loop do
+          break if finish?
+
+          tb = divide_queue.shift
+          break unless tb
+
+          list = tb.divide
+          unless list
+            # 分割できなかったので、元をdone_queueへ
+            done_queue << tb
+            break
+          end
+
+          list.each do |b|
+            if dividable_block?(b)
+              divide_queue << b
+            else
+              done_queue << b
+            end
+          end
+        end
+
+        # queueをまとめる
+        divide_queue.each{|b| done_queue << b}
+      end
+
+      # -------------------------------------------------------------
+
+      def recursive_road_create(target)
+        # 全部道がつながったら終了
+        return if blocks.all?{|b| b.has_road?}
+
+        # まだ道の処理をしてない、接しているblockを探す
+        yet_block = blocks.reject{|b| b.road_created?}
+        cling_list = create_cling_list(target, yet_block)
+
+        # 行き止まり => 終了
+        return if cling_list.size <= 0
+
+        # 接しているblockに道を作る
+        next_block = connect_cling_blocks(target, cling_list)
+
+        # 作成完了
+        target.road_created
+
+        # 次を再帰的呼び出し
+        recursive_road_create(next_block)
+      end
+
+      def connect_cling_block_has_road
+        # 道がない部屋を探す
+        remains = blocks.select{|b| b.has_room? && ! b.has_road?}
+        return if remains.empty?
+
+        # すでに完了しているblockの数を確認
+        done_count = blocks.select{|b| b.has_room? && b.has_road?}.size
+
+        remains.each do |target|
+          # min_room_countを満たすならランダム
+          if done_count >= min_room_count
+            next unless bool_rand
+          end
+
+          # 接しているblockに道があるならつなぐ
+          c_list = create_cling_list(target, blocks.select{|b| b.has_road?}).flatten
+          return if c_list.empty?
+          target.create_road_to(c_list.pickup!)
+          c_list.each{|b| target.add_remain_cling_blocks(b)}
+
+          done_count += 1
+        end
+      end
+
+      def move_room_and_connect
+        # 完了してしたblockの数を確認し、min_room_countを満たしていたら終わり
+        done_count = blocks.select{|b| b.has_room? && b.has_road?}.size
+        return if done_count >= min_room_count
+
+        # まだ道がない部屋を探す
+        remains = blocks.select{|b| b.has_room? && ! b.has_road?}
+        return if remains.empty?
+
+        remains.each do |target|
+          # 元の部屋等の削除
+          target.remove_all
+
+          # 改めて部屋を作る先を決める
+          enable_blocks = blocks.select{|b| b.has_remain_cling_blocks?}
+          next if enable_blocks.empty?
+
+          org_block = enable_blocks.choice
+          room_block = org_block.remain_cling_blocks.pickup!
+
+          # 部屋作成
+          room_block.create_room(:min => min_room_size, :max => max_room_size)
+
+          # 接続
+          room_block.create_road_to(org_block)
+        end
+      end
+
+      def create_cling_list(block, list)
+        top_list = collect_cling_block(block, list,:top)
+        bottom_list = collect_cling_block(block, list, :bottom)
+        left_list = collect_cling_block(block, list, :left)
+        right_list = collect_cling_block(block, list, :right)
+
+        [top_list, bottom_list, left_list, right_list].select{|a| a.size > 0}
+      end
+
+      def collect_cling_block(block, list, direction)
+        case direction
+        when :top
+          list.select{|b| block.cling_to_top?(b)}
+        when :bottom
+          list.select{|b| block.cling_to_bottom?(b)}
+        when :left
+          list.select{|b| block.cling_to_left?(b)}
+        when :right
+          list.select{|b| block.cling_to_right?(b)}
+        end
+      end
+
+      def connect_cling_blocks(target, cling_list)
+        return unless cling_list
+        return if cling_list.size <= 0
+
+        # 4方向で選択可能なblock配列から一つ選ぶ
+        direction_list = cling_list.pickup!
+        next_block = direction_list.pickup!
+
+        # ブロックに道をつなぐ
+        target.create_road_to(next_block)
+
+        # その方向の残りを接しているblockとして記録
+        direction_list.each{|b| target.add_remain_cling_blocks(b)}
+
+        # 残りの方向もランダムにつなぐ
+        cling_list.each do |d_list|
+          bl = d_list.pickup! if bool_rand
+          target.create_road_to(bl) if bl
+          d_list.each{|b| target.add_remain_cling_blocks(b)}
+        end
+
+        # 次の対象返却
+        next_block
+      end
+
+      def add_road_for_dead_end
+        deadends = blocks.select{|b| b.dead_end?}
+        return if deadends.empty?
+
+        deadends.each do |target|
+          # まだ作成していない方向に何か接しているか？
+          c_list = []
+          block_list = blocks.select{|b| b.has_road?}
+          target.remain_direction.each do |d|
+            ret = collect_cling_block(target, block_list, d)
+            c_list += ret.flatten
+          end
+          next if c_list.empty?
+          target.create_road_to(c_list.pickup!)
+        end
+      end
+
+    end
+  end
+end