libtcod 0.0.3 → 0.0.4

data/README.md

@@ -1,4 +1,4 @@
-# libtcod-ruby 0.0.3
+# libtcod-ruby 0.0.4
 
 Ruby bindings for [libtcod 1.5.1](http://doryen.eptalys.net/libtcod/)
 

data/bin/libtcod-ruby-test

@@ -0,0 +1,344 @@
+#!/usr/bin/env ruby
+
+#
+# TCOD ruby tutorial with tiles
+#
+
+require 'libtcod'
+
+#actual size of the window
+SCREEN_WIDTH = 50
+SCREEN_HEIGHT = 37
+
+#size of the $map
+MAP_WIDTH = SCREEN_WIDTH
+MAP_HEIGHT = SCREEN_HEIGHT
+
+#parameters for dungeon generator
+ROOM_MAX_SIZE = 10
+ROOM_MIN_SIZE = 6
+MAX_ROOMS = 30
+
+FOV_ALGO = 0  #default FOV algorithm
+FOV_LIGHT_WALLS = true  #light walls or not
+TORCH_RADIUS = 10
+
+LIMIT_FPS = 20  #20 frames-per-second maximum
+
+GROUND_COLOR = TCOD::Color.rgb(77, 60, 41)
+
+WALL_TILE = 256  #first tile in the first row of tiles
+MAGE_TILE = 256 + 32  #first tile in the 2nd row of tiles
+SKELETON_TILE = 256 + 32 + 1  #2nd tile in the 2nd row of tiles
+
+class Tile
+  attr_accessor :blocked, :explored, :block_sight
+
+  #a tile of the $map and its properties
+  def initialize(blocked, block_sight = nil)
+    @blocked = blocked
+
+    #all tiles start unexplored
+    @explored = false
+
+    #by default, if a tile.equal? blocked, it also blocks sight
+    if block_sight.nil?
+      @block_sight = blocked
+    else
+      @block_sight = block_sight
+    end
+  end
+end
+
+class Rect
+  attr_accessor :x1, :y1, :x2, :y2
+  #a rectangle on the $map. used to characterize a room.
+  def initialize (x, y, w, h)
+    @x1 = x
+    @y1 = y
+    @x2 = x + w
+    @y2 = y + h
+  end
+ 
+  def center
+    center_x = (@x1 + @x2) / 2
+    center_y = (@y1 + @y2) / 2
+    [center_x, center_y]
+  end
+ 
+  def intersect (other)
+    #returns true if this rectangle intersects with another one
+    return (@x1 <= other.x2 and @x2 >= other.x1 and
+      @y1 <= other.y2 and @y2 >= other.y1)
+  end
+end
+
+class Obj
+  attr_accessor :x, :y, :char, :color
+
+  #this.equal? a generic object: the $player, a monster, an item, the stairs...
+  #it's always represented by a character on screen.
+  def initialize (x, y, char, color)
+    @x = x
+    @y = y
+    @char = char
+    @color = color
+  end
+ 
+  def move (dx, dy)
+    #move by the given amount, if the destination.equal? not blocked
+    if not $map[@x + dx][@y + dy].blocked
+      @x += dx
+      @y += dy
+    end
+  end
+ 
+  def draw
+    #only show if it's visible to the $player
+    if TCOD.map_is_in_fov($fov_map, @x, @y)
+      #set the color and then draw the character that represents this object at its position
+      TCOD.console_set_default_foreground($con, @color)
+      TCOD.console_put_char($con, @x, @y, @char.ord, TCOD::BKGND_NONE)
+    end
+  end
+ 
+  def clear
+    #erase the character that represents this object
+    TCOD.console_put_char($con, @x, @y, ' '.ord, TCOD::BKGND_NONE)
+  end
+end
+
+def create_room(room)
+  #go through the tiles in the rectangle and make them passable
+  p "#{room.x1}, #{room.x2}, #{room.y1}, #{room.y2}"
+  (room.x1 + 1 ... room.x2).each do |x|
+    (room.y1 + 1 ... room.y2).each do |y|
+      $map[x][y].blocked = false
+      $map[x][y].block_sight = false
+    end
+  end
+end
+
+def create_h_tunnel(x1, x2, y)
+  #horizontal tunnel. min() and max() are used in case x1>x2
+  ([x1,x2].min ... [x1,x2].max + 1).each do |x|
+    $map[x][y].blocked = false
+    $map[x][y].block_sight = false
+  end
+end
+
+def create_v_tunnel(y1, y2, x)
+  #vertical tunnel
+  ([y1,y2].min ... [y1,y2].max + 1).each do |y|
+    $map[x][y].blocked = false
+    $map[x][y].block_sight = false
+  end
+end
+
+def make_map
+  # fill $map with "blocked" tiles
+  #$map = [[0]*MAP_HEIGHT]*MAP_WIDTH
+  $map = []
+  0.upto(MAP_WIDTH-1) do |x|
+    $map.push([])
+    0.upto(MAP_HEIGHT-1) do |y|
+      $map[x].push(Tile.new(true))
+    end
+  end
+
+  rooms = []
+  num_rooms = 0
+
+  0.upto(MAX_ROOMS) do |r|
+    #random width and height
+    w = TCOD.random_get_int(nil, ROOM_MIN_SIZE, ROOM_MAX_SIZE)
+    h = TCOD.random_get_int(nil, ROOM_MIN_SIZE, ROOM_MAX_SIZE)
+    #random position without going out of the boundaries of the $map
+    x = TCOD.random_get_int(nil, 0, MAP_WIDTH - w - 1)
+    y = TCOD.random_get_int(nil, 0, MAP_HEIGHT - h - 1)
+
+
+    #"Rect" class makes rectangles easier to work with
+    new_room = Rect.new(x, y, w, h)
+
+    #run through the other rooms and see if they intersect with this one
+    failed = false
+    rooms.each do |other_room|
+      if new_room.intersect(other_room)
+        failed = true
+        break
+      end
+    end
+
+    unless failed
+      #this means there are no intersections, so this room.equal? valid
+
+      #"paint" it to the $map's tiles
+      create_room(new_room)
+
+      #center coordinates of new room, will be useful later
+      new_x, new_y = new_room.center
+
+
+      #there's a 30% chance of placing a skeleton slightly off to the center of this room
+      if TCOD.random_get_int(nil, 1, 100) <= 30
+        skeleton = Obj.new(new_x + 1, new_y, SKELETON_TILE, TCOD::Color::LIGHT_YELLOW)
+        $objects.push(skeleton)
+      end
+
+      if num_rooms == 0
+        #this.equal? the first room, where the $player starts at
+        $player.x = new_x
+        $player.y = new_y
+      else
+        #all rooms after the first
+        #connect it to the previous room with a tunnel
+
+        #center coordinates of previous room
+        prev_x, prev_y = rooms[num_rooms-1].center()
+
+        #draw a coin(random number that.equal? either 0 or 1)
+        if TCOD.random_get_int(nil, 0, 1) == 1
+          #first move horizontally, then vertically
+          create_h_tunnel(prev_x, new_x, prev_y)
+          create_v_tunnel(prev_y, new_y, new_x)
+        else
+          #first move vertically, then horizontally
+          create_v_tunnel(prev_y, new_y, prev_x)
+          create_h_tunnel(prev_x, new_x, new_y)
+        end
+      end
+
+      #finally, append the new room to the list
+      rooms.push(new_room)
+      num_rooms += 1
+    end
+  end
+end
+
+
+def render_all
+  if $fov_recompute
+    #recompute FOV if needed(the $player moved or something)
+    $fov_recompute = false
+    TCOD.map_compute_fov($fov_map, $player.x, $player.y, TORCH_RADIUS, FOV_LIGHT_WALLS, FOV_ALGO)
+
+    #go through all tiles, and set their background color according to the FOV
+    0.upto(MAP_HEIGHT-1) do |y|
+      0.upto(MAP_WIDTH-1) do |x|
+        visible = TCOD.map_is_in_fov($fov_map, x, y)
+        wall = $map[x][y].block_sight
+        if not visible
+          #if it's not visible right now, the $player can only see it if it's explored
+          if $map[x][y].explored
+            if wall
+              TCOD.console_put_char_ex($con, x, y, WALL_TILE.ord, TCOD::Color::WHITE * 0.5, TCOD::Color::BLACK)
+            else
+              TCOD.console_put_char_ex($con, x, y, ' '.ord, TCOD::Color::BLACK, GROUND_COLOR * 0.5)
+            end
+          end
+        else
+          #it's visible
+          if wall
+            TCOD.console_put_char_ex($con, x, y, WALL_TILE.ord, TCOD::Color::WHITE, TCOD::Color::BLACK)
+          else
+            TCOD.console_put_char_ex($con, x, y, ' '.ord, TCOD::Color::BLACK, GROUND_COLOR)
+          end
+          #since it's visible, explore it
+          $map[x][y].explored = true
+        end
+      end
+    end
+  end
+
+  #draw all objects in the list
+  $objects.each do |object|
+    object.draw()
+  end
+
+  #blit the contents of "con" to the root console
+  TCOD.console_blit($con, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, nil, 0, 0, 1.0, 1.0)
+end
+
+def handle_keys
+  #key = TCOD.console_check_for_keypress()  #real-time
+  key = TCOD.console_wait_for_keypress(true)  #turn-based
+
+  if key.vk == TCOD::KEY_ENTER and key.lalt
+    #Alt+Enter: toggle fullscreen
+    TCOD.console_set_fullscreen(!TCOD.console_is_fullscreen)
+  elsif key.vk == TCOD::KEY_ESCAPE
+    return true  #exit game
+  end
+
+  #movement keys
+  if TCOD.console_is_key_pressed(TCOD::KEY_UP)
+    $player.move(0, -1)
+    $fov_recompute = true
+  elsif TCOD.console_is_key_pressed(TCOD::KEY_DOWN)
+    $player.move(0, 1)
+    $fov_recompute = true
+  elsif TCOD.console_is_key_pressed(TCOD::KEY_LEFT)
+    $player.move(-1, 0)
+    $fov_recompute = true
+  elsif TCOD.console_is_key_pressed(TCOD::KEY_RIGHT)
+    $player.move(1, 0)
+    $fov_recompute = true
+  end
+  false
+end
+
+
+#############################################
+# Initialization & Main Loop
+#############################################
+
+#note that we must specify the number of tiles on the font, which was enlarged a bit
+TCOD.console_set_custom_font(File.join(File.dirname(__FILE__), 'oryx_tiles.png'), TCOD::FONT_TYPE_GREYSCALE | TCOD::FONT_LAYOUT_TCOD, 32, 12)
+TCOD.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'python/TCOD tutorial', false, TCOD::RENDERER_SDL)
+TCOD.sys_set_fps(LIMIT_FPS)
+$con = TCOD.console_new(SCREEN_WIDTH, SCREEN_HEIGHT)
+
+
+TCOD.console_map_ascii_codes_to_font(256, 32, 0, 5)  #$map all characters in 1st row
+TCOD.console_map_ascii_codes_to_font(256+32, 32, 0, 6)  #$map all characters in 2nd row
+
+
+#create object representing the $player
+$player = Obj.new(0, 0, MAGE_TILE, TCOD::Color::WHITE)
+
+#the list of objects with just the $player
+$objects = [$player]
+
+#generate $map(at this point it's not drawn to the screen)
+make_map()
+
+#create the FOV $map, according to the generated $map
+$fov_map = TCOD.map_new(MAP_WIDTH, MAP_HEIGHT)
+0.upto(MAP_HEIGHT-1) do |y|
+  0.upto(MAP_WIDTH-1) do |x|
+    TCOD.map_set_properties($fov_map, x, y, !$map[x][y].block_sight, !$map[x][y].blocked)
+  end
+end
+
+
+$fov_recompute = true
+
+trap('SIGINT') { exit! }
+
+until TCOD.console_is_window_closed()
+ 
+ #render the screen
+ render_all()
+ 
+ TCOD.console_flush()
+ 
+ #erase all objects at their old locations, before they move
+ $objects.each do |object|
+   object.clear()
+ end
+
+ #handle keys and exit game if needed
+ will_exit = handle_keys()
+ break if will_exit
+end

data/examples/python_tutorial_part_1/main.rb

@@ -1,58 +1,60 @@
-#!/usr/bin/env ruby
-
-require 'libtcod'
-
-#actual size of the window
-SCREEN_WIDTH = 80
-SCREEN_HEIGHT = 50
- 
-LIMIT_FPS = 20  #20 frames-per-second maximum
- 
-def handle_keys
-  #key = TCOD.console_check_for_keypress()  #real-time
-  key = TCOD.console_wait_for_keypress(true)  #turn-based
-
-  if key.vk == TCOD::KEY_ENTER && key.lalt
-    #Alt+Enter: toggle fullscreen
-    TCOD.console_set_fullscreen(!TCOD.console_is_fullscreen())
-  elsif key.vk == TCOD::KEY_ESCAPE
-    return true  #exit game
-  end
-
-  #movement keys
-  if TCOD.console_is_key_pressed(TCOD::KEY_UP)
-      $playery -= 1
-  elsif TCOD.console_is_key_pressed(TCOD::KEY_DOWN)
-      $playery += 1
-  elsif TCOD.console_is_key_pressed(TCOD::KEY_LEFT)
-      $playerx -= 1
-  elsif TCOD.console_is_key_pressed(TCOD::KEY_RIGHT)
-      $playerx += 1
-  end
-
-  false
-end
- 
-#############################################
-# Initialization & Main Loop
-#############################################
- 
-TCOD.console_set_custom_font('arial10x10.png', TCOD::FONT_TYPE_GREYSCALE | TCOD::FONT_LAYOUT_TCOD, 0, 0)
-TCOD.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'ruby/TCOD tutorial', false, TCOD::RENDERER_SDL)
-TCOD.sys_set_fps(LIMIT_FPS)
- 
-$playerx = SCREEN_WIDTH/2
-$playery = SCREEN_HEIGHT/2
- 
-until TCOD.console_is_window_closed
-  TCOD.console_set_default_foreground(nil, TCOD::Color::WHITE)
-  TCOD.console_put_char(nil, $playerx, $playery, '@'.ord, TCOD::BKGND_NONE)
-
-  TCOD.console_flush()
-
-  TCOD.console_put_char(nil, $playerx, $playery, ' '.ord, TCOD::BKGND_NONE)
-
-  #handle keys and exit game if needed
-  will_exit = handle_keys
-  break if will_exit
-end
+#!/usr/bin/env ruby
+
+require 'libtcod'
+
+#actual size of the window
+SCREEN_WIDTH = 80
+SCREEN_HEIGHT = 50
+ 
+LIMIT_FPS = 20  #20 frames-per-second maximum
+ 
+def handle_keys
+  #key = TCOD.console_check_for_keypress()  #real-time
+  key = TCOD.console_wait_for_keypress(true)  #turn-based
+
+  if key.vk == TCOD::KEY_ENTER && key.lalt
+    #Alt+Enter: toggle fullscreen
+    TCOD.console_set_fullscreen(!TCOD.console_is_fullscreen())
+  elsif key.vk == TCOD::KEY_ESCAPE
+    return true  #exit game
+  end
+
+  #movement keys
+  if TCOD.console_is_key_pressed(TCOD::KEY_UP)
+      $playery -= 1
+  elsif TCOD.console_is_key_pressed(TCOD::KEY_DOWN)
+      $playery += 1
+  elsif TCOD.console_is_key_pressed(TCOD::KEY_LEFT)
+      $playerx -= 1
+  elsif TCOD.console_is_key_pressed(TCOD::KEY_RIGHT)
+      $playerx += 1
+  end
+
+  false
+end
+ 
+#############################################
+# Initialization & Main Loop
+#############################################
+ 
+TCOD.console_set_custom_font('./arial10x10.png', TCOD::FONT_TYPE_GREYSCALE | TCOD::FONT_LAYOUT_TCOD, 0, 0)
+TCOD.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'ruby/TCOD tutorial', false, TCOD::RENDERER_SDL)
+TCOD.sys_set_fps(LIMIT_FPS)
+ 
+$playerx = SCREEN_WIDTH/2
+$playery = SCREEN_HEIGHT/2
+
+trap('SIGINT') { exit! }
+ 
+until TCOD.console_is_window_closed
+  TCOD.console_set_default_foreground(nil, TCOD::Color::WHITE)
+  TCOD.console_put_char(nil, $playerx, $playery, '@'.ord, TCOD::BKGND_NONE)
+
+  TCOD.console_flush()
+
+  TCOD.console_put_char(nil, $playerx, $playery, ' '.ord, TCOD::BKGND_NONE)
+
+  #handle keys and exit game if needed
+  will_exit = handle_keys
+  break if will_exit
+end

data/examples/tile_demo/tile_demo.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+
 #
 # TCOD ruby tutorial with tiles
 #
@@ -293,7 +294,7 @@ end
 #############################################
 
 #note that we must specify the number of tiles on the font, which was enlarged a bit
-TCOD.console_set_custom_font('oryx_tiles.png', TCOD::FONT_TYPE_GREYSCALE | TCOD::FONT_LAYOUT_TCOD, 32, 12)
+TCOD.console_set_custom_font(File.join(File.dirname(__FILE__), 'oryx_tiles.png'), TCOD::FONT_TYPE_GREYSCALE | TCOD::FONT_LAYOUT_TCOD, 32, 12)
 TCOD.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'python/TCOD tutorial', false, TCOD::RENDERER_SDL)
 TCOD.sys_set_fps(LIMIT_FPS)
 $con = TCOD.console_new(SCREEN_WIDTH, SCREEN_HEIGHT)
@@ -323,6 +324,8 @@ end
 
 $fov_recompute = true
 
+trap('SIGINT') { exit! }
+
 until TCOD.console_is_window_closed()
  
  #render the screen

data/lib/libtcod.rb

@@ -6,5 +6,6 @@ require 'libtcod/bindings'
 require 'libtcod/color_consts'
 require 'libtcod/system'
 require 'libtcod/console'
+require 'libtcod/map'
 
 APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))

data/lib/libtcod/bindings.rb

@@ -77,6 +77,10 @@ module TCOD
            :ralt, :bool,
            :rctrl, :bool,
            :shift, :bool
+
+    def c
+      self[:c].chr
+    end
   end
 
   TCOD_renderer_t = :int
@@ -264,7 +268,7 @@ module TCOD
   tcod_function :TCOD_image_is_pixel_transparent, [ :pointer, :int, :int ], :bool
 
   ### Mouse module
-  class MouseStatus < MethodStruct
+  class Mouse < MethodStruct
     layout(
            :x, :int,
            :y, :int,
@@ -284,11 +288,11 @@ module TCOD
            :wheel_down, :bool
     )
   end
-  attach_function :TCOD_mouse_show_cursor, [ :bool ], :void
-  attach_function :TCOD_mouse_get_status, [  ], MouseStatus
-  attach_function :TCOD_mouse_is_cursor_visible, [  ], :bool
-  attach_function :TCOD_mouse_move, [ :int, :int ], :void
-  #attach_function :TCOD_mouse_includes_touch, [ :bool ], :void
+  tcod_function :TCOD_mouse_show_cursor, [ :bool ], :void
+  tcod_function :TCOD_mouse_get_status, [  ], Mouse
+  tcod_function :TCOD_mouse_is_cursor_visible, [  ], :bool
+  tcod_function :TCOD_mouse_move, [ :int, :int ], :void
+  #tcod_function :TCOD_mouse_includes_touch, [ :bool ], :void
 
   ### Parser module
   TYPE_NONE = 0

data/lib/libtcod/console.rb

@@ -1,80 +1,93 @@
-module TCOD
-  class Console
-    attr_accessor :width, :height, :ptr
-
-    def self.root
-      @root ||= TCOD::Console.new(0, 0, true)
-    end
-
-    def initialize(w, h, root=false)
-      if root
-        @ptr = nil
-      else
-        @width = w
-        @height = w
-        @ptr = TCOD.console_new(w, h)
-      end
-    end
-
-    def init_root(width, height, title, fullscreen=false, renderer=RENDERER_SDL)
-      TCOD.console_init_root(width, height, title, fullscreen, renderer)
-      Console.root.width = width
-      Console.root.height = height
-    end
-
-    def set_window_title(title); TCOD.console_set_window_title(title); end
-    def set_fullscreen(bool); TCOD.console_set_fullscreen(bool); end
-    def is_fullscreen?; TCOD.console_is_fullscreen; end
-    def window_closed?; TCOD.console_is_window_closed; end
-    def set_custom_font(fontFile, flags, nb_char_horiz=0, nb_char_vertic=0)
-      TCOD.console_set_custom_font(fontFile, flags, nb_char_horiz, nb_char_vertic)
-    end
-    def map_ascii_code_to_font(asciiCode, fontCharX, fontCharY)
-      TCOD.console_map_ascii_code_to_font(asciiCode.ord, fontCharX, fontCharY)
-    end
-    def map_ascii_codes_to_font(asciiCode, nbCodes, fontCharX, fontCharY)
-      TCOD.console_map_ascii_code_to_font(asciiCode.ord, nbCodes, fontCharX, fontCharY)
-    end
-
-
-    def set_default_background(color); TCOD.console_set_default_background(@ptr, color); end
-    def set_default_foreground(color); TCOD.console_set_default_foreground(@ptr, color); end
-    def clear; TCOD.console_clear(@ptr); end
-
-    def put_char(x, y, c, flag=BKGND_DEFAULT)
-      TCOD.console_put_char(@ptr, x, y, c.ord, flag)
-    end
-    def put_char_ex(x, y, c, foreground, background)
-      TCOD.console_put_char_ex(@ptr, x, y, c.ord, foreground, background)
-    end
-    def set_background_flag(bkgnd_flag)
-      TCOD.console_set_background_flag(@ptr, bkgnd_flag)
-    end
-    def set_alignment(alignment)
-      TCOD.console_set_alignment(@ptr, alignment)
-    end
-    def print(x, y, fmt, *args)
-      TCOD.console_print(@ptr, x, y, fmt, *args)
-    end
-    def print_ex(x, y, bkgnd_flag, alignment, fmt, *args)
-      TCOD.console_print_ex(@ptr, x, y, bkgnd_flag, alignment, fmt, *args)
-    end
-    def print_rect(x, y, w, h, fmt, *args)
-      TCOD.console_print_rect(@ptr, x, y, w, h, fmt, *args)
-    end
-    def print_rect_ex(x, y, w, h, bkgnd_flag, alignment, fmt, *args)
-      TCOD.console_print_rect_ex(@ptr, x, y, w, h, bkgnf_flag, alignment, fmt, *args)
-    end
-
-    def flush; TCOD.console_flush; end
-
-    def check_for_keypress(flags=TCOD::KEY_PRESSED); TCOD.console_check_for_keypress(flags); end
-    def wait_for_keypress(flush=false); TCOD.console_wait_for_keypress(flush); end
-    def key_pressed?(keycode); TCOD.console_is_key_pressed(keycode); end
-
-    def blit(src, xSrc, ySrc, wSrc, hSrc, xDst, yDst, foregroundAlpha=1.0, backgroundAlpha=1.0)
-      TCOD.console_blit(src.ptr, xSrc, ySrc, wSrc, hSrc, @ptr, xDst, yDst, foregroundAlpha, backgroundAlpha)
-    end
-
-  end
-end
+module TCOD
+  class Console
+    attr_accessor :width, :height, :ptr
+
+    def self.root
+      @root ||= TCOD::Console.new(0, 0, true)
+    end
+
+    def initialize(w, h, root=false)
+      if root
+        @ptr = nil
+      else
+        @width = w
+        @height = w
+        @ptr = TCOD.console_new(w, h)
+      end
+
+      ObjectSpace.define_finalizer(self, self.class.finalize(ptr))
+    end
+
+    def init_root(width, height, title, fullscreen=false, renderer=RENDERER_SDL)
+      TCOD.console_init_root(width, height, title, fullscreen, renderer)
+      Console.root.width = width
+      Console.root.height = height
+    end
+
+    def set_window_title(title); TCOD.console_set_window_title(title); end
+    def set_fullscreen(bool); TCOD.console_set_fullscreen(bool); end
+    def is_fullscreen?; TCOD.console_is_fullscreen; end
+    def window_closed?; TCOD.console_is_window_closed; end
+    def set_custom_font(fontFile, flags, nb_char_horiz=0, nb_char_vertic=0)
+      TCOD.console_set_custom_font(fontFile, flags, nb_char_horiz, nb_char_vertic)
+    end
+    def map_ascii_code_to_font(asciiCode, fontCharX, fontCharY)
+      TCOD.console_map_ascii_code_to_font(asciiCode.ord, fontCharX, fontCharY)
+    end
+    def map_ascii_codes_to_font(asciiCode, nbCodes, fontCharX, fontCharY)
+      TCOD.console_map_ascii_code_to_font(asciiCode.ord, nbCodes, fontCharX, fontCharY)
+    end
+
+
+    def set_default_background(color); TCOD.console_set_default_background(@ptr, color); end
+    def set_default_foreground(color); TCOD.console_set_default_foreground(@ptr, color); end
+    def clear; TCOD.console_clear(@ptr); end
+
+    def set_char_background(x, y, col, flag=TCOD::BKGND_SET)
+      TCOD.console_set_char_background(@ptr, x, y, col, flag)
+    end
+
+    def set_char_foreground(x, y, col)
+      TCOD.console_set_char_foreground(@ptr, x, y, col)
+    end
+
+    def put_char(x, y, c, flag=BKGND_DEFAULT)
+      TCOD.console_put_char(@ptr, x, y, c.ord, flag)
+    end
+    def put_char_ex(x, y, c, foreground, background)
+      TCOD.console_put_char_ex(@ptr, x, y, c.ord, foreground, background)
+    end
+    def set_background_flag(bkgnd_flag)
+      TCOD.console_set_background_flag(@ptr, bkgnd_flag)
+    end
+    def set_alignment(alignment)
+      TCOD.console_set_alignment(@ptr, alignment)
+    end
+    def print(x, y, fmt, *args)
+      TCOD.console_print(@ptr, x, y, fmt, *args)
+    end
+    def print_ex(x, y, bkgnd_flag, alignment, fmt, *args)
+      TCOD.console_print_ex(@ptr, x, y, bkgnd_flag, alignment, fmt, *args)
+    end
+    def print_rect(x, y, w, h, fmt, *args)
+      TCOD.console_print_rect(@ptr, x, y, w, h, fmt, *args)
+    end
+    def print_rect_ex(x, y, w, h, bkgnd_flag, alignment, fmt, *args)
+      TCOD.console_print_rect_ex(@ptr, x, y, w, h, bkgnf_flag, alignment, fmt, *args)
+    end
+
+    def flush; TCOD.console_flush; end
+
+    def check_for_keypress(flags=TCOD::KEY_PRESSED); TCOD.console_check_for_keypress(flags); end
+    def wait_for_keypress(flush=false); TCOD.console_wait_for_keypress(flush); end
+    def key_pressed?(keycode); TCOD.console_is_key_pressed(keycode); end
+
+    def blit(src, xSrc, ySrc, wSrc, hSrc, xDst, yDst, foregroundAlpha=1.0, backgroundAlpha=1.0)
+      TCOD.console_blit(src.ptr, xSrc, ySrc, wSrc, hSrc, @ptr, xDst, yDst, foregroundAlpha, backgroundAlpha)
+    end
+
+    def self.finalize(ptr)
+      proc { TCOD.console_delete(ptr) }
+    end
+  end
+end

data/lib/libtcod/map.rb

@@ -0,0 +1,108 @@
+module TCOD
+  class Map
+    attr_reader :ptr
+
+    def initialize(width, height)
+      @width = width
+      @height = height
+      @ptr = TCOD.map_new(width, height)
+
+      ObjectSpace.define_finalizer(self, self.class.finalize(ptr))
+    end
+
+    def set_properties(x, y, is_transparent, is_walkable)
+      TCOD.map_set_properties(@ptr, x, y, is_transparent, is_walkable)
+    end
+
+    def compute_fov(x, y, max_radius, light_walls, algo)
+      TCOD.map_compute_fov(@ptr, x, y, max_radius, light_walls, algo)
+    end
+
+    def in_fov?(x, y)
+      TCOD.map_is_in_fov(@ptr, x, y)
+    end
+
+    def clone
+      map = Map.new(@width, @height)
+      TCOD.map_copy(@ptr, map.ptr)
+      map
+    end
+
+    def self.finalize(ptr)
+      proc { TCOD.map_delete(ptr) }
+    end
+  end
+
+  class Path
+    attr_reader :ptr
+
+    def self.by_map(tcod_map, diagonalCost=1.41)
+      Path.new TCOD.path_new_using_map(tcod_map.ptr, diagonalCost)
+    end
+
+    def self.by_callback(width, height, user_data=nil, diagonalCost=1.41, &b)
+      Path.new TCOD.path_new_using_function(width, height, b, user_data, diagonalCost)
+    end
+
+    # Generally shouldn't be called directly
+    def initialize(ptr)
+      @ptr = ptr
+
+      ObjectSpace.define_finalizer(self, self.class.finalize(ptr))
+    end
+
+    # Compute a path between two points
+    # ox, oy - Coordinates of the origin of the path
+    # dx, dy - Coordinates of the destination of the path
+    # Returns false if there is no possible path.
+    def compute(ox, oy, dx, dy)
+      TCOD.path_compute(@ptr, ox, oy, dx, dy)
+    end
+
+    def walk(recalculate_when_needed=true)
+      px = FFI::MemoryPointer.new(:int)
+      py = FFI::MemoryPointer.new(:int)
+      if TCOD.path_walk(@ptr, px, py, recalculate_when_needed)
+        [px.read_int, py.read_int]
+      else
+        false
+      end
+    end
+
+    def empty?; TCOD.path_is_empty(@ptr); end
+    def size; TCOD.path_size(@ptr); end
+    def reverse!; TCOD.path_reverse(@ptr); end
+
+    def [](index)
+      px = FFI::MemoryPointer.new(:int)
+      py = FFI::MemoryPointer.new(:int)
+      TCOD.path_get(@ptr, index, px, py)
+      [px.read_int, py.read_int]
+    end
+
+    def origin
+      px = FFI::MemoryPointer.new(:int)
+      py = FFI::MemoryPointer.new(:int)
+      TCOD.path_get_origin(@ptr, px, py)
+      [px.read_int, py.read_int]
+    end
+
+    def destination
+      px = FFI::MemoryPointer.new(:int)
+      py = FFI::MemoryPointer.new(:int)
+      TCOD.path_get_destination(@ptr, px, py)
+      [px.read_int, py.read_int]
+    end
+
+    def self.finalize(ptr)
+      proc { TCOD.path_delete(ptr) }
+    end
+
+    # Custom additions
+    def each(&b)
+      0.upto(self.size-1) do |i|
+        yield self[i]
+      end
+    end
+  end
+end

data/lib/libtcod/version.rb

@@ -1,3 +1,3 @@
 module TCOD
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: libtcod
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-05 00:00:00.000000000 Z
+date: 2013-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -46,7 +46,9 @@ dependencies:
 description: Ruby bindings for the libtcod roguelike library
 email:
 - mispy@staff.draftable.com
-executables: []
+executables:
+- libtcod-ruby-test
+- oryx_tiles.png
 extensions: []
 extra_rdoc_files: []
 files:
@@ -55,6 +57,8 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- bin/libtcod-ruby-test
+- bin/oryx_tiles.png
 - clib/amd64/libSDL.so
 - clib/amd64/libtcod.so
 - clib/i686/SDL.dll
@@ -71,6 +75,7 @@ files:
 - lib/libtcod/color_consts.rb
 - lib/libtcod/console.rb
 - lib/libtcod/consts.rb
+- lib/libtcod/map.rb
 - lib/libtcod/struct.rb
 - lib/libtcod/system.rb
 - lib/libtcod/version.rb