square-dungeon-gen 1.0.0 → 1.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 02c73e23d80259be80160c0218e6fe479845e2e7
-  data.tar.gz: bb6c03c2e1c1d82a87e0a2e422245291406232b7
+  metadata.gz: 02ee3558715e0c0bcdee350923901d21bce2af45
+  data.tar.gz: '08248f4ae13933c8c8a717827b2f4b5ef7617c39'
 SHA512:
-  metadata.gz: da20505c016e885ca759019e24e458fd8c4fc59a51e9aae88ce101d0b77cef99423326a05c9ea61bbb7a1b76aa6317a15b48fbdb60a20d0e609c823d5982fb7d
-  data.tar.gz: 205739141a74ba5bf6b30cfa9b0a84dad93effbfc0e6413c0cdafe1c398acda9c43ca2c7d67526f1eab032e64df0682fe288de28f96e4d56323e9219a60a5e46
+  metadata.gz: b7355fb3e50b8dc6f53bc59cff5f3b29fa6ceb8f9b7a566bfc22d9711832c01cd86ae68bebdd02d02099d3e13b6dcf1a90e928dcd550732d05079f06d5d0c19e
+  data.tar.gz: aa41cbff21d6098e8bc1c0004bc63433e94f2aa2607bbf235aeed86c8002351a0eba9ee856cde46358493e50863413a5ab2b41e6dbafc336d641e895ef49ef8e

data/README.md

@@ -0,0 +1,57 @@
+[![Build Status](https://travis-ci.org/czuger/square-dungeon-gen.svg?branch=master)](https://travis-ci.org/czuger/square-dungeon-gen)
+[![Maintainability](https://api.codeclimate.com/v1/badges/a72af1658fd0931463a5/maintainability)](https://codeclimate.com/github/czuger/square-dungeon-gen/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/a72af1658fd0931463a5/test_coverage)](https://codeclimate.com/github/czuger/square-dungeon-gen/test_coverage)
+
+# Square dungeon gen
+This repository contain a library for generating square simple dungeons
+
+## Compatibility
+
+Require ruby 2.4.0 or higher.
+
+## Usage
+
+### Basics
+------
+ 
+```ruby
+# Create a dungeon for four 1 level players
+d=Dungeon.new
+d.generate( dungeon_size, party_array )
+
+# Exemple :
+d=Dungeon.new
+d.generate( 4, [ 1, 1, 1, 1 ] )
+# This will not create a dungeon of 4 rooms size, but a dungeon of 4**2*0.3 rooms (rounded up)
+# The dungeon constructor accept another parameter wich is the amount of rooms to remove from the dungeon
+# This parameter is a number between 0 and 1. By default it is set to 0.3 which mean that it will remove 30% of the rooms.
+# The [ 1, 1, 1, 1 ] array mean that the dungeon is designed for four 1 level players.
+
+d=Dungeon.new
+d.generate( 4, [ 1, 1, 1, 1 ], 0.5 )
+# Will remove 50% of the rooms
+
+# Draw your dungeon
+d.draw( 'out/dungeon.jpg' )
+# Or only the curren room
+d.draw_current_room( 'out/current_room.jpg' )
+
+# You can get the directions available from the current room
+d.available_directions
+# => [ :left, :right ] # according to your dungeon which is random
+
+# Then you can move the current room by moving in a direction
+d.set_next_room( :left )
+# Will move the current_room to the left.
+```
+
+### Examples
+------
+
+This is an example of the current room : 
+
+![test picture](/images/entry-room.jpg)
+
+This is an example of the full dungeon room : 
+
+![test picture](/images/dungeon.jpg)

data/lib/dungeon/dungeon.rb

@@ -0,0 +1,82 @@
+require_relative '../rooms/room'
+require_relative 'dungeon_walker'
+require_relative 'dungeon_generator'
+require_relative 'dungeon_draw'
+require_relative '../hallways/horizontal_hallway'
+require_relative '../hallways/vertical_hallway'
+require_relative '../hallways/hallways_list'
+require 'dd-next-encounters'
+require 'rmagick'
+require 'pp'
+require 'json'
+
+class Dungeon
+
+  attr_reader :current_room, :hallways, :rooms
+
+  include DungeonGenerator
+  include DungeonDraw
+
+  def initialize
+    @dungeon_size = @rooms_removal_coef = @rooms = @hallways = @dungeon_generated = @current_room = @lair = nil
+  end
+
+  def set_next_room( direction )
+    assert_dungeon_generated
+    # puts 'Current room = ' + @current_room.id.to_s
+    room_id = @hallways.get_room_id_from_direction( @current_room, direction )
+    # puts 'Connected room id = ' + room_id.to_s
+    # puts 'Rooms = ' + @rooms.keys.to_s
+    @current_room = @rooms[ room_id ]
+  end
+
+  def available_directions
+    assert_dungeon_generated
+    @hallways.directions( @current_room )
+  end
+
+  def to_json
+    assert_dungeon_generated
+    {
+        dungeon_size: @dungeon_size,
+        rooms_removal_coef: @rooms_removal_coef,
+        entry_room_id: @entry.id,
+        current_room_id: @current_room.id,
+        dungeon_generated: @dungeon_generated,
+        rooms: @rooms.values.map{ |r| r.to_json_hash( @hallways ) },
+        hallways: @hallways.to_hash,
+        lair: @lair.to_hash
+    }.to_json
+  end
+
+  def self.from_json( json_string )
+    data = JSON.parse( json_string )
+    dungeon = Dungeon.new
+    dungeon.from_json(data)
+    dungeon
+  end
+
+  def from_json( data )
+    raise 'You must parse the json string before calling this method' if data.is_a? String
+
+    @dungeon_size = data['dungeon_size']
+    @rooms_removal_coef = data['rooms_removal_coef']
+    @dungeon_generated = data['dungeon_generated']
+
+    @lair = Lairs.from_hash( data['lair'] )
+    @rooms = Hash[ data['rooms'].map{ |dr| [ dr['id'], Room.new( dr['top'], dr['left'], @lair, dr ) ] } ]
+
+    @hallways = HallwaysList.new
+    @hallways.from_json(data['hallways'], @rooms)
+
+    @entry = @rooms[data['entry_room_id']]
+    @current_room = @rooms[data['current_room_id']]
+  end
+
+  private
+
+  def check_params( dungeon_size, party_levels, encounters_difficulty, rooms_removal_coef )
+    raise "dungeon_size should not be null" if dungeon_size == 0
+  end
+
+end

data/lib/dungeon/dungeon_draw.rb

@@ -0,0 +1,57 @@
+module DungeonDraw
+
+  def draw( output_file )
+    assert_dungeon_generated
+    width = height = ( @dungeon_size * Room::ROOM_SQUARE_SIZE +
+        ( ( @dungeon_size-1 ) * Room::SQUARES_BETWEEN_ROOMS ) ) * Room::SQUARE_SIZE_IN_PIXELS +
+        ( Room::ROOM_SQUARE_SIZE * Room::SQUARE_SIZE_IN_PIXELS )
+
+    create_gc( width, height )
+    @rooms.each_pair do |_, r|
+      r.compute_coords
+      r.draw( @gc )
+    end
+    @hallways.draw_from_base_room @gc
+    draw_gc( output_file )
+  end
+
+  def draw_current_room( output_file )
+    assert_dungeon_generated
+    width = height = ( Room::ROOM_SQUARE_SIZE + Room::SQUARES_BETWEEN_ROOMS * 2 ) * Room::SQUARE_SIZE_IN_PIXELS
+
+    create_gc( width, height )
+    @current_room.compute_coords_at_origin
+    @current_room.draw( @gc )
+
+    @hallways.draw_hallways_connected_to_given_room_at_origin( @gc, @current_room )
+
+    draw_gc( output_file )
+  end
+
+  def print_dungeon( output_file )
+    assert_dungeon_generated
+    rooms = {}
+    @rooms.each do |_, v|
+      rooms[ v.id ] = v.to_hash(hallways )
+    end
+    File.open(output_file,'w') do |f|
+      PP.pp(rooms,f)
+    end
+  end
+
+  private
+
+  def create_gc( width, height )
+    @canvas = Magick::Image.new( width, height )
+
+    @gc = Magick::Draw.new
+    @gc.stroke( DrawableObject::GRID_COLOR )
+    @gc.fill( DrawableObject::BACKGROUND_COLOR )
+  end
+
+  def draw_gc( output_file )
+    @gc.draw( @canvas )
+    @canvas.write( output_file )
+  end
+
+end

data/lib/dungeon/dungeon_generator.rb

@@ -0,0 +1,102 @@
+require 'matrix'
+
+module DungeonGenerator
+
+  def generate( dungeon_size, party_levels, encounters_difficulty: :medium, rooms_removal_coef: 0.3, lair: nil, output: false )
+    check_params( dungeon_size, party_levels, encounters_difficulty, rooms_removal_coef )
+    @dungeon_size = dungeon_size
+    @rooms_removal_coef = rooms_removal_coef
+    @rooms = {}
+    @hallways = HallwaysList.new
+    @dungeon_generated = false
+    @current_room = nil
+
+    @lair = lair ? lair : Lairs.new( encounters_difficulty, party_levels )
+
+    @output = output
+    create_dungeon
+    create_entry
+    connect_hallways
+    delete_rooms
+    generate_treasure
+    @dungeon_generated = true
+  end
+
+  private
+
+  def assert_dungeon_generated
+    raise "Dungeon hasn't been generated" unless @dungeon_generated
+  end
+
+  def generate_treasure
+    rooms_distances = { }
+    @rooms.keys.each do |room_id|
+      rooms_distances[ room_id ] = distance_between_rooms_ids(@entry.id, room_id )
+    end
+    max_distance = rooms_distances.values.max
+    rooms_distances.delete_if {|_, value| value != max_distance }
+    treasure_room_id = rooms_distances.keys.sample
+    @rooms[treasure_room_id].set_treasure_room
+  end
+
+  def create_entry
+    @entry = random_entry_room
+    @entry.set_entry_room
+    @current_room = @entry
+  end
+
+  def distance_between_rooms_ids( r_id_1, r_id_2 )
+    Math.sqrt( (r_id_1[0] - r_id_2[0])**2  + (r_id_1[1] - r_id_2[1])**2  ).ceil
+  end
+
+  def create_dungeon
+    Matrix.build( @dungeon_size ){ |r, c| [ r+1, c+1 ] }.to_a.flatten(1).each do |top, left|
+      @rooms[ [ top, left ] ] = Room.new( top, left, @lair )
+       @rooms[ [ top, left ] ].id = [ top, left ]
+    end
+  end
+
+  def connect_hallways
+    Matrix.build( @dungeon_size ){ |r, c| [ r+1, c+1 ] }.to_a.flatten(1).each do |top, left|
+      @hallways.connect_rooms( @rooms[ [ top, left ] ],@rooms[ [ top, left+1 ] ], HorizontalHallway.new ) unless left == @dungeon_size
+      @hallways.connect_rooms( @rooms[ [ top, left ] ],@rooms[ [ top+1, left ] ], VerticalHallway.new ) unless top == @dungeon_size
+    end
+  end
+
+  # Coef must be a number between 0 -> 1
+  # for example 1/3 mean that we will delete 1/3 of the rooms
+  def delete_rooms
+
+    to_delete_rooms_keys = @rooms.keys.shuffle
+    puts "Current dungeon size = #{@rooms.count}" if @output
+    target_dungeon_size = @rooms.count - ((@dungeon_size**2)*@rooms_removal_coef).ceil
+    puts "Target dungeon size = #{target_dungeon_size}" if @output
+
+    while @rooms.count > target_dungeon_size && !to_delete_rooms_keys.empty?
+
+      to_delete_room_key = to_delete_rooms_keys.shift
+      tmp_rooms = @rooms.clone
+      tmp_rooms.delete( to_delete_room_key )
+
+      dw = DungeonWalker.new( tmp_rooms, @dungeon_size, @entry )
+      # If we can walk to all the rooms in the dungeon, then the room deletion is validated
+      if dw.walk_rooms.count == tmp_rooms.count
+        @hallways.disable_hallways!( to_delete_room_key )
+        @rooms.delete( to_delete_room_key )
+      end
+      # Otherwise we try with the next room
+
+    end
+
+    puts "Final dungeon size = #{@rooms.count}" if @output
+  end
+
+  def external_rooms
+    @rooms.values.select{ |r| r.top == 1 || r.left == 1 || r.top == @dungeon_size || r.left == @dungeon_size }
+  end
+
+  def random_entry_room
+    external_rooms.sample
+  end
+
+end

data/lib/dungeon/dungeon_walker.rb

@@ -0,0 +1,51 @@
+require 'set'
+
+class DungeonWalker
+
+  WALKING_POSITIONS = [ [ -1, 0 ], [ 1, 0 ], [ 0, -1 ], [ 0, 1 ] ]
+
+  def initialize( rooms, dungeon_size, entry_room )
+    @rooms = rooms
+    @dungeon_size = dungeon_size
+    @entry_room = entry_room
+  end
+
+  def walk_rooms()
+    walking_room_queue = [ @entry_room.top_left_array ]
+    walked_rooms_positions = Set.new
+
+    until walking_room_queue.empty?
+      current_room_position = walking_room_queue.shift
+      walked_rooms_positions << current_room_position
+
+      connected_rooms_positions = get_connected_rooms_positions(  current_room_position )
+      connected_rooms_positions.each do |room_position|
+        # p room_position
+        next if walked_rooms_positions.include?( room_position )
+        walked_rooms_positions << room_position
+        walking_room_queue << room_position
+        # p walked_rooms_positions
+      end
+
+    end
+    walked_rooms_positions
+  end
+
+  def get_connected_rooms_positions( room_position )
+    connected_positions = []
+    WALKING_POSITIONS.each do |wp|
+
+      top = room_position[0] + wp[0]
+      left = room_position[1] + wp[1]
+
+      if( room_position != [ top, left ] && top >= 1 && left >= 1 && top <= @dungeon_size && left <= @dungeon_size &&
+          @rooms.has_key?( [ top, left ] ) )
+        connected_positions << [ top, left ]
+      end
+
+    end
+    # p connected_positions
+    connected_positions
+  end
+
+end

data/lib/hallways/hallway.rb

@@ -0,0 +1,51 @@
+require_relative '../misc/drawable_object'
+
+class Hallway < DrawableObject
+
+  attr_reader :disabled, :rooms, :hallway_id
+  attr_accessor :hallway_id
+
+  # Should be half room size
+  HALLWAYS_LENGTH=6
+  HALLWAYS_WIDTH=2
+
+  def initialize
+    @disabled = false
+    @hallway_id = nil
+  end
+
+  def disable!
+    @disabled = true
+  end
+
+  def set_draw_base_room( draw_base_room )
+    @draw_base_room = draw_base_room
+  end
+
+  def to_hash
+    { hallway_id: @hallway_id, klass: self.class.name, disabled: @disabled, draw_base_room: @draw_base_room.id }
+  end
+
+  def get_direction_array( rooms_keys, room, input_output )
+    return [ nil, nil ] if disabled
+    return [ input_output[0], self ] if rooms_keys[0] == room.top_left_array
+    return [ input_output[1], self ] if rooms_keys[1] == room.top_left_array
+    [ nil, nil ]
+  end
+
+  private
+
+  def draw( gc, width, height, min_x, max_x, min_y, max_y, x_decal: 0, y_decal: 0 )
+    gc.rectangle( min_x, min_y, max_x, max_y )
+
+    # Squares
+    1.upto( width ).each do |t|
+      gc.line( min_x + SQUARE_SIZE_IN_PIXELS*t - x_decal, min_y, min_x + SQUARE_SIZE_IN_PIXELS*t - x_decal, max_y )
+    end
+
+    1.upto( height ).each do |t|
+      gc.line( min_x, min_y + SQUARE_SIZE_IN_PIXELS*t - y_decal, max_x, min_y + SQUARE_SIZE_IN_PIXELS*t - y_decal )
+    end
+  end
+
+end

data/lib/hallways/hallways_list.rb

@@ -0,0 +1,73 @@
+class HallwaysList
+
+  def initialize
+    @hallways = {}
+  end
+
+  def connect_rooms( r1, r2, hallway )
+    @hallways[ [ r1.top_left_array, r2.top_left_array ] ] = hallway
+    hallway.hallway_id = [ r1.top_left_array, r2.top_left_array ]
+    hallway.set_draw_base_room( r1 )
+  end
+
+  def get_room_id_from_direction( room, direction )
+    connections = connected_hallways( room )
+    # puts "Connected hallways = " + connections.map{ |k, h| [ k, h.hallway_id ] }.to_s
+    connected_hallway = connections[direction]
+    unless connected_hallway
+      raise "Can't find a connected hallway. direction = #{direction.inspect}, connections = #{connections.inspect}"
+    end
+    connected_hallway.get_connected_room(direction)
+  end
+
+  def connected_hallways( room )
+    hallways = {}
+    @hallways.each_pair do |rooms_keys, hallway|
+      d, h = hallway.get_direction_array( rooms_keys, room )
+      hallways[d] = h if d
+    end
+    hallways
+  end
+
+  def directions( room )
+    connected_hallways(room).keys.sort
+  end
+
+  def draw_from_base_room( gc )
+    @hallways.each_pair{ |_, h| h.draw_from_base_room( gc ) unless h.disabled }
+  end
+
+  def draw_hallways_connected_to_given_room_at_origin( gc, room )
+    connections = connected_hallways( room )
+    connections.each do |direction, hallway|
+      hallway.draw_from_given_room( gc, room, direction )
+    end
+  end
+
+  def disable_hallways!( room_key )
+    @hallways.each_pair do |rooms_keys, hallway|
+      if rooms_keys[0] == room_key || rooms_keys[1] == room_key
+        hallway.disable!
+      end
+    end
+  end
+
+  def to_hash
+    @hallways.values.map{ |v| v.to_hash }
+  end
+
+  def from_json( data, rooms )
+    data.each do |hallway_data|
+      # pp hallway_data
+      r1 = rooms[hallway_data['hallway_id'][0]]
+      r2 = rooms[hallway_data['hallway_id'][1]]
+      if r1 && r2
+        hallway = Object.const_get(hallway_data['klass']).new
+        hallway.disable! if hallway_data['disabled']
+        hallway.set_draw_base_room(r1)
+        connect_rooms( r1, r2, hallway )
+      end
+    end
+  end
+
+end

data/lib/hallways/horizontal_hallway.rb

@@ -0,0 +1,42 @@
+require_relative 'hallway'
+
+class HorizontalHallway < Hallway
+
+  HALLWAY_HEIGHT=HALLWAYS_WIDTH
+  HALLWAY_WIDTH=HALLWAYS_LENGTH
+
+  def get_direction_array( rooms_keys, room )
+    super( rooms_keys, room, [ :right, :left ] )
+  end
+
+  def get_connected_room( direction )
+    if direction == :right
+      @hallway_id[1]
+    else
+      @hallway_id[0]
+    end
+  end
+
+  def draw( gc, base_room, x_decal = 0 )
+    min_x = base_room.max_x - x_decal
+    max_x = min_x + HALLWAY_WIDTH * SQUARE_SIZE_IN_PIXELS - x_decal
+
+    min_y = base_room.min_y + ( Room::ROOM_SQUARE_SIZE/2-1 ) * SQUARE_SIZE_IN_PIXELS
+    max_y = min_y + HALLWAY_HEIGHT * SQUARE_SIZE_IN_PIXELS
+
+    super( gc, HALLWAY_WIDTH, HALLWAY_HEIGHT, min_x, max_x, min_y, max_y, x_decal: x_decal/2 )
+  end
+
+  def draw_from_base_room( gc )
+    draw( gc, @draw_base_room )
+  end
+
+  def draw_from_given_room( gc, room, direction )
+    if direction == :right
+      draw( gc, room )
+    else
+      draw( gc, room, ( Room::ROOM_SQUARE_SIZE ) * SQUARE_SIZE_IN_PIXELS )
+    end
+  end
+
+end

data/lib/hallways/vertical_hallway.rb

@@ -0,0 +1,42 @@
+require_relative 'hallway'
+
+class VerticalHallway < Hallway
+
+  HALLWAY_HEIGHT=HALLWAYS_LENGTH
+  HALLWAY_WIDTH=HALLWAYS_WIDTH
+
+  def get_direction_array( rooms_keys, room )
+    super( rooms_keys, room, [ :bottom, :top ] )
+  end
+
+  def get_connected_room( direction )
+    if direction == :bottom
+      @hallway_id[1]
+    else
+      @hallway_id[0]
+    end
+  end
+
+  def draw( gc, base_room, y_decal = 0 )
+    min_x = base_room.min_x + ( Room::ROOM_SQUARE_SIZE/2-1 ) * SQUARE_SIZE_IN_PIXELS
+    max_x = min_x + HALLWAY_WIDTH * SQUARE_SIZE_IN_PIXELS
+
+    min_y = base_room.max_y - y_decal
+    max_y = min_y + HALLWAY_HEIGHT * SQUARE_SIZE_IN_PIXELS - y_decal
+
+    super( gc, HALLWAY_WIDTH, HALLWAY_HEIGHT, min_x, max_x, min_y, max_y, y_decal: y_decal/2 )
+  end
+
+  def draw_from_base_room( gc )
+    draw( gc, @draw_base_room )
+  end
+
+  def draw_from_given_room( gc, room, direction )
+    if direction == :bottom
+      draw( gc, room )
+    else
+      draw( gc, room, ( Room::ROOM_SQUARE_SIZE ) * SQUARE_SIZE_IN_PIXELS )
+    end
+  end
+
+end

data/lib/misc/drawable_object.rb

@@ -0,0 +1,9 @@
+class DrawableObject
+
+  SQUARE_SIZE_IN_PIXELS = 60
+
+  GRID_COLOR = 'darkslateblue'
+  BACKGROUND_COLOR = 'white'
+  TEXT_COLOR = 'black'
+
+end

data/lib/misc/walker.rb

@@ -0,0 +1,26 @@
+class Walker
+
+  def initialize( dungeon )
+    @dungeon = dungeon
+  end
+
+  def directions
+    Hash[ @dungeon.hallways.directions( @dungeon.current_room ).map{ |e| [ e.to_s[0], e ] } ]
+  end
+
+  def main_loop
+    loop do
+      _directions = directions
+      p _directions
+
+      direction = gets.chomp
+      direction = _directions[direction]
+      p direction
+
+      p @dungeon.set_next_room( direction )
+      @dungeon.draw_current_room( 'out/room.jpg'  )
+
+    end
+  end
+
+end

data/lib/rooms/room.rb

@@ -0,0 +1,74 @@
+require_relative '../misc/drawable_object'
+require_relative '../hallways/hallway'
+require_relative 'room_content'
+require_relative 'room_draw'
+require 'hazard'
+
+class Room < DrawableObject
+
+  SQUARES_BETWEEN_ROOMS = Hallway::HALLWAYS_LENGTH
+  ROOM_SQUARE_SIZE = 12
+
+  attr_reader :top, :left, :entry_room, :min_x, :min_y, :max_x, :max_y, :content, :content_description, :decorations
+  attr_accessor :id
+
+  include RoomContent
+  include RoomDraw
+
+  def initialize( top, left, lair, room_data = {} )
+    @top = room_data['top'] ? room_data['top'].to_i : top
+    @left = room_data['left'] ? room_data['left'].to_i : left
+    @content = room_data['content']
+    @content_description = room_data['content_description']
+    @entry_room = room_data['entry_room']
+    @id = room_data['id'] ? room_data['id'] : [ top, left ]
+
+    @decorations = []
+    if room_data['decorations']
+      load_decoration_from_json(room_data['decorations'] )
+    else
+      create_decorations
+    end
+
+    create_encounters( lair ) unless room_data['content_description']
+  end
+
+  def top_left_array
+    [ @top, @left ]
+  end
+
+  def decal_at_origin
+    @top = 1
+    @left = 1
+  end
+
+  def compute_coords
+    @min_x = ( ( @left-1 ) * ROOM_SQUARE_SIZE + @left * SQUARES_BETWEEN_ROOMS ) * SQUARE_SIZE_IN_PIXELS
+    @max_x = @min_x + ROOM_SQUARE_SIZE * SQUARE_SIZE_IN_PIXELS
+    @min_y = ( ( @top-1 ) * ROOM_SQUARE_SIZE + @top * SQUARES_BETWEEN_ROOMS ) * SQUARE_SIZE_IN_PIXELS
+    @max_y = @min_y + ROOM_SQUARE_SIZE * SQUARE_SIZE_IN_PIXELS
+  end
+
+  def compute_coords_at_origin
+    @min_x = SQUARES_BETWEEN_ROOMS * SQUARE_SIZE_IN_PIXELS
+    @max_x = @min_x + ROOM_SQUARE_SIZE * SQUARE_SIZE_IN_PIXELS
+    @min_y = SQUARES_BETWEEN_ROOMS * SQUARE_SIZE_IN_PIXELS
+    @max_y = @min_y + ROOM_SQUARE_SIZE * SQUARE_SIZE_IN_PIXELS
+  end
+
+  def to_hash( hallways )
+    {id: @id, entry_room: @entry_room, content: @content, content_description: @content_description,
+     top: @top, left: @left, decorations: @decorations.map{ |d| d[:decoration_type] },
+     connected_hallways: hallways.connected_hallways( self ).map{ |k, h| { k => h.to_hash } } }
+  end
+
+  def to_json_hash( hallways )
+    if @decorations.count > 1
+      a = :true
+    end
+    h = to_hash( hallways )
+    h.delete(:connected_hallways)
+    h
+  end
+
+end

data/lib/rooms/room_content.rb

@@ -0,0 +1,75 @@
+require 'hazard'
+require_relative 'room_traps'
+
+module RoomContent
+
+  attr_accessor :party_levels, :encounters_difficulty
+
+  include RoomTraps
+
+  CONTENT_DESC_EMPTY='Nothing in this room.'
+  CONTENT_DESC_MONSTERS_CLEARED='Slain monsters lying on the floor.'
+  CONTENT_DESC_TRAP_CLEARED='A deactivated trap. Be carefull.'
+
+  def set_entry_room
+    @entry_room = true
+    @content = 'E'
+    @content_description = 'This room is the entry room.'
+  end
+
+  def set_treasure_room
+    @content = 'H'
+    @content_description = 'The treasure, you find it.'
+  end
+
+  def clear
+    case @content
+      when 'T'
+        @content = nil
+        @content_description = CONTENT_DESC_TRAP_CLEARED
+      when 'M'
+        @content = nil
+        @content_description = CONTENT_DESC_MONSTERS_CLEARED
+    end
+  end
+
+  private
+
+  def create_encounters( lair )
+    @content_description = CONTENT_DESC_EMPTY
+    roll = Hazard.d6
+    generate_trap if roll == 1
+    generate_monster( lair ) if roll > 1 && roll < 6
+  end
+
+  def load_decoration_from_json( decorations_types )
+    decorations_types.each do |decoration_type|
+      if decoration_type == 'four_columns'
+        create_four_columns
+      end
+    end
+  end
+
+  def create_decorations
+    roll = Hazard.d6
+    create_four_columns if roll >= 5
+  end
+
+  def create_four_columns
+    near = (Room::ROOM_SQUARE_SIZE/8.0).ceil
+    distant = Room::ROOM_SQUARE_SIZE-[ (Room::ROOM_SQUARE_SIZE/8.0).ceil*2, 3 ].max
+
+    column_1 = { top: near, left: near }
+    column_2 = { top: near, left: distant }
+    column_3 = { top: distant, left: near }
+    column_4 = { top: distant, left: distant }
+
+    @decorations << { decoration_type: :four_columns, decoration_data: [ column_1, column_2, column_3, column_4 ] }
+  end
+
+  def generate_monster( lair )
+    @content = 'M'
+    @content_description = lair.encounter.to_s + '.'
+  end
+
+end

data/lib/rooms/room_draw.rb

@@ -0,0 +1,47 @@
+module RoomDraw
+
+  def draw( gc )
+    gc.rectangle( @min_x, @min_y, @max_x, @max_y )
+
+    # Squares
+    1.upto( Room::ROOM_SQUARE_SIZE ).each do |t|
+      gc.line( @min_x + DrawableObject::SQUARE_SIZE_IN_PIXELS*t, @min_y, @min_x + DrawableObject::SQUARE_SIZE_IN_PIXELS*t, @max_y )
+      gc.line( @min_x, @min_y + DrawableObject::SQUARE_SIZE_IN_PIXELS*t, @max_x, @min_y + DrawableObject::SQUARE_SIZE_IN_PIXELS*t )
+    end
+
+    if @content
+      print_text( gc, @content )
+    end
+
+    @decorations.each do |decoration|
+      draw_four_columns(gc, decoration[:decoration_data] ) if decoration[:decoration_type] == :four_columns
+    end
+  end
+
+  private
+
+  def print_text( gc, text )
+    x = @min_x + (Room::ROOM_SQUARE_SIZE/2.35) * DrawableObject::SQUARE_SIZE_IN_PIXELS
+    y = @min_y + (Room::ROOM_SQUARE_SIZE/1.73) * DrawableObject::SQUARE_SIZE_IN_PIXELS
+    gc.pointsize( (Room::ROOM_SQUARE_SIZE*100)/8 )
+    gc.fill( DrawableObject::TEXT_COLOR )
+    gc.text( x, y, text )
+    gc.fill( DrawableObject::BACKGROUND_COLOR )
+  end
+
+  def draw_four_columns(gc, columns_data )
+    gc.stroke( DrawableObject::GRID_COLOR )
+    gc.fill( DrawableObject::GRID_COLOR )
+
+    columns_data.each do |c_data|
+      min_x = (c_data[:left]+1)*DrawableObject::SQUARE_SIZE_IN_PIXELS + @min_x
+      min_y = (c_data[:top]+1)*DrawableObject::SQUARE_SIZE_IN_PIXELS + @min_y
+      perim_x = min_x+3
+      perim_y = min_y - DrawableObject::SQUARE_SIZE_IN_PIXELS+3
+
+      gc.circle( min_x, min_y, perim_x, perim_y )
+    end
+    gc.fill( DrawableObject::BACKGROUND_COLOR )
+  end
+
+end

data/lib/rooms/room_traps.rb

@@ -0,0 +1,15 @@
+# This is very basic, need to improve
+
+module RoomTraps
+
+  private
+
+  def generate_trap
+    dd = 10+Hazard.d4
+    degats = Hazard.m2d10
+    @content = 'T'
+    @content_description = "The room contains a pit. Make a perception check against #{dd}. In case of failure the first character takes #{degats} hp."
+  end
+
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: square-dungeon-gen
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.5.2
 platform: ruby
 authors:
 - Cédric Zuger
@@ -38,13 +38,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.16'
+- !ruby/object:Gem::Dependency
+  name: dd-next-encounters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
 description: A simple gem that generate square dungeons
 email: zuger.cedric@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- README.md
 - lib/dungeon.rb
+- lib/dungeon/dungeon.rb
+- lib/dungeon/dungeon_draw.rb
+- lib/dungeon/dungeon_generator.rb
+- lib/dungeon/dungeon_walker.rb
+- lib/hallways/hallway.rb
+- lib/hallways/hallways_list.rb
+- lib/hallways/horizontal_hallway.rb
+- lib/hallways/vertical_hallway.rb
+- lib/misc/drawable_object.rb
+- lib/misc/walker.rb
+- lib/rooms/room.rb
+- lib/rooms/room_content.rb
+- lib/rooms/room_draw.rb
+- lib/rooms/room_traps.rb
 homepage: https://github.com/czuger/sqare-dungeon-gen
 licenses:
 - MIT
@@ -57,7 +92,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="