rdgc-dm 0.1.0

data/lib/rdgc/maker/divide_temp_block.rb

@@ -0,0 +1,269 @@
+# coding: UTF-8
+module RDGC
+  module Maker
+    class DivideTempBlock < TempBlock
+
+      attr_accessor :divide_direction
+      attr_writer :depth, :min_size
+
+      def depth
+        @depth ||= 0
+        @depth
+      end
+
+      def min_size
+        @min_size = Util::Config.min_block_size if @min_size.to_i < Util::Config.min_block_size
+        @min_size
+      end
+
+      def min_divide_size
+        min_size * 2
+      end
+
+      def opposite_direction
+        case self.divide_direction
+        when :horizontal
+          :vertical
+        when :vertical
+          :horizontal
+        else
+          nil
+        end
+      end
+
+      def dividable_size?
+        case self.divide_direction
+        when :horizontal
+          height >= min_divide_size ? true : false
+        when :vertical
+          width >= min_divide_size ? true : false
+        else
+          false
+        end
+      end
+
+      def dividable(f = true)
+        @dividable = f
+      end
+
+      def dividable?
+        @dividable
+      end
+
+      def set_dividable
+        return unless dividable_size?
+        dividable
+      end
+
+      def divide_point(val)
+        range_rand(min_size, val - min_divide_size)
+      end
+
+      def divide
+        self.divide_direction ||= select_rand({:horizontal => 1, :vertical => 1})
+        return unless dividable_size?
+
+        case self.divide_direction
+        when :horizontal
+          divide_horizontal
+        when :vertical
+          divide_vertical
+        end
+      end
+
+      def divide_horizontal
+        return unless dividable_size?
+
+        # 分割幅決定
+        point = divide_point(height)
+
+        upper = DivideTempBlock.create(top, top + point - 1, left, right)
+        lower = DivideTempBlock.create(top + point, bottom, left, right)
+
+        set_next_value(upper, lower)
+        [upper, lower].shuffle
+      end
+
+      def divide_vertical
+        return unless dividable_size?
+
+        # 分割点決定
+        point = divide_point(width)
+
+        lefter = DivideTempBlock.create(top, bottom, left, left + point - 1)
+        righter = DivideTempBlock.create(top, bottom, left + point, right)
+
+        set_next_value(lefter, righter)
+        [lefter, righter].shuffle
+      end
+
+      def set_next_value(b1, b2)
+        [b1, b2].each do |b|
+          b.depth = self.depth + 1
+          b.divide_direction = opposite_direction
+          b.min_size = min_size
+        end
+
+        if bool_rand
+          b1.set_dividable
+          b2.set_dividable if bool_rand
+        else
+          b2.set_dividable
+          b1.set_dividable if bool_rand
+        end
+      end
+
+      # for road ----------------------------------------------------
+
+      def road_created(f = true)
+        @road_created = f
+        self
+      end
+
+      def road_created?
+        @road_created
+      end
+
+      def set_road_point(direction, point)
+        @road_point ||= {}
+        @road_point[direction] = point
+      end
+
+      def road_point
+        @road_point ||= {}
+        @road_point
+      end
+
+      def remain_cling_blocks
+        @remain_cling_blocks ||= []
+        @remain_cling_blocks
+      end
+
+      def add_remain_cling_blocks(b)
+        return if b.has_room?
+        remain_cling_blocks << b
+      end
+
+      def has_remain_cling_blocks?
+        remain_cling_blocks.empty? ? false : true
+      end
+
+      def dead_end?
+        return false if has_room?
+        return false unless has_cross_point?
+        road_point.keys.size == 1 ? true : false
+      end
+
+      def remain_direction
+        [:top, :bottom, :left, :right] - road_point.keys
+      end
+
+      def create_road_to(b)
+        return unless (has_room? || has_cross_point?)
+        return unless (b.has_room? || b.has_cross_point?)
+
+        # 相手とどこで接しているか調べる
+        # 接線に向かって道を伸ばす
+        # 左か上に位置する部屋に接続線を引く
+        case cling_direction_to(b)
+        when :top
+          my_x = create_road_for_direction(:top)
+          b_x = b.create_road_for_direction(:bottom)
+          b.create_road_for_adjoin_x(my_x, b_x)
+        when :bottom
+          my_x = create_road_for_direction(:bottom)
+          b_x = b.create_road_for_direction(:top)
+          create_road_for_adjoin_x(my_x, b_x)
+        when :left
+          my_y = create_road_for_direction(:left)
+          b_y = b.create_road_for_direction(:right)
+          b.create_road_for_adjoin_y(my_y, b_y)
+        when :right
+          my_y = create_road_for_direction(:right)
+          b_y = b.create_road_for_direction(:left)
+          create_road_for_adjoin_y(my_y, b_y)
+        end
+      end
+
+      def create_road_for_direction(d)
+        # 道を描くポイントを持っている（すでに道がある）ならそれを返す
+        val = road_point[d]
+        return val if val
+
+        # 新しい道を描く
+        case
+        when has_room?
+          val = create_road_from_room(d)
+        when has_cross_point?
+          val = create_road_from_point(d)
+        end
+
+        val
+      end
+
+      def create_road_from_room(d)
+        return unless has_room?
+        return if road_point[d]
+
+        case d
+        when :top
+          x = range_rand(room.left, room.right)
+          set_road_point(:top, x)
+          add_road(Map::Road.create(top, room.top-1, x, x))
+          x
+        when :bottom
+          x = range_rand(room.left, room.right)
+          set_road_point(:bottom, x)
+          add_road(Map::Road.create(room.bottom+1, bottom, x, x))
+          x
+        when :left
+          y = range_rand(room.top, room.bottom)
+          set_road_point(:left, y)
+          add_road(Map::Road.create(y, y, left, room.left-1))
+          y
+        when :right
+          y = range_rand(room.top, room.bottom)
+          set_road_point(:right, y)
+          add_road(Map::Road.create(y, y, room.right+1, right))
+          y
+        end
+      end
+
+      def create_road_from_point(d)
+        return unless has_cross_point?
+        return if road_point[d]
+
+        x, y = cross_point
+        case d
+        when :top
+          set_road_point(:top, x)
+          add_road(Map::Road.create(top, y, x, x))
+          x
+        when :bottom
+          set_road_point(:bottom, x)
+          add_road(Map::Road.create(y, bottom, x, x))
+          x
+        when :left
+          set_road_point(:left, y)
+          add_road(Map::Road.create(y, y, left, x))
+          y
+        when :right
+          set_road_point(:right, y)
+          add_road(Map::Road.create(y, y, x, right))
+          y
+        end
+      end
+
+      def create_road_for_adjoin_x(x1, x2)
+        p_s, p_e = [x1, x2].sort
+        add_road(Map::Road.create(bottom, bottom, p_s, p_e))
+      end
+
+      def create_road_for_adjoin_y(y1, y2)
+        p_s, p_e = [y1, y2].sort
+        add_road(Map::Road.create(p_s, p_e, right, right))
+      end
+
+    end
+  end
+end

data/lib/rdgc/maker/dungeon_maker.rb

@@ -0,0 +1,57 @@
+# coding: UTF-8
+module RDGC
+  module Maker
+    module DungeonMaker
+
+      def make(width, height, params = nil)
+        @params = params
+        tb = create_whole_block(width, height)
+        @blocks = make_blocks(tb)
+        @blocks.freeze
+        create_room
+        create_road
+        clear_block
+        create_pure_blocks
+      end
+
+      def params
+        @params ||= {}
+        @params
+      end
+
+      def blocks
+        @blocks ||= []
+        @blocks
+      end
+
+      def create_whole_block(width, height)
+      end
+
+      def make_blocks(tb)
+      end
+
+      def create_room
+      end
+
+      def create_road
+      end
+
+      def clear_block
+        return if blocks.size <= 1
+        blocks.each do |b|
+          next if b.has_road?
+          b.remove_all
+        end
+      end
+
+      def create_pure_blocks
+        blocks.inject([]) do |l, b|
+          pb = b.create_pure_block
+          l << pb if pb
+          l
+        end
+      end
+
+    end
+  end
+end

data/lib/rdgc/maker/temp_block.rb

@@ -0,0 +1,23 @@
+# coding: UTF-8
+module RDGC
+  module Maker
+    class TempBlock < Map::Block
+
+      def self.create_whole_block(width, height)
+        left = 0
+        right = width - 1
+        top = 0
+        bottom = height - 1
+        self.create(top, bottom, left, right)
+      end
+
+      def create_pure_block
+        b = Map::Block.create(self.top, self.bottom, self.left, self.right)
+        b.room = self.room if self.has_room?
+        self.roads.each{|r| b.add_road(r) if r}
+        b.empty? ? nil : b
+      end
+
+    end
+  end
+end

data/lib/rdgc/map/area.rb

@@ -0,0 +1,103 @@
+# coding: UTF-8
+module RDGC
+  module Map
+    class Area
+      include TileType
+
+      attr_accessor :top, :bottom, :left, :right
+
+      def self.create(top, bottom, left, right)
+        b = self.new
+        b.top = top
+        b.bottom = bottom
+        b.left = left
+        b.right = right
+        b
+      end
+
+      def coordinates
+        "t:#{top} b:#{bottom} l:#{left} r:#{right} / w:#{width} h:#{height}"
+      end
+
+      alias :to_co :coordinates
+
+      def height
+        bottom - top + 1
+      end
+
+      def width
+        right - left + 1
+      end
+
+      def has_xy?(x, y)
+        return false if x < left
+        return false if x > right
+        return false if y < top
+        return false if y > bottom
+        true
+      end
+
+      def random_point
+        [range_rand(left, right), range_rand(top, bottom)]
+      end
+
+      def each
+        return to_enum(:each) unless block_given?
+        each_x do |x|
+          each_y do |y|
+            yield(x, y)
+          end
+        end
+      end
+
+      def each_x
+        return to_enum(:each_x) unless block_given?
+        (left..right).each do |x|
+          yield(x)
+        end
+      end
+
+      def each_y
+        return to_enum(:each_y) unless block_given?
+        (top..bottom).each do |y|
+          yield(y)
+        end
+      end
+
+      def each_tile
+        return to_enum(:each_tile) unless block_given?
+        each do |x, y|
+          yield(x, y, tile(x, y))
+        end
+      end
+
+      def fill
+        # need override
+      end
+
+      def fill_tile(tile)
+        each do |x, y|
+          set_tile(x, y, tile)
+        end
+      end
+
+      def set_tile(x, y, tile)
+        return unless has_xy?(x, y)
+        tile_data[x][y] = tile
+      end
+
+      def tile(x, y)
+        return unless has_xy?(x, y)
+        tile_data[x][y]
+      end
+
+      private
+
+      def tile_data
+        @tile_data ||= Hash.new{|hash, key| hash[key] = {}}
+        @tile_data
+      end
+
+    end
+  end
+end

data/lib/rdgc/map/block.rb

@@ -0,0 +1,155 @@
+# coding: UTF-8
+module RDGC
+  module Map
+    class Block < Area
+
+      def self.create(top, bottom, left, right)
+        # fillはしない
+        super(top, bottom, left, right)
+      end
+
+      def fill
+        # 初期化
+        fill_tile TileType::WALL
+
+        fill_room
+        fill_roads
+      end
+
+      def fill_room
+        return unless has_room?
+        room.each_tile do |x, y, t|
+          set_tile(x, y, t)
+        end
+      end
+
+      def fill_roads
+        return unless has_road?
+        roads.each do |r|
+          r.each_tile do |x, y, t|
+            set_tile(x, y, t)
+          end
+        end
+      end
+
+      def room
+        @room
+      end
+
+      def room=(r)
+        @room = r
+      end
+
+      def remove_room
+        @room = nil
+      end
+
+      def has_room?
+        @room ? true : false
+      end
+
+      def create_room(opt = nil)
+        @room = Room.create_from_block(self, opt)
+        @room
+      end
+
+      def roads
+        @roads ||= []
+        @roads
+      end
+
+      def add_road(road)
+        @roads ||= []
+        @roads << road
+      end
+
+      def remove_roads
+        @roads = []
+      end
+
+      def has_road?
+        roads.empty? ? false : true
+      end
+
+      def cross_point
+        @cross_point
+      end
+
+      def remove_cross_point
+        @cross_point = nil
+      end
+
+      def has_cross_point?
+        @cross_point ? true : false
+      end
+
+      def create_cross_point
+        # 右と下は接線を引くので余計に空ける
+        x_min = self.left + 1
+        x_max = self.right - 2
+        y_min = self.top + 1
+        y_max = self.bottom - 2
+
+        x = range_rand(x_min, x_max)
+        y = range_rand(y_min, y_max)
+
+        @cross_point = [x, y]
+        @cross_point
+      end
+
+      def remove_all
+        remove_room
+        remove_roads
+        remove_cross_point
+      end
+
+      def empty?
+        return false if has_room?
+        return false if has_road?
+        true
+      end
+
+      def cling_to_top?(b)
+        return false unless top == b.bottom+1
+        return false if left > b.right
+        return false if right < b.left
+        true
+      end
+
+      def cling_to_bottom?(b)
+        return false unless bottom == b.top-1
+        return false if left > b.right
+        return false if right < b.left
+        true
+      end
+
+      def cling_to_left?(b)
+        return false unless left == b.right+1
+        return false if top > b.bottom
+        return false if bottom < b.top
+        true
+      end
+
+      def cling_to_right?(b)
+        return false unless right == b.left-1
+        return false if top > b.bottom
+        return false if bottom < b.top
+        true
+      end
+
+      def cling_direction_to(b)
+        case
+        when cling_to_top?(b)
+          :top
+        when cling_to_bottom?(b)
+          :bottom
+        when cling_to_left?(b)
+          :left
+        when cling_to_right?(b)
+          :right
+        end
+      end
+
+    end
+  end
+end

data/lib/rdgc/map/board.rb

@@ -0,0 +1,81 @@
+# coding: UTF-8
+module RDGC
+  module Map
+    class Board < Area
+
+      def self.create_from_blocks(blocks)
+        d = self.new
+        d.init(blocks)
+        d
+      end
+
+      def init(list)
+        return unless list
+        return if list.empty?
+
+        @blocks = list
+        @rooms = blocks.map(&:room).compact
+        @roads = blocks.map(&:roads).flatten.compact
+
+        set_coordinates
+        fill
+      end
+
+      def set_coordinates
+        return unless blocks
+        self.top = blocks.map(&:top).min
+        self.bottom = blocks.map(&:bottom).max
+        self.left = blocks.map(&:left).min
+        self.right = blocks.map(&:right).max
+      end
+
+      def fill
+        # 初期化
+        fill_tile TileType::WALL
+
+        rooms.each do |r|
+          r.each_tile do |x, y, t|
+            set_tile(x, y, t)
+          end
+        end
+
+        roads.each do |r|
+          r.each_tile do |x, y, t|
+            set_tile(x, y, t)
+          end
+        end
+      end
+
+      def blocks
+        @blocks ||= []
+        @blocks
+      end
+
+      def rooms
+        @rooms ||= []
+        @rooms
+      end
+
+      def roads
+        @roads ||= []
+        @roads
+      end
+
+      def movable?(x, y)
+        return false unless has_xy?(x, y)
+        tile(x, y).movable?
+      end
+
+      def room?(x, y)
+        return false unless has_xy?(x, y)
+        tile(x, y).room?
+      end
+
+      def road?(x, y)
+        return false unless has_xy?(x, y)
+        tile(x, y).road?
+      end
+
+    end
+  end
+end

data/lib/rdgc/map/road.rb

@@ -0,0 +1,18 @@
+# coding: UTF-8
+module RDGC
+  module Map
+    class Road < Area
+
+      def self.create(top, bottom, left, right)
+        road = super(top, bottom, left, right)
+        road.fill
+        road
+      end
+
+      def fill
+        fill_tile TileType::ROAD
+      end
+
+    end
+  end
+end