unicodetiles 1.0.0

data/.rspec

@@ -0,0 +1,2 @@
+--format nested
+--color

data/Gemfile

@@ -0,0 +1,7 @@
+source :rubygems
+
+gem "gosu"
+
+group :test do
+  gem "rspec"
+end

data/Rakefile

@@ -0,0 +1,62 @@
+require 'rspec/core/rake_task'
+require 'rake/clean'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+
+# ROCCO =============================================
+
+# Bring in Rocco tasks
+require 'rocco/tasks'
+Rocco::make 'docs/'
+
+desc 'Build rocco docs'
+task :docs => :rocco
+directory 'docs/'
+
+desc 'Build docs and open in browser for the reading'
+task :read => :docs do
+  sh 'open docs/lib/ut.html'
+end
+
+# Make index.html a copy of ut.html
+file 'docs/index.html' => 'docs/lib/ut.html' do |f|
+  cp 'docs/lib/ut.html', 'docs/index.html', :preserve => true
+end
+task :docs => 'docs/index.html'
+CLEAN.include 'docs/index.html'
+
+# Alias for docs task
+task :doc => :docs
+
+# GITHUB PAGES =======================================
+
+desc 'Update gh-pages branch'
+task :pages => ['docs/.git', :docs] do
+  rev = `git rev-parse --short HEAD`.strip
+  Dir.chdir 'docs' do
+    sh "git add *.html"
+    sh "git commit -m 'rebuild pages from #{rev}'" do |ok,res|
+      if ok
+        verbose { puts "gh-pages updated" }
+        sh "git push -q o HEAD:gh-pages"
+      end
+    end
+  end
+end
+
+# Update the pages/ directory clone
+file 'docs/.git' => ['docs/', '.git/refs/heads/gh-pages'] do |f|
+  sh "cd docs && git init -q && git remote add o ../.git" if !File.exist?(f.name)
+  sh "cd docs && git fetch -q o && git reset -q --hard o/gh-pages && touch ."
+end
+CLOBBER.include 'docs/.git'
+
+# RSPEC =============================================
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  # Put spec opts in a file named .rspec in root
+end

data/Readme.md

@@ -0,0 +1,15 @@
+# Unicodetiles.rb
+
+Ruby Port of [Unicodetiles.js](https://github.com/tapio/unicodetiles.js)
+
+## Installation
+
+  * Install Ruby 1.9.2
+    * On Linux: `sudo apt-get install ruby` or [RVM](https://rvm.beginrescueend.com)
+    * On Windows: [Ruby Installer](http://rubyinstaller.org)
+    * *Windows only*: Install [Ruby DevKit](http://rubyinstaller.org/add-ons/devkit/)
+    * Install Bundler gem: `gem install bundler`
+    * Install dependencies: `bundle install`
+
+## Examples
+Examples can be found in the `examples/` dir and can be run with `ruby examples/01_minimal.rb` etc.

data/examples/01_minimal.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require_relative '../lib/ut'
+require_relative 'helper'
+require 'set'
+
+
+class Window < Gosu::Window
+  attr_accessor :viewport
+
+  def initialize width, height
+    super width, height, false
+  end
+
+  def draw
+    viewport.draw
+  end
+end
+
+$window = Window.new WINDOW_WIDTH, WINDOW_HEIGHT
+
+@renderer = UT::FontRenderer.new :font_name => "fonts/DejaVuSansMono.ttf", :tile_size => TILE_SIZE
+@viewport = UT::Viewport.new :renderer => @renderer, :width => VIEWPORT_WIDTH, :height => VIEWPORT_HEIGHT
+@viewport.put_string 0, 0, "Hello World !", Gosu::Color::CYAN
+@viewport.put_string 0, 1, "Some unicode chars:", Gosu::Color::GREEN, Gosu::Color::GRAY
+%W{☠ ☃ ⚙ ☻ ♞ ☭ ✈ ✟ ✂ ✯}.each_with_index do |c,i|
+  @viewport.put_tile i, 2, (UT::Tile.new :glyph => c, :foreground => Gosu::Color.from_hsv(c.ord%360, 1, 1))
+end
+@viewport.put_string 14, 4, "Long strings get automatically wrapped as block"
+@viewport.put_string 13, 7, "or as a line if u want", nil, nil, :line
+@viewport.put_string 20, 9, "or not at all", nil, nil, :none
+
+$window.viewport = @viewport
+$window.show

data/examples/02_simple_dungeon.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require_relative '../lib/ut'
+require_relative 'helper'
+require_relative 'dungeon'
+require_relative "example_window"
+
+$window = ExampleWindow.new
+
+@dungeon = Dungeon.new
+@renderer = UT::FontRenderer.new :font_name => "fonts/DejaVuSansMono.ttf", :tile_size => TILE_SIZE, :scale_x => SCALE_X, :scale_y => SCALE_Y
+@viewport = UT::Viewport.new :renderer => @renderer, :width => VIEWPORT_WIDTH, :height => VIEWPORT_HEIGHT
+@engine = UT::Engine.new :viewport => @viewport, :world_width => @dungeon.width, :world_height => @dungeon.height
+@engine.set_source do |x,y|
+  @dungeon.get_tile x, y
+end
+
+$window.dungeon = @dungeon
+$window.engine = @engine
+$window.show

data/examples/03_fov_dungeon.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require_relative '../lib/ut'
+require_relative 'helper'
+require_relative 'dungeon'
+require_relative 'example_window'
+
+$window = ExampleWindow.new
+
+@dungeon = Dungeon.new
+@renderer = UT::FontRenderer.new :font_name => "fonts/DejaVuSansMono.ttf", :tile_size => TILE_SIZE, :scale_x => SCALE_X, :scale_y => SCALE_Y
+@viewport = UT::Viewport.new :renderer => @renderer, :width => VIEWPORT_WIDTH, :height => VIEWPORT_HEIGHT
+@engine = UT::Engine.new :viewport => @viewport, :world_width => @dungeon.width, :world_height => @dungeon.height
+@engine.set_source do |x,y|
+  @dungeon.get_tile x, y
+end
+@engine.set_mask do |x,y|
+  @dungeon.is_visible? x, y
+end
+
+$window.dungeon = @dungeon
+$window.engine = @engine
+$window.show

data/examples/04_shader_lightning.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require_relative '../lib/ut'
+require_relative 'helper'
+require_relative 'dungeon'
+require_relative 'shader'
+require_relative 'example_window'
+
+$window = ExampleWindow.new
+
+@dungeon = Dungeon.new
+@shader = Shader.new
+@renderer = UT::FontRenderer.new :font_name => "fonts/DejaVuSansMono.ttf", :tile_size => TILE_SIZE, :scale_x => SCALE_X, :scale_y => SCALE_Y
+@viewport = UT::Viewport.new :renderer => @renderer, :width => VIEWPORT_WIDTH, :height => VIEWPORT_HEIGHT
+@engine = UT::Engine.new :viewport => @viewport, :world_width => @dungeon.width, :world_height => @dungeon.height
+@engine.set_source do |x,y|
+  @dungeon.get_tile x, y
+end
+@engine.set_mask do |x,y|
+  @dungeon.is_visible? x, y
+end
+@engine.set_shader do |tile, x, y|
+  @shader.apply tile, x, y
+end
+
+$window.dungeon = @dungeon
+$window.shader = @shader
+$window.engine = @engine
+$window.show

data/examples/05_infinite_forest.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require_relative '../lib/ut'
+require_relative 'helper'
+require_relative 'forest'
+require_relative 'example_window'
+
+$window = ExampleWindow.new
+
+@forest = Forest.new
+@renderer = UT::FontRenderer.new :font_name => "fonts/DejaVuSansMono.ttf", :tile_size => TILE_SIZE, :scale_x => SCALE_X, :scale_y => SCALE_Y
+@viewport = UT::Viewport.new :renderer => @renderer, :width => VIEWPORT_WIDTH, :height => VIEWPORT_HEIGHT
+@engine = UT::Engine.new :viewport => @viewport
+@engine.set_source do |x,y|
+  @forest.get_tile x, y
+end
+@engine.set_mask do |x,y|
+  @forest.is_visible? x, y
+end
+
+$window.dungeon = @forest
+$window.engine = @engine
+$window.show

data/examples/dungeon.rb

@@ -0,0 +1,102 @@
+#encoding: utf-8
+require_relative 'fov'
+
+class Dungeon
+  include ShadowcastingFieldOfView
+  attr_reader :px, :py
+
+  AT_TILE = UT::Tile.new :glyph => "@"
+  WALL_TILE = UT::Tile.new :glyph => "▒", :foreground => Gosu::Color.new(0xFF646464)
+  FLOOR_TILE = UT::Tile.new :glyph => ".", :foreground => Gosu::Color.new(0xFF323232)
+
+  def initialize
+    @px = 3
+    @py = 2
+    @map = [
+      " #####             #####      ",
+      " #...########      #...####   ",
+      " #..........#      #......#   ",
+      " #...######.#      #..###.#   ",
+      " #####    #.#      ######.####",
+      "          #.#          #.....#",
+      "          #.#          #.....#",
+      "          #.############.....#",
+      "          #..................#",
+      "          ####.###############",
+      "##########   #.#     #....#   ",
+      "#........##  #.#     #.#..#   ",
+      "#..####...#  #.#     #.#..#   ",
+      "#.........#  #.#     #.###### ",
+      "#.........#  #.#     #......# ",
+      "##.########  #.#     #......# ",
+      " #.#         #.#     #####.## ",
+      " #.#         #.#         #.#  ",
+      " #.#   #######.#         #.#  ",
+      " #.#   #.......#         #.#  ",
+      " #.#   #.....#.#         #.#  ",
+      " #.#   #.....#.#         #.#  ",
+      " #.#   #.....#.#         #.#  ",
+      " #.#   #.....#.#         #.#  ",
+      " #.#   #######.#         #.#  ",
+      " #.#         #.###########.#  ",
+      " #.#         #.............#  ",
+      " #.#############.###########  ",
+      " #...............#            ",
+      " #################            "
+    ]
+    update_fov
+  end
+
+  def width
+    @map[0].length
+  end
+
+  def height
+    @map.length
+  end
+
+  def get_tile x, y
+    return nil if x<0 || y<0
+    return AT_TILE if x==@px && y==@py
+
+    char = @map[y][x]
+    case char
+    when "."
+      FLOOR_TILE
+    when "#"
+      WALL_TILE
+    else
+      UT::NULLTILE
+    end
+  rescue
+    nil
+  end
+
+  def move_player dx, dy
+    destination = get_tile @px+dx, @py+dy
+    if destination == FLOOR_TILE
+      @px,@py = @px+dx, @py+dy
+      update_fov
+    end
+  end
+
+  def is_visible? x, y
+    @mask[[x,y]] || false
+  end
+
+  private
+
+  def update_fov
+    @mask = {}
+    do_fov @px, @py, 7
+  end
+
+  def blocked? x, y
+    return true if x < 0 || y < 0
+    return @map[y][x] == "#"
+  end
+
+  def light x, y
+    @mask[[x,y]] = true
+  end
+end

data/examples/example_window.rb

@@ -0,0 +1,47 @@
+require_relative 'helper'
+
+class ExampleWindow < Gosu::Window
+  attr_accessor :engine, :dungeon, :shader
+
+  REPEAT = 250
+
+  def initialize
+    super WINDOW_WIDTH, WINDOW_HEIGHT, false
+    @down_keys = {}
+  end
+
+  def update
+    keys = [Gosu::KbW, Gosu::KbA, Gosu::KbS, Gosu::KbD]
+    deltas = [[0,-1],[-1,0],[0,1],[1,0]]
+    keys.each_with_index do |key, i|
+      if button_down? key
+        if @down_keys.include? key
+          @down_keys[key] += update_interval
+          if @down_keys[key] > REPEAT
+            @dungeon.move_player deltas[i][0], deltas[i][1]
+            @down_keys[key] -= REPEAT
+          end
+        else
+          @dungeon.move_player deltas[i][0], deltas[i][1]
+          @down_keys[key] = update_interval
+        end
+      else
+        @down_keys.delete key
+      end
+    end
+    engine.update @dungeon.px, @dungeon.py
+    shader.center @dungeon.px, @dungeon.py unless shader.nil?
+    shader.update update_interval unless shader.nil?
+  end
+
+  def draw
+    draw_quad 0, 0, Gosu::Color::BLACK,
+              width, 0, Gosu::Color::BLACK,
+              0, height, Gosu::Color::BLACK,
+              width, height, Gosu::Color::BLACK
+
+    engine.viewport.draw
+  end
+end
+
+

data/examples/forest.rb

@@ -0,0 +1,65 @@
+#encoding: utf-8
+require_relative "fov"
+
+class Forest
+  include ShadowcastingFieldOfView
+
+  attr_reader :px, :py
+
+  GRASS = UT::Tile.new :glyph => ".", :foreground => Gosu::Color.new(0xFF509650)
+  GRASS2 = UT::Tile.new :glyph => ".", :foreground => Gosu::Color.new(0xFF5AFA5A)
+  TREE = UT::Tile.new :glyph => "☘", :foreground => Gosu::Color.new(0xFF146414)
+  ROCK = UT::Tile.new :glyph => "☁", :foreground => Gosu::Color.new(0xFF646464)
+  AT = UT::Tile.new :glyph => "@", :foreground => Gosu::Color.new(0xFFFFFFFF)
+
+  def initialize
+    @px = 0
+    @py = 0
+    update_fov
+  end
+
+  def get_tile x, y
+    return AT if x == @px && y == @py
+    r = deterministic_rand x, y
+    return TREE if (r > 0.80)
+    return ROCK if (r > 0.75)
+    return GRASS2  if (r > 0.50)
+    return GRASS;
+  end
+
+  def move_player dx, dy
+    destination = get_tile @px+dx, @py+dy
+    if destination.glyph == "."
+      @px,@py = @px+dx, @py+dy
+      update_fov
+    end
+  end
+
+  def is_visible? x, y
+    @mask[[x,y]] || false
+  end
+
+  private
+
+  def update_fov
+    @mask = {}
+    do_fov @px, @py, 13
+  end
+
+  def blocked? x, y
+    return (get_tile x, y).glyph != "."
+  end
+
+  def light x, y
+    @mask[[x,y]] = true
+  end
+
+  A = 2971215073
+  B = 479001599
+  M = 1048573;
+
+  def deterministic_rand x, y
+    num = ((A*x)^(B*y)) % M;
+    return num.to_f / M;
+  end
+end

data/examples/fov.rb

@@ -0,0 +1,70 @@
+# taken from http://roguebasin.roguelikedevelopment.org/index.php/Ruby_shadowcasting_implementation
+
+module ShadowcastingFieldOfView
+    # Multipliers for transforming coordinates into other octants
+    @@mult = [
+                [1,  0,  0, -1, -1,  0,  0,  1],
+                [0,  1, -1,  0,  0, -1,  1,  0],
+                [0,  1,  1,  0,  0, -1, -1,  0],
+                [1,  0,  0,  1, -1,  0,  0, -1],
+             ] 
+
+    # Determines which co-ordinates on a 2D grid are visible
+    # from a particular co-ordinate.
+    # start_x, start_y: center of view
+    # radius: how far field of view extends
+    def do_fov(start_x, start_y, radius)
+        light start_x, start_y
+        8.times do |oct|
+            cast_light start_x, start_y, 1, 1.0, 0.0, radius,
+                @@mult[0][oct],@@mult[1][oct],
+                @@mult[2][oct], @@mult[3][oct], 0
+        end
+    end
+    
+    private
+    # Recursive light-casting function
+    def cast_light(cx, cy, row, light_start, light_end, radius, xx, xy, yx, yy, id)
+        return if light_start < light_end
+        radius_sq = radius * radius
+        (row..radius).each do |j| # .. is inclusive
+            dx, dy = -j - 1, -j
+            blocked = false
+            while dx <= 0
+                dx += 1
+                # Translate the dx, dy co-ordinates into map co-ordinates
+                mx, my = cx + dx * xx + dy * xy, cy + dx * yx + dy * yy
+                # l_slope and r_slope store the slopes of the left and right
+                # extremities of the square we're considering:
+                l_slope, r_slope = (dx-0.5)/(dy+0.5), (dx+0.5)/(dy-0.5)
+                if light_start < r_slope
+                    next
+                elsif light_end > l_slope
+                    break
+                else
+                    # Our light beam is touching this square; light it
+                    light(mx, my) if (dx*dx + dy*dy) < radius_sq
+                    if blocked
+                        # We've scanning a row of blocked squares
+                        if blocked?(mx, my)
+                            new_start = r_slope
+                            next
+                        else
+                            blocked = false
+                            light_start = new_start
+                        end
+                    else
+                        if blocked?(mx, my) and j < radius
+                            # This is a blocking square, start a child scan
+                            blocked = true
+                            cast_light(cx, cy, j+1, light_start, l_slope,
+                                radius, xx, xy, yx, yy, id+1)
+                            new_start = r_slope
+                        end
+                    end
+                end
+            end # while dx <= 0
+            break if blocked
+        end # (row..radius+1).each
+    end
+end

data/examples/helper.rb

@@ -0,0 +1,8 @@
+TILE_SIZE = 20
+SCALE_X = 1.85
+SCALE_Y = 1.25
+WINDOW_WIDTH = 640
+WINDOW_HEIGHT = 480
+
+VIEWPORT_WIDTH = WINDOW_WIDTH/TILE_SIZE
+VIEWPORT_HEIGHT = WINDOW_HEIGHT/TILE_SIZE

data/examples/shader.rb

@@ -0,0 +1,46 @@
+class Shader
+  attr_accessor :light_color, :light_intensity, :max_dist
+
+  def initialize options = {}
+    self.light_color = options[:light_color] || Gosu::Color.new(0xFFFF2F00)
+    self.light_intensity = options[:light_intensity] || 0.7
+    self.max_dist = options[:max_dist] || 5
+    @time = 0
+    @x = 0
+    @y = 0
+  end
+
+  def apply tile, x, y
+    return tile if tile.nil?
+    anim = @time/1000.0
+    anim = (anim - anim.floor - 0.5).abs + 0.5
+    dist = distance @x, @y, x, y
+    return tile if dist > max_dist || dist == 0
+    factor = (1.0 - (dist / max_dist)) * light_intensity * anim
+    r = (blend light_color.red, tile.foreground.red, factor).round
+    g = (blend light_color.green, tile.foreground.green, factor).round
+    b = (blend light_color.blue, tile.foreground.blue, factor).round
+    argb = Integer("0xFF%02X%02X%02X" % [r, g, b])
+    shaded = tile.clone
+    shaded.foreground = Gosu::Color.new argb
+    shaded
+  end
+
+  def update delta
+    @time += delta
+  end
+
+  def center x, y
+    @x, @y = x, y
+  end
+
+  private
+
+  def distance x1, y1, x2, y2
+    Math.sqrt((x2-x1)**2 + (y2-y1)**2)
+  end
+
+  def blend a, b, f
+    a*f + b*(1.0-f)
+  end
+end

data/lib/ut.rb

@@ -0,0 +1,20 @@
+# # Unicodetiles.rb
+#
+# Ruby Port of [Unicodetiles.js](https://github.com/tapio/unicodetiles.js)
+
+$LOAD_PATH << './lib'
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'gosu'
+
+require 'ut/tile'
+require 'ut/viewport'
+require 'ut/engine'
+require 'ut/font_renderer'
+require 'ut/version'
+
+module UT
+
+end

data/lib/ut/engine.rb

@@ -0,0 +1,146 @@
+module UT
+
+  # The *Engine* is responsible for fetching the relevant *Tile*s from the
+  # `source` and checking its visibility with the `mask`. The *Tile*s are also
+  # passed to the `shader` before being finally passed to the *Viewport*.
+  # `Enigne.new` takes an `options` hash as its only parameter.
+  # The `options` hash respects three members:
+  #
+  #   * `:source`: The source used to fetch tiles. _Defaults to `DEFAULT_SOURCE`_.
+  #
+  #   * `:mask`: The mask used to determine a tile's visiblity. _Defaults to
+  #   `DEFAULT_MASK`_.
+  #
+  #   * `:shader`: The shader to preprocess tiles. _Defaults to
+  #   `DEFAULT_SOURCE`_.
+  #
+  #   * `:viewport`: The *Viewport* used for rendering.
+  #
+  #   * `:world_width`: The width of the world. _Default to `nil`_.
+  #
+  #   * `:world_height`: The height of the world. _Defaults to `nil`_.
+  class Engine
+    # The default shader. Just returns the tile it gets.
+    DEFAULT_SHADER = lambda {|tile,x,y| tile}
+    # The default tile source. Always return `Tile::NULL`
+    DEFAULT_SOURCE = lambda {|x,y| Tile::NULL}
+    # The default mask. Always returns `true`.
+    DEFAULT_MASK = lambda {|x,y| true}
+
+    # The *Viewport* used for rendering
+    attr_accessor :viewport
+    # The width and height of the world. *Tile*s 'outside' of the world are
+    # not passed to the *Viewport* for rendering.
+    # If the `world_width` and `world_height` are `nil`, the world is infinte
+    # and all tiles are rendered.
+    attr_accessor :world_height, :world_width
+
+    def initialize options = {}
+      @source = options[:source] || DEFAULT_SOURCE
+      @mask = options[:mask] || DEFAULT_MASK
+      @shader = options[:shader] || DEFAULT_SHADER
+      self.viewport = options[:viewport]
+      self.world_width = options[:world_width]
+      self.world_height = options[:world_height]
+      @cache = {}
+    end
+
+    # Takes a block that accepts a `tile`, `x` and `y` and stores it as the
+    # shader function.
+    def set_shader &blk
+      @shader = blk || DEFAULT_SHADER
+    end
+
+    # Takes a *Proc* or *lambda* which accepts a `tile`, `x` and `y` and stores
+    # it as the shader function.
+    def set_shader= shader
+      @shader = shader || DEFAULT_SHADER
+    end
+
+    # Takes a block that accepts `x` and `y` and stores it as the
+    # source function.
+    def set_source &blk
+      @source = blk || DEFAULT_SOURCE
+    end
+
+    # Takes a *Proc* or *lambda* which accepts a `x` and `y` and stores
+    # it as the source function.
+    def set_source= source
+      @source = source || DEFAULT_SOURCE
+    end
+
+    # Takes a block that accepts `x` and `y` and stores it as the
+    # mask function.
+    def set_mask &blk
+      @mask = blk || DEFAULT_MASK
+    end
+
+    # Takes a *Proc* or *lambda* which accepts a `x` and `y` and stores
+    # it as the mask function.
+    def set_mask= mask
+      @mask = mask || DEFAULT_MASK
+    end
+
+    # Fetches the *Tile* at location `[x,y]` from the source
+    def fetch x, y
+      return nil unless in_world? x, y
+      return nil unless is_visible? x, y
+
+      tile = @cache[[x, y]] if cache_enabled?
+      tile ||= @source.call x, y
+      @cache[[x, y]] = tile if cache_enabled?
+      apply_shader tile, x ,y
+    end
+
+    # Applies the shader to the `tile` at `[x,y]`
+    def apply_shader tile, x, y
+      @shader.call tile, x, y
+    end
+
+    # Determines the visibility of the *Tile* at `[x,y]`
+    def is_visible? x, y
+      @mask.call x, y
+    end
+
+    # Updates the *Engine*. `world_x` and `world_y` represents the center of the
+    # world that should be rendered in _tile coordinates_.
+    def update world_x, world_y
+      x = world_x - @viewport.center_x
+      y = world_y - @viewport.center_y
+      @viewport.width.times do |xi|
+        @viewport.height.times do |yi|
+          tx, ty = x+xi, y+yi
+          tile = fetch tx, ty
+          @viewport.put_tile xi, yi, tile
+        end
+      end
+    end
+
+    # Checks if the cache is enabled.
+    def cache_enabled?
+      @cache_enabled
+    end
+
+    # Enables or disables the cache.
+    def cache_enabled= value
+      @cache_enabled = value
+    end
+
+    # Clears the cache.
+    def clear_cache
+      @cache = {}
+    end
+
+    # Checks if a location is in the world.
+    def in_world? x, y
+      result = true
+      unless world_width.nil?
+        result &&= (x >= 0 && x < world_width)
+      end
+      unless world_height.nil?
+        result &&= (y >= 0 && y< world_height)
+      end
+      result
+    end
+  end
+end

data/lib/ut/font_renderer.rb

@@ -0,0 +1,76 @@
+module UT
+  # The *FontRenderer* uses the `Gosu::Font` class to draw the tiles on a
+  # `Gosu::Window`.
+  # `FontRenderer.new` takes an `options` hash as its only parameter.
+  # The `options` hash respects three members:
+  #
+  #   * `:window`: The `Gosu::Window`. _Defaults to `$window`._
+  #
+  #   * `:font_name`: Specifies the name of the font. Accepts the same values
+  #   as `Gosu::Font.new`. _Defaults to `nil`._
+  #
+  #   * `:tile_size`: The size of the tile on screen in _pixels_. Equivalent to the font
+  #   size. _Default to `0`_.
+  #
+  #   * `:scale_x`: Scales the font horizontally by this factor to reduce
+  #   spacing between the chars. _Default to 1_.
+  #
+  #   * `:scale_y`: Scales the font vertically by this factor to reduce spacing
+  #   between the chars. _Defaults to 1_.
+  class FontRenderer
+    attr_accessor :tile_size
+
+    def initialize options
+      @window = options[:window] || $window
+      @font_name = options[:font_name]
+      @tile_size = options[:tile_size] || 0
+      @scale_x = options[:scale_x] || 1
+      @scale_y = options[:scale_y] || 1
+      reload_font
+    end
+
+    def tile_size
+      @tile_size
+    end
+
+    def tile_size= value
+      @tile_size = value
+      reload_font
+    end
+
+    def font_name= value
+      @font_name = value
+      reload_font
+    end
+
+    def font_name
+      @font_name
+    end
+
+    # The `Gosu::Font` instance used for drawing the tiles
+    def font
+      @font
+    end
+
+    # Renders the `tile` width the top-left corner at `[left,top]` on the
+    # `window`
+    def render tile, left, top
+      @window.draw_quad left          , top            , tile.background,
+        left+tile_size, top            , tile.background,
+        left          , top + tile_size, tile.background,
+        left+tile_size, top + tile_size, tile.background
+
+      @font.draw_rel tile.glyph,
+                     left+tile_size/2, top+tile_size/2,
+                     0, 0.5, 0.5,
+                     @scale_x, @scale_y,
+                     tile.foreground
+    end
+
+    private
+
+    def reload_font
+      @font = Gosu::Font.new(@window, @font_name, @tile_size)
+    end
+  end
+end

data/lib/ut/tile.rb

@@ -0,0 +1,41 @@
+module UT
+  # A *Tile* stores all attributes required by a *Viewport* to draw it.
+  # `Tile.new` takes an `args` hash as its only parameter.
+  # The `args` hash respects three members:
+  #
+  #   * `:glyph`: The unicode character. _Defaults to `' '`._
+  #
+  #   * `:foreground`: The foreground color represented by a `Gosu::Color`
+  #   instance. _Defaults to `DEFAULT_FOREGROUND`._
+  #
+  #   * `:background`: The background color represented by a `Gosu::Color`
+  #   instance. _Defaults to `DEFAULT_BACKGROUND`._
+  class Tile
+    # The unicode character
+    attr_accessor :glyph
+    # Foreground and background color of the *Tile*
+    # Colors are stored as an instance of `Gosu::Color`
+    attr_accessor :foreground, :background
+
+    # The default foreground color is white
+    DEFAULT_FOREGROUND = Gosu::Color::WHITE
+    # the default background color is black
+    DEFAULT_BACKGROUND = Gosu::Color::BLACK
+    # An empty tile wih default fore- and background color
+    NULL = Tile.new
+
+    def initialize args = {}
+      self.glyph      = args[:glyph] || " "
+      self.foreground = args[:foreground] || DEFAULT_FOREGROUND
+      self.background = args[:background] || DEFAULT_BACKGROUND
+    end
+
+    # Clones the tile by copying all attributes to a new *Tile*. Returns the
+    # cloned tile.
+    def clone
+      Tile.new :glyph      => glyph,
+               :foreground => foreground,
+               :background => background
+    end
+  end
+end

data/lib/ut/version.rb

@@ -0,0 +1,4 @@
+module UT
+  # The current version of *unicodetiles.rb*
+  VERSION = "1.0.0"
+end

data/lib/ut/viewport.rb

@@ -0,0 +1,120 @@
+module UT
+
+  # The *viewport* stores the *Tile*s that should be drawn onto the screen as well
+  # as their location on the screen.
+  # `Viewport.new` takes an `options` hash as its only parameter.
+  # The `options` hash respects three members:
+  #
+  #   * `:renderer`: The renderer that renders the tiles. _Defaults to `nil`._
+  #
+  #   * `:left`: Specifies the horizontal offset in _pixels_ from the left side
+  #   of the screen. _Defaults to 0_.
+  #
+  #   * `:top`: Specifies the vertical offset in _pixels_ from the top of the
+  #   screen. _Defaults to 0_.
+  #
+  #   * `:width`: The width of the *Viewport* in _tiles_.
+  #
+  #   * `:height`: The height of the *Viewport* in _tiles_.
+  #
+  #   * `:wrap_mode`: The wrap mode for strings. _Defaults to `:block`_.
+  class Viewport
+    # The renderer used to draw the tiles on screen.
+    # Must repond to:
+    #
+    #   * `tile_size`: Returns the size of the rendered tile in _pixel_.
+    #
+    #   * `render(tile, left, top)`: Renders the `tile` on screen with the
+    #   top-left corner of the tile located at `[left, top]`.
+    attr_accessor :renderer
+    # Coordinates of the top-left corner of the *Viewport*.
+    attr_accessor :top, :left
+    # Width and height of the viewport measured in _tiles_.
+    attr_accessor :width, :height
+    # A flag which tells the *Viewport* how to handle strings that are longer
+    # than `width`. Accepts the following values:
+    #
+    #   * `:line`: Wraps the string into the next line and starts at the
+    #   beginning of the line.
+    #   * `:block`: Wraps the string into the next line and starts at the same
+    #   x-coordinate.
+    #   * `:none`: No wrapping of strings
+    attr_accessor :wrap_mode
+
+    def initialize options={}
+      self.renderer = options[:renderer]
+      self.left = options[:left] || 0
+      self.top = options[:top] || 0
+      self.width = options[:width]
+      self.height = options[:height]
+      self.wrap_mode = options[:wrap_mode] || :block
+
+      @tiles = {}
+    end
+
+    # Clears all tiles in the *Viewport*
+    def clear
+      @tiles = {}
+    end
+
+    # Stores the `tile` at location `[x,y]`
+    def put_tile x, y, tile
+      if tile.nil?
+        @tiles.delete [x,y]
+      else
+        @tiles[[x,y]] = tile
+      end
+    end
+
+    # Puts a `string` into the *Viewport* by creating a tile for each character
+    # and storing them in a line starting at `[x,y]`. The tiles colors can be
+    # specified by `foreground` and `background`. `wrap_mode` overrides the
+    # global `wrap_mode` of the *Viewport*.
+    def put_string x, y, string, foreground = nil, background = nil, wrap_mode = nil
+      counter = 0
+      string.each_char do |c|
+        tx, ty = case wrap_mode || self.wrap_mode
+                 when :block
+                   [x+counter%(width-x), y+(counter/(width-x)).floor]
+                 when :line
+                   [(x+counter)%width, ty = y+((x+counter)/width).floor]
+                 else
+                   [x + counter, y]
+                 end
+        put_tile tx, ty, (Tile.new :glyph => c,
+                          :foreground => foreground,
+                          :background => background)
+        counter += 1;
+      end
+    end
+
+    # Draws the tiles onto the screen using the `renderer`
+    def draw
+      @tiles.each do |coords, tile|
+        tleft = left + coords[0]*@renderer.tile_size
+        ttop = top + coords[1]*@renderer.tile_size
+        @renderer.render tile, tleft, ttop
+      end
+    end
+
+    # The width of the *Viewport* on the screen in _pixels_.
+    def render_width
+      width * @renderer.tile_size
+    end
+
+    # The height of the *Viewport* on the screen in _pixels_.
+    def render_height
+      height * @renderer.tile_size
+    end
+
+    # The x-coordinate of the center of the *Viewport* in _tiles_.
+    def center_x
+      (width/2).floor
+    end
+
+    # The y-coordinate of the center of the *Viewport* in _tiles_.
+    def center_y
+      (height/2).floor
+    end
+  end
+end

data/spec/engine_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+module UT
+  describe Engine do
+    let(:viewport) { double(Viewport) }
+    subject do
+      Engine.new :viewport => viewport
+    end
+
+    its(:viewport) { should == viewport }
+
+    describe "#update" do
+      before do
+        viewport.stub(:center_x => 1, :center_y => 2)
+        viewport.stub(:width => 2, :height => 2)
+        def subject.fetch x, y
+          {x:x, y:y}
+        end
+      end
+
+      it "updates tile in the viewport" do
+        subject.viewport.should_receive(:put_tile).with(0,0, {x:4,y:2})
+        subject.viewport.should_receive(:put_tile).with(1,0, {x:5,y:2})
+        subject.viewport.should_receive(:put_tile).with(0,1, {x:4,y:3})
+        subject.viewport.should_receive(:put_tile).with(1,1, {x:5,y:3})
+
+        subject.update 5,4
+      end
+
+    end
+
+    describe "#fetch" do
+      let(:source) { double("source") }
+      before { subject.set_source = source}
+      it "calls the source to fetch a tile" do
+        source.should_receive(:call).with(1, 2).and_return
+
+        subject.fetch 1, 2
+      end
+
+      it "returns the tile from the source" do
+        tile = Tile.new
+        source.stub(:call => tile)
+
+        (subject.fetch 0, 0).should == tile
+      end
+
+      context "when cache is enabled" do
+        before do
+          subject.cache_enabled = true
+        end
+
+        it "fetches a tile only once" do
+          source.should_receive(:call).with(0,0).once.and_return Tile.new
+
+          2.times { subject.fetch 0,0 }
+        end
+
+        it "cached tile is same as fetched tile" do
+          tile = Tile.new
+          source.should_receive(:call).with(0,0).and_return tile
+
+          subject.fetch 0, 0
+          subject.fetch(0, 0).should == tile
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require_relative '../lib/ut'

data/spec/tile_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+module UT
+  describe Tile do
+    describe '#initialize' do
+      context 'without args' do
+        its(:glyph) { should == " " }
+        its(:foreground) { should == Tile::DEFAULT_FOREGROUND }
+        its(:background) { should == Tile::DEFAULT_BACKGROUND }
+      end
+
+      context 'with args' do
+        subject do
+          Tile.new :glyph => "a",
+            :foreground => Gosu::Color::RED,
+            :background => Gosu::Color::GREEN
+        end
+
+        its(:glyph) { should == "a" }
+        its(:foreground) { should == Gosu::Color::RED }
+        its(:background) { should == Gosu::Color::GREEN }
+      end
+    end
+
+    describe '#clone' do
+      let(:tile) do
+        Tile.new :glyph => "a",
+                 :foreground => Gosu::Color::RED,
+                 :background => Gosu::Color::GREEN
+      end
+      subject { tile.clone }
+
+      its(:glyph) { should == tile.glyph }
+      its(:foreground) { should == tile.foreground }
+      its(:background) { should == tile.background }
+    end
+  end
+end

data/spec/viewport_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+module UT
+  describe Viewport do
+    let(:renderer) { double("renderer") }
+    describe '#initialize' do
+      context 'with options' do
+        let(:options) { [:renderer, :left, :top, :width, :height] }
+        subject { Viewport.new options.reduce({}){ |h,x| h[x]=x;h } }
+
+        it "assigns the options" do
+          options.each do |option|
+            (subject.send option).should == option
+          end
+        end
+      end
+    end
+
+    describe "#center_x" do
+      it "returns half width rounded down" do
+        subject.width = 3
+        subject.center_x.should == 1
+      end
+    end
+
+    describe "#center_y" do
+      it "returns half height rounded down" do
+        subject.height = 3
+        subject.center_y.should == 1
+      end
+    end
+
+    describe "#render_width" do
+      before do
+        subject.width = 2
+        subject.renderer = renderer
+        renderer.stub(:tile_size => 3)
+      end
+
+      it "computes the width required by the renderer to render the tiles" do
+        subject.render_width.should == 6
+      end
+    end
+
+    describe "#render_height" do
+      before do
+        subject.height = 2
+        subject.renderer = renderer
+        renderer.stub(:tile_size => 3)
+      end
+
+      it "computes the height required by the renderer to render the tiles" do
+        subject.render_height.should == 6
+      end
+    end
+
+    describe "#put_tile" do
+      it "updates the tile at the specified location" do
+        tile = double(Tile)
+        subject.put_tile 1, 1, tile
+        (subject.instance_variable_get :@tiles) == {[1,1] => tile}
+      end
+
+      context "when a tile is overriden" do
+        before do
+          tile1 = double(Tile, :id => 1)
+          @tile2 = double(Tile, :id => 2)
+          subject.put_tile 1, 1, tile1
+          subject.put_tile 1, 1, @tile2
+        end
+
+        it "replaces the tile" do
+          (subject.instance_variable_get :@tiles) == {[1,1] => @tile2}
+        end
+      end
+    end
+
+    describe "#draw" do
+      before do
+        subject.left = 1
+        subject.top = 2
+        renderer.stub(:tile_size => 3)
+        subject.renderer = renderer
+        @tile1 = double(Tile, :id => 1)
+        @tile2 = double(Tile, :id => 2)
+        subject.put_tile 0, 0, @tile1
+        subject.put_tile 1, 1, @tile2
+      end
+
+      it "tells the renderer to draw each tile" do
+        renderer.should_receive(:render).with(@tile1, 1, 2)
+        renderer.should_receive(:render).with(@tile2, 4, 5)
+
+        subject.draw
+      end
+    end
+  end
+end

data/ut.gemspec

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+require 'ut/version'
+
+Gem::Specification.new 'unicodetiles', UT::VERSION do |s|
+  s.description       = "A simple, text character based tile engine for creating roguelike games etc. The bundled font (DejaVu Sans Mono) has decent coverage (3289 glyphs) of Unicode, providing monospace characters for various miscellaneous symbols that can be useful in creating fancy looking character based games and user interface."
+  s.summary           = "Unicode Tile Engine"
+  s.authors           = ["Kevin Mees"]
+  s.email             = "kev.mees@gmail.com"
+  s.homepage          = "https://kmees.github.com/projects/unicodetiles"
+  s.files             = `git ls-files`.split("\n") - %w[.gitignore]
+  s.test_files        = s.files.select { |p| p =~ /^spec\/.*_spec.rb/ }
+  s.extra_rdoc_files  = s.files.select { |p| p =~ /^Readme.md/ }
+
+  s.add_dependency 'gosu', '>= 0.7'
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: unicodetiles
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Kevin Mees
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-28 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gosu
+  requirement: &23513700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: *23513700
+description: A simple, text character based tile engine for creating roguelike games
+  etc. The bundled font (DejaVu Sans Mono) has decent coverage (3289 glyphs) of Unicode,
+  providing monospace characters for various miscellaneous symbols that can be useful
+  in creating fancy looking character based games and user interface.
+email: kev.mees@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- Readme.md
+files:
+- .rspec
+- Gemfile
+- Rakefile
+- Readme.md
+- examples/01_minimal.rb
+- examples/02_simple_dungeon.rb
+- examples/03_fov_dungeon.rb
+- examples/04_shader_lightning.rb
+- examples/05_infinite_forest.rb
+- examples/dungeon.rb
+- examples/example_window.rb
+- examples/forest.rb
+- examples/fov.rb
+- examples/helper.rb
+- examples/shader.rb
+- fonts/DejaVuSansMono.ttf
+- lib/ut.rb
+- lib/ut/engine.rb
+- lib/ut/font_renderer.rb
+- lib/ut/tile.rb
+- lib/ut/version.rb
+- lib/ut/viewport.rb
+- spec/engine_spec.rb
+- spec/spec_helper.rb
+- spec/tile_spec.rb
+- spec/viewport_spec.rb
+- ut.gemspec
+homepage: https://kmees.github.com/projects/unicodetiles
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Unicode Tile Engine
+test_files:
+- spec/engine_spec.rb
+- spec/tile_spec.rb
+- spec/viewport_spec.rb