automaze 0.0.0

data/LICENSE

@@ -0,0 +1,24 @@
+automazerb
+
+The MIT License
+
+Copyright (c) 2010 Toshiyuki Hirooka <toshi.hirooka@gmail.com>
+
+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,27 @@
+
+= automazerb
+
+== description
+automazerb is maze generator library for ruby.
+
+== usage
+
+  require "automaze"
+  maze = Automaze::Automaze.new
+  puts maze
+
+  panel = maze.panels(3,4)
+  panel.wall? #=> true or false
+
+  maze.each_panels do |panel,x,y|
+    if panel.wall?
+      print "XX"
+    else
+      print "  "
+    end
+  end
+
+specifying generation algorithm
+
+  Automaze::Automaze.new(:algorithm=>:boutaoshi)
+

data/Rakefile

@@ -0,0 +1,30 @@
+# coding: utf-8
+
+require "rake"
+require "rspec/core/rake_task"
+
+task :default => [:spec]
+
+desc "spec all"
+RSpec::Core::RakeTask.new do |t|
+  t.name = "spec"
+  t.pattern = "spec/*_spec.rb"
+end
+
+desc "run sample"
+task :run do
+  sh "ruby sample.rb"
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "automaze"
+    gemspec.summary = "maze generator"
+    gemspec.email = "toshi.hirooka@gmail.com"
+    gemspec.homepage = "http://github.com/tosik/automazerb"
+    gemspec.description = "maze generator"
+    gemspec.authors = ["Toshiyuki Hirooka"]
+  end
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/algorithms/boutaoshi.rb

@@ -0,0 +1,31 @@
+# coding: utf-8
+
+module Boutaoshi
+  def generate
+    init_panels
+
+    each_panels do |panel, x, y|
+      if post?(x,y) && y == 2
+        random_floor(four_panels(x,y)).set_kind(:wall)
+      end
+    end
+
+    each_panels do |panel, x, y|
+      if post?(x,y) && y != 2
+        random_floor(three_panels(x,y)).set_kind(:wall)
+      end
+    end
+  end
+
+  def init_panels
+    each_panels do |panel, x, y|
+      panel.set_kind(:floor)
+      panel.set_kind(:wall) if post?(x,y)
+    end
+  end
+
+  def post?(x,y)
+    ( x % 2 ) == 1 && ( y % 2 ) == 1
+  end
+end
+

data/lib/algorithms/dug_tunnels.rb

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+module DugTunnels
+  def init_panels
+    each_panels do |panel, x, y|
+      panel.set_kind(:wall)
+    end
+  end
+
+  def generate
+    init_panels
+
+    # start point
+    xy = random_even_xy
+    panels(*xy).set_kind(:floor)
+
+    while !dug_all?
+
+      # select random floor
+      begin
+        xy = random_even_xy
+      end while panels(*xy).wall?
+
+      while can_dig(*xy)
+        dir = random_direction
+        next_xy = next_xy(*xy, dir)
+        next_panel = panels(*next_xy)
+        if next_panel.wall? && !out_of_map?(*next_xy)
+          dig(*xy, dir)
+          xy = next_xy
+        end
+      end
+    end
+  end
+
+  def random_direction
+    return rand(4)
+    @dir ||= 0
+    @dir += 1
+    @dir = 0 if @dir == 4
+    @dir
+  end
+
+  def next_xy(x, y, dir)
+    [
+      [x-2,y],
+      [x+2,y],
+      [x,y-2],
+      [x,y+2],
+    ].at(dir)
+  end
+
+  def next_panel(x, y, dir)
+    panels(*next_xy(x, y, dir))
+  end
+
+  def random_even_xy
+    [rand(@size_x/2 + 1) * 2, rand(@size_y/2 + 1) * 2]
+  end
+
+  def can_dig(x, y)
+    (0..3).each do |dir|
+      unless out_of_map?(*next_xy(x, y, dir))
+        return true if next_panel(x, y, dir).wall?
+      end
+    end
+    return false
+  end
+
+  def dug_all?
+    each_panels do |panel, x, y|
+      if ( x % 2 ) == 0 && ( y % 2 ) == 0
+        return false if panel.wall?
+      end
+    end
+
+    return true
+  end
+
+  def dig(x, y, dir)
+    xy = next_xy(x, y, dir)
+    panels(*xy).set_kind(:floor)
+
+    diff = [xy[0] - x, xy[1] - y]
+    if diff[0] == 0
+      panels(x, xy[1] - 1).set_kind(:floor) if diff[1] > 0
+      panels(x, xy[1] + 1).set_kind(:floor) if diff[1] < 0
+    end
+    if diff[1] == 0
+      panels(xy[0] - 1, y).set_kind(:floor) if diff[0] > 0
+      panels(xy[0] + 1, y).set_kind(:floor) if diff[0] < 0
+    end
+  end
+end
+

data/lib/automaze.rb

@@ -0,0 +1,112 @@
+# coding: utf-8
+
+# The MIT License
+#
+# Copyright (c) 2010 Toshiyuki Hirooka <toshi.hirooka@gmail.com>
+#
+# 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.
+
+require "active_support/inflector"
+require_relative "panel"
+
+module Automaze
+  class Automaze
+    DEFAULT_ALGORITHM = :boutaoshi
+
+    class << self
+      def include_algorithm(algorithm)
+        raise "cannot include because algorithm is nil" if algorithm.nil?
+        require_relative "algorithms/#{algorithm.to_s}"
+        include algorithm.to_s.camelize.constantize
+      end
+    end
+
+    def initialize(options={})
+      @panels = {}
+
+      @size_x = options.delete(:size_x) || 30
+      @size_y = options.delete(:size_y) || 20
+      self.class.include_algorithm options.delete(:algorithm) || DEFAULT_ALGORITHM
+      self.generate # included algorithm
+    end
+    attr_reader :size_x
+    attr_reader :size_y
+
+    # nil panel is wall
+    def panels(x,y)
+      @panels[[x,y]] ||= Panel.new(:wall)
+    end
+
+    def each_panels
+      (0..@size_y).each do |y|
+        (0..@size_x).each do |x|
+          yield(panels(x,y), x, y)
+        end
+      end
+    end
+
+    def four_panels(x,y)
+      [
+        panels(x-1,y),
+        panels(x+1,y),
+        panels(x,y-1),
+        panels(x,y+1),
+      ]
+    end
+
+    def three_panels(x,y)
+      [
+        panels(x-1,y),
+        panels(x+1,y),
+        panels(x,y+1),
+      ]
+    end
+
+    def random_floor(panels)
+      loop do
+        panel = panels[rand(panels.length)]
+        return panel if panel.floor?
+      end
+    end
+
+    def out_of_map?(x, y)
+      return true if x < 0
+      return true if x > @size_x
+      return true if y < 0
+      return true if y > @size_y
+      return false
+    end
+
+    def to_s
+      str = ""
+      (-1..@size_y+1).each {|y|
+        (-1..@size_x+1).each {|x|
+          if panels(x,y).wall?
+            str += "XX"
+          else
+            str += "  "
+          end
+        }
+        str += "\n"
+      }
+      return str
+    end
+  end
+end
+

data/lib/panel.rb

@@ -0,0 +1,27 @@
+# coding: utf-8
+
+module Automaze
+  class Panel
+    def initialize(kind)
+      set_kind(kind)
+    end
+
+    PANEL_KINDS = [:floor, :wall]
+
+    def kind_valid?(kind)
+      PANEL_KINDS.include? kind
+    end
+
+    PANEL_KINDS.each do |kind|
+      define_method("#{kind}?") do
+        @kind == kind
+      end
+    end
+
+    def set_kind(kind)
+      raise "unknown kind" unless kind_valid?(kind)
+      @kind = kind
+    end
+
+  end
+end

data/sample.rb

@@ -0,0 +1,24 @@
+$: << "lib"
+require "automaze"
+
+algorithm = ARGV[0] || :dug_tunnels
+maze = Automaze::Automaze.new(
+  :algorithm=>algorithm,
+  :size_x=>40,
+  :size_y=>30)
+
+# building rooms
+5.times do
+  room_size_x = rand(2) * 2 + 1
+  room_size_y = rand(2) * 2 + 1
+  center_x = rand(maze.size_x/2-room_size_x)*2 + room_size_x
+  center_y = rand(maze.size_y/2-room_size_y)*2 + room_size_y
+  (-room_size_x..room_size_x).each do |x|
+    (-room_size_y..room_size_y).each do |y|
+      maze.panels(x+center_x,y+center_y).set_kind(:floor)
+    end
+  end
+end
+
+puts maze
+

data/spec/automaze_spec.rb

@@ -0,0 +1,46 @@
+# coding: utf-8
+
+require_relative "../lib/automaze"
+
+describe Automaze::Automaze do
+  describe "self.include_algorithm" do
+    it "includes algorithm module" do
+      lambda { Automaze::Automaze.include_algorithm(:boutaoshi) }.should_not raise_error
+    end
+  end
+
+  describe "new" do
+    it "returns Automaze class" do
+      Automaze::Automaze.new.class.should == Automaze::Automaze
+    end
+
+    describe "using options" do
+      describe ":algorithm" do
+        it "accepts :boutaoshi" do
+          lambda { Automaze::Automaze.new(:algorithm=>:boutaoshi) }.should_not raise_error
+        end
+        it "doesnt accept :invalid_algorithm" do
+          lambda { Automaze::Automaze.new(:algorithm=>:invalid_algorithm) }.should raise_error
+        end
+      end
+    end
+  end
+
+  describe "instance" do
+    before :each do
+      @maze = Automaze::Automaze.new
+    end
+
+    describe "panels" do
+      it "returns wall panel when panel is nil" do
+        @maze.panels(-123, -456).wall?.should be_true
+      end
+      it "returns wall panel when panel is floor" do
+        @maze.panels(-123, -456).set_kind(:floor)
+        @maze.panels(-123, -456).floor?.should be_true
+      end
+    end
+
+  end
+end
+

data/spec/panel_spec.rb

@@ -0,0 +1,39 @@
+# coding: utf-8
+
+require_relative "../lib/panel"
+
+describe Automaze::Panel do
+  describe "check kind of panel; exp) wall?, floor?" do
+    it "returns true when correct kind" do
+      Automaze::Panel.new(:wall).wall?.should be_true
+      Automaze::Panel.new(:floor).floor?.should be_true
+    end
+    it "returns true when incorrect kind" do
+      Automaze::Panel.new(:floor).wall?.should be_false
+      Automaze::Panel.new(:wall).floor?.should be_false
+    end
+  end
+
+  describe "new by invalid kind" do
+    it "raises error" do
+      lambda { Automaze::Panel.new(:this_is_invalid_kind) }.should raise_error
+    end
+  end
+
+  describe "instance" do
+    before :each do
+      @wall = Automaze::Panel.new(:wall)
+      @floor = Automaze::Panel.new(:floor)
+    end
+
+    describe "set_kind" do
+      it "can set kind" do
+        @wall.set_kind(:floor)
+        @wall.floor?.should be_true
+        @floor.set_kind(:wall)
+        @floor.wall?.should be_true
+      end
+    end
+  end
+end
+

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: automaze
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 0
+  version: 0.0.0
+platform: ruby
+authors: 
+- Toshiyuki Hirooka
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-31 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: maze generator
+email: toshi.hirooka@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/algorithms/boutaoshi.rb
+- lib/algorithms/dug_tunnels.rb
+- lib/automaze.rb
+- lib/panel.rb
+- sample.rb
+- spec/automaze_spec.rb
+- spec/panel_spec.rb
+has_rdoc: true
+homepage: http://github.com/tosik/automazerb
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: maze generator
+test_files: 
+- spec/automaze_spec.rb
+- spec/panel_spec.rb