survivor 0.1.0.alpha2

data/.gitignore

@@ -0,0 +1,2 @@
+gem/
+*.gem

data/.rvmrc

@@ -0,0 +1 @@
+rvm --create 1.9.3@survivor

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,15 @@
+PATH
+  remote: .
+  specs:
+    survivor (0.1.0.alpha)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  survivor!

data/Rakefile

@@ -0,0 +1,57 @@
+this_dir  = File.expand_path('..', __FILE__)
+gem_dir   = File.join this_dir, 'gem'
+spec_file = File.join this_dir, 'survivor.gemspec'
+
+spec = Gem::Specification.load spec_file
+
+task :mkdir do
+  FileUtils.mkdir_p gem_dir
+end
+
+task :gem => :mkdir do
+  gem_file = File.join this_dir, Gem::Builder.new(spec).build
+  FileUtils.mv gem_file, gem_dir
+end
+
+namespace :gem do
+
+  task :build => :gem
+
+  gem_file = File.join gem_dir, "#{spec.name}-#{spec.version}.gem"
+
+  task :push => :gem do
+    sh "gem push #{gem_file}"
+  end
+
+  task :install => :gem do
+    sh "gem install #{gem_file}"
+  end
+
+  task :uninstall do
+    sh "gem uninstall #{spec.name}"
+  end
+
+  task :clean do
+    FileUtils.rm_rf gem_dir
+  end
+
+end
+
+task :clean => 'gem:clean'
+
+task :setup => [ 'gem:install', :clean ]
+
+task :run => :setup do
+  system 'survivor'
+end
+
+namespace :run do
+
+  task :map, [ :file ] => :setup do |task, args|
+    file = args[:file]
+    system "survivor --map #{file}"
+  end
+
+end
+
+task :default => :run

data/bin/survivor

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'survivor'
+require 'survivor/options'
+require 'survivor/options/parser'
+
+options = Survivor::Options.new
+Survivor::Options::Parser.new(options).parse!
+
+Survivor.run(options)

data/lib/survivor.rb

@@ -0,0 +1,22 @@
+require 'survivor/game'
+require 'survivor/options'
+
+module Survivor
+
+  def self.run(options = Options.new)
+    Survivor::Game.new(options).run
+  end
+
+  def self.root
+    File.expand_path '../..', __FILE__
+  end
+
+  def self.maps
+    File.join root, 'maps'
+  end
+
+  def self.map(filename)
+    File.join maps, filename
+  end
+
+end

data/lib/survivor/core_ext/hash.rb

@@ -0,0 +1,15 @@
+module Survivor
+  module CoreExt
+    class ::Hash
+
+      def map!
+        merge!(self) { |key, value| yield value }
+      end
+
+      def try_map!
+        map! { |value| yield value rescue value }
+      end
+
+    end
+  end
+end

data/lib/survivor/core_ext/kernel.rb

@@ -0,0 +1,11 @@
+module Survivor
+  module CoreExt
+    module ::Kernel
+
+      def with(object, &block)
+        object.instance_eval(&block)
+      end
+
+    end
+  end
+end

data/lib/survivor/game.rb

@@ -0,0 +1,48 @@
+require 'survivor/game/creature/character'
+require 'survivor/game/logic/movement'
+require 'survivor/game/map'
+require 'survivor/game/map/tile'
+require 'survivor/ui'
+
+module Survivor
+  class Game
+
+    attr_reader :character, :map
+
+    def initialize(options)
+      @map = Map.load(options.map_location)
+      @character = Creature::Character.new.tap do |character|
+        character.coordinates = map.starting_point
+      end
+    end
+
+    def run
+      game_loop
+    end
+
+    private
+
+    def game_loop
+      UI.run do |ui|
+        loop do
+          ui.display self
+          handle ui.input do |input|
+            ui.message input
+          end
+        end
+      end
+    end
+
+    def handle(input)
+      case input
+        when :q     then exit
+        when :up    then Logic::Movement.move_up    character, map
+        when :down  then Logic::Movement.move_down  character, map
+        when :left  then Logic::Movement.move_left  character, map
+        when :right then Logic::Movement.move_right character, map
+        else yield input
+      end
+    end
+
+  end
+end

data/lib/survivor/game/creature.rb

@@ -0,0 +1,33 @@
+require 'survivor/game/map/coordinates'
+
+module Survivor
+  class Game
+    class Creature
+
+      attr_accessor :coordinates
+      attr_reader   :char, :color
+
+      def initialize(char, color = :white)
+        @char, @color = char, color
+        self.coordinates = Map::Coordinates.new
+      end
+
+      def x=(value)
+        self.coordinates = Map::Coordinates[value, y]
+      end
+
+      def y=(value)
+        self.coordinates = Map::Coordinates[x, value]
+      end
+
+      def x
+        coordinates.x
+      end
+
+      def y
+        coordinates.y
+      end
+
+    end
+  end
+end

data/lib/survivor/game/creature/character.rb

@@ -0,0 +1,15 @@
+require 'survivor/game/creature'
+
+module Survivor
+  class Game
+    class Creature
+      class Character < Creature
+
+        def initialize
+          super '@'
+        end
+
+      end
+    end
+  end
+end

data/lib/survivor/game/logic.rb

@@ -0,0 +1,11 @@
+module Survivor
+  class Game
+    module Logic
+
+      def self.surroundings(creature, map, reach = {})
+        map.area_around creature.coordinates, reach
+      end
+
+    end
+  end
+end

data/lib/survivor/game/logic/movement.rb

@@ -0,0 +1,33 @@
+require 'survivor/game/map/coordinates'
+
+module Survivor
+  class Game
+    module Logic
+      module Movement
+
+        def self.move(creature, map, dx, dy)
+          coordinates = Map::Coordinates[dx + creature.x, dy + creature.y]
+          tile = map[coordinates]
+          creature.coordinates = coordinates if tile and tile.passable?
+        end
+
+        def self.move_up(creature, map, n = 1)
+          move creature, map, 0, n
+        end
+
+        def self.move_down(creature, map, n = 1)
+          move creature, map, 0, -n
+        end
+
+        def self.move_left(creature, map, n = 1)
+          move creature, map, -n, 0
+        end
+
+        def self.move_right(creature, map, n = 1)
+          move creature, map, n, 0
+        end
+
+      end
+    end
+  end
+end

data/lib/survivor/game/map.rb

@@ -0,0 +1,116 @@
+require 'survivor/core_ext/hash'
+require 'survivor/game/map/coordinates'
+require 'survivor/game/map/custom_yaml_format'
+
+module Survivor
+  class Game
+    class Map
+
+      include Enumerable
+
+      attr_accessor :starting_point
+
+      def initialize(options = {})
+        options.try_map!(&:abs)
+        @map = Hash.new(options.fetch(:default_tile, nil))
+        0.upto(options.fetch(:lines, 0)) do |y|
+          0.upto(options.fetch(:columns, 0)) do |x|
+            coordinates = Coordinates[x, y]
+            @map[coordinates] = yield coordinates
+          end
+        end if block_given?
+        @starting_point = options.fetch(:starting_point, Coordinates[0, 0])
+      end
+
+      def [](coordinates)
+        @map[coordinates]
+      end
+
+      def []=(coordinates, value)
+        @map[coordinates] = value
+      end
+
+      def tiles
+        @map.values
+      end
+
+      def each
+        @map.each_key { |coordinates| yield coordinates }
+      end
+
+      def each_tile
+        @map.each_value { |tile| yield tile }
+      end
+
+      def each_with_coordinates
+        @map.each { |coordinates, tile| yield tile, coordinates }
+      end
+
+      def lines
+        (Hash.new { |hash, key| hash[key] = Array.new }).tap do |lines|
+          group_by { |coordinate| coordinate.y }.each do |line_number, coordinates|
+            coordinates.each do |coordinate|
+              lines[line_number] << @map[coordinate]
+            end
+          end
+        end
+      end
+
+      def each_line
+        lines.tap do |lines|
+          lines.keys.each do |line_number|
+            yield lines[line_number]
+          end
+        end
+      end
+
+      def each_line_string
+        each_line do |line|
+          yield line.map(&:to_s).join
+        end
+      end
+
+      def area_around(coordinates, reach = {})
+        cx, cy = *coordinates
+        reach.try_map!(&:abs)
+        default = +(reach.fetch(:default, 1))
+        up      = +(reach.fetch(:up,      default))
+        down    = -(reach.fetch(:down,    default))
+        left    = -(reach.fetch(:left,    default))
+        right   = +(reach.fetch(:right,   default))
+        #
+        # (cx - n, cy + n) (cx - 1, cy + n) (cx, cy + n) (cx + 1, cy + n) (cx + n, cy + n)
+        # (cx - n, cy + 1) (cx - 1, cy + 1) (cx, cy + 1) (cx + 1, cy + 1) (cx + n, cy + 1)
+        # (cx - n, cy)     (cx - 1, cy)     (cx, cy)     (cx + 1, cy)     (cx + n, cy)
+        # (cx - n, cy - 1) (cx - 1, cy - 1) (cx, cy - 1) (cx + 1, cy - 1) (cx + n, cy - 1)
+        # (cx - n, cy - n) (cx - 1, cy - n) (cx, cy - n) (cx + 1, cy - n) (cx + n, cy - n)
+        #
+        Map.new(:starting_point => coordinates).tap do |map|
+          left.upto(right) do |x|
+            down.upto(up) do |y|
+              coordinates = Coordinates[cx + x, cy + y]
+              map[coordinates] = @map[coordinates]
+            end
+          end
+        end
+      end
+
+      { :above => :up, :below => :down, :left => :left, :right => :right }.each do |synonym, direction|
+        define_method(synonym) do |coordinates|
+          area_around coordinates, direction => 1, :default => 0
+        end
+      end
+
+      def self.load(filename)
+        raise filename.prepend("Map not found - ") unless File.file? filename
+        raise filename.prepend("Map not readable - ") unless File.readable? filename
+        CustomYamlFormat.from_file filename
+      end
+
+      def save(filename)
+        CustomYamlFormat.save self, filename
+      end
+
+    end
+  end
+end

data/lib/survivor/game/map/coordinates.rb

@@ -0,0 +1,49 @@
+require 'survivor/core_ext/hash'
+
+module Survivor
+  class Game
+    class Map
+      class Coordinates
+
+        class << self
+          attr_reader :cache
+        end
+
+        attr_reader :x, :y
+
+        def self.[](*args)
+          (@cache ||= Hash.new { |cache, args| cache[args] = new(*args) })[args]
+        end
+
+        def initialize(x = 0, y = 0)
+          @x, @y = x, y
+        end
+
+        def to_a
+          [x, y]
+        end
+
+        def ==(coordinates)
+          to_a == coordinates.to_a
+        end
+
+        alias :eql? :==
+        alias :===  :==
+
+        def hash
+          to_a.hash
+        end
+
+        alias :to_ary   :to_a
+        alias :to_array :to_a
+
+        def to_s
+          "(#{x}, #{y})"
+        end
+
+        alias :inspect :to_s
+
+      end
+    end
+  end
+end

data/lib/survivor/game/map/custom_yaml_format.rb

@@ -0,0 +1,85 @@
+require 'survivor/game/map'
+require 'survivor/game/map/coordinates'
+require 'survivor/game/map/tile'
+require 'survivor/version'
+require 'yaml'
+
+module Survivor
+  class Game
+    class Map
+      class CustomYamlFormat
+
+        def self.save(map, filename)
+          File.open(filename, 'w') do |file|
+            file.write custom_structure_for(map).to_yaml
+          end
+        end
+
+        def self.from_file(filename)
+          from_yaml File.open(filename) { |file| YAML::load file }
+        end
+
+        def self.from_yaml(string)
+          survivor = string['survivor']
+          version = survivor['version']
+          unless Survivor::Version == version
+            puts "Map meant for Survivor v#{version} - current version is v#{Survivor::Version}"
+          end
+          build_map survivor['map']
+        end
+
+        private
+
+        def self.build_map(map_hash)
+          tiles = map_hash['tiles']
+          Map.new.tap do |map|
+            map_hash['data'].split("\n").tap do |lines|
+              lines.each_with_index do |line, y|
+                line.chars.each_with_index do |char, x|
+                  args = []
+                  if tile_data = tiles[char]
+                    args << tile_data.fetch('color', :white).to_sym
+                    args << tile_data.fetch('passable', true)
+                  end
+                  tile = Tile.new char, *args
+                  map[Coordinates[x, lines.count - y - 1]] = tile
+                end
+              end
+            end
+            start = map_hash['starting point']
+            x, y = start['x'].to_i, start['y'].to_i
+            map.starting_point = Coordinates[x, y]
+          end
+        end
+
+        def self.custom_structure_for(map)
+          {}.tap do |data|
+            (data['survivor'] = {}).tap do |survivor|
+              survivor['version'] = Survivor::Version.to_s
+              (survivor['map'] = {}).tap do |map_hash|
+                (map_hash['starting point'] = {}).tap do |starting_point|
+                  starting_point['x'] = map.starting_point.x
+                  starting_point['y'] = map.starting_point.y
+                end
+                (map_hash['tiles'] = {}).tap do |tiles|
+                  map.tiles.uniq.each do |tile|
+                    (tiles[tile.char] = {}).tap do |tile_data|
+                      tile_data['color'] = tile.color.to_s
+                      tile_data['passable'] = tile.passable?
+                    end
+                  end
+                end
+                (map_hash['data'] = '').tap do |data|
+                  map.each_line_string do |line|
+                    data << "#{line}\n"
+                  end
+                end
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/survivor/game/map/tile.rb

@@ -0,0 +1,44 @@
+module Survivor
+  class Game
+    class Map
+      class Tile
+
+        attr_reader :char, :color
+
+        def initialize(string, color = :white, passable = true)
+          @char = string.chars.first
+          @color, @passable = color, passable
+        end
+
+        def passable?
+          @passable
+        end
+
+        def to_a
+          [ @char, @color, @passable ]
+        end
+
+        alias :to_ary   :to_a
+        alias :to_array :to_a
+
+        def ==(tile)
+          self.to_a == tile.to_a
+        end
+
+        alias :eql? :==
+        alias :===  :==
+
+        def hash
+          self.to_a.hash
+        end
+
+        alias :to_s :char
+
+        def inspect
+          "['#{char}' #{passable?}]"
+        end
+
+      end
+    end
+  end
+end

data/lib/survivor/options.rb

@@ -0,0 +1,57 @@
+require 'survivor'
+require 'pathname'
+
+module Survivor
+  class Options
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    BOOLEAN_OPTIONS = [ :development_mode ].freeze.tap do |boolean_options|
+      boolean_options.each do |boolean_option|
+
+        define_method("#{boolean_option}_enabled?".to_sym) do
+          @options[boolean_option]
+        end
+
+        define_method("#{boolean_option}_disabled?".to_sym) do
+          not @options[boolean_option]
+        end
+
+        { :enable => true, :disable => false }.each_pair do |set, state|
+          define_method("#{set}_#{boolean_option}".to_sym) do
+            @options[boolean_option] = state
+          end
+        end
+
+      end
+    end
+
+    VALUE_OPTIONS = [ :map ].freeze.tap do |value_options|
+      value_options.each do |value_option|
+
+        define_method(value_option) do |default = nil|
+          @options.fetch(value_option, default)
+        end
+
+        alias :"#{value_option}_with_default" :"#{value_option}"
+
+        define_method("#{value_option}=".to_sym) do |value|
+          @options[value_option] = value
+        end
+
+      end
+    end
+
+    def map_location(default = 'test.map.yaml')
+      map = map_with_default(default)
+      if Pathname.new(map).relative?
+        File.join(Survivor.maps, map)
+      else
+        map
+      end
+    end
+
+  end
+end

data/lib/survivor/options/parser.rb

@@ -0,0 +1,39 @@
+require 'survivor/core_ext/kernel'
+require 'survivor/version'
+require 'optparse'
+
+module Survivor
+  class Options
+    class Parser
+
+      def initialize(options)
+        @option_parser = OptionParser.new do |parser|
+          with parser do
+            on '--dev', 'Enable development mode' do
+              options.enable_development_mode
+            end
+
+            on '--map MAP', 'Start a game on the given map.' do |map|
+              options.map = map
+            end
+
+            on '-h', '--help', 'Display this help screen and exit' do
+              puts self
+              exit
+            end
+
+            on '--version', 'Display version and exit' do
+              puts Survivor::Version
+              exit
+            end
+          end
+        end
+      end
+
+      [ :parse, :parse! ].each do |method|
+        define_method(method) { @option_parser.send method }
+      end
+
+    end
+  end
+end

data/lib/survivor/ui.rb

@@ -0,0 +1,18 @@
+require 'survivor/ui/curses'
+
+module Survivor
+  module UI
+
+    extend UI::Curses
+
+    def self.run
+      self.init
+      begin
+        yield self
+      ensure
+        self.close
+      end
+    end
+
+  end
+end

data/lib/survivor/ui/curses.rb

@@ -0,0 +1,184 @@
+require 'survivor/core_ext/kernel'
+require 'curses'
+
+module Survivor
+  module UI
+    module Curses
+
+      COLOR_CONSTANT_REGEX = /^COLOR_\w+$/i
+
+      def init
+        curses do
+          init_screen
+          if has_colors?
+            start_color
+            const_get(:COLOR_BLACK).tap do |background_color|
+              constants.grep(COLOR_CONSTANT_REGEX).map do |symbol|
+                const_get symbol
+              end.each do |color|
+                init_pair color, color, background_color
+              end
+            end
+          end
+          noecho
+          cbreak
+        end
+        create_windows
+      end
+
+      def close
+        close_windows
+        curses.close_screen
+      end
+
+      def display(game)
+        clear_all
+        draw_window_borders
+        draw_map game.map
+        draw_creature game.character
+        write_messages
+        refresh_all
+      end
+
+      def input
+        translate_key game_window.getch
+      end
+
+      def messages
+        @@messages ||= []
+      end
+
+      def message(str)
+        messages << str.to_s
+      end
+
+      private
+
+      def curses(&block)
+        ::Curses.tap { |curses| with(curses, &block) if block }
+      end
+
+      def game_border_window
+        @@game_border_window
+      end
+
+      def game_window
+        @@game_window
+      end
+
+      def messages_border_window
+        @@messages_border_window
+      end
+
+      def messages_window
+        @@messages_window
+      end
+
+      def border_windows
+        [ game_border_window, messages_border_window ]
+      end
+
+      def content_windows
+        [ game_window, messages_window ]
+      end
+
+      def windows
+        border_windows + content_windows
+      end
+
+      def inside_of(window)
+        [ window.maxy - 2, window.maxx - 2, window.begy + 1, window.begx + 1 ]
+      end
+
+      def create_windows
+        height = (curses.lines * 3 / 10).to_i
+        width = curses.cols
+        @@game_border_window = curses::Window.new(curses.lines - height, width, 0, 0)
+        @@game_window = curses::Window.new *inside_of(game_border_window)
+        @@messages_border_window = curses::Window.new(height, width, game_border_window.maxy, 0)
+        @@messages_window = curses::Window.new *inside_of(messages_border_window)
+        windows.each do |window|
+          [ [ :keypad, true ], [ :scrollok, true ] ].each do |args|
+            window.send *args
+          end
+        end
+      end
+
+      def close_windows
+        windows.each &:close
+      end
+
+      def clear_all
+        windows.each &:clear
+      end
+
+      def refresh_all
+        windows.each &:refresh
+      end
+
+      def draw_window_borders
+        border_windows.each { |window| window.box '|', '-' }
+      end
+
+      @@key_map = {
+        ::Curses::Key::UP    => :up,
+        ::Curses::Key::DOWN  => :down,
+        ::Curses::Key::LEFT  => :left,
+        ::Curses::Key::RIGHT => :right
+      }
+
+      ('a'..'z').each do |char|
+        @@key_map[char] = char.to_sym if char.ascii_only?
+      end
+
+      def translate_key(curses_key)
+        @@key_map[curses_key]
+      end
+
+      @@color_map = {}
+
+      ::Curses.constants.grep(COLOR_CONSTANT_REGEX).each do |symbol|
+        symbol.to_s.gsub(/^.*_/, '').downcase.to_sym.tap do |color|
+          @@color_map[color] = ::Curses.const_get symbol
+        end
+      end
+
+      def translate_color(color)
+        ::Curses.color_pair @@color_map[color]
+      end
+
+      def write_on(window, string, line, column, color = nil)
+        with window do
+          setpos line, column
+          attron color if color
+          addstr string.to_s
+        end
+      end
+
+      def draw_map(map)
+        map.each_with_coordinates do |tile, (column, line)|
+          write_on game_window, tile,
+                                normalized(line), column,
+                                translate_color(tile.color) if tile
+        end
+      end
+
+      def draw_creature(creature)
+        write_on game_window, creature.char,
+                              normalized(creature.y), creature.x,
+                              translate_color(creature.color) if creature
+      end
+
+      def write_messages
+        messages.last(messages_window.maxy).each do |message|
+          messages_window.addstr "#{message}\n"
+        end if messages and not messages.empty?
+      end
+
+      def normalized(line, window = game_window)
+        window.maxy - line - 1
+      end
+
+    end
+  end
+end

data/lib/survivor/version.rb

@@ -0,0 +1,20 @@
+module Survivor
+  module Version
+
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 0
+    BUILD = 'alpha2'
+
+    STRING = [ MAJOR, MINOR, PATCH, BUILD ].compact.join '.'
+
+    def self.==(string)
+      STRING == string
+    end
+
+    def self.to_s
+      STRING
+    end
+
+  end
+end

data/maps/test.map.yaml

@@ -0,0 +1,33 @@
+---
+survivor:
+  version: 0.1.0.alpha
+  map:
+    starting point:
+      x: 10
+      y: 10
+    tiles:
+      '#':
+        color: red
+        passable: no
+      ' ':
+        color: white
+        passable: yes
+
+    data: |
+      ############################################################
+      #                            #                             #
+      #                            #                             #
+      #                            #                             #
+      #                            #                             #
+      #                            #       #              ########
+      #                 ###        #      #                      #
+      #                  ##             ##                       #
+      #                  ##            ##                        #
+      #                  ####         ###                        #
+      #                     ############                         #
+      ########                     #                             #
+      #                            #                             #
+      #                            #                             #
+      #                            #                             #
+      #                            #                             #
+      ############################################################

data/survivor.gemspec

@@ -0,0 +1,22 @@
+#!/usr/bin/env gem build
+# encoding: utf-8
+
+# Add library into load path
+$:.unshift File.expand_path('../lib', __FILE__)
+
+require 'survivor/version'
+
+Gem::Specification.new do |gem|
+
+  gem.name     = 'survivor'
+  gem.version  = Survivor::Version::STRING
+  gem.summary  = 'Survival horror roguelike game'
+  gem.author   = 'Matheus Afonso Martins Moreira'
+  gem.homepage = 'https://github.com/matheusmoreira/survivor'
+
+  gem.files         = `git ls-files`.split "\n"
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map &File.method(:basename)
+
+  gem.add_development_dependency 'bundler'
+
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: survivor
+version: !ruby/object:Gem::Version
+  version: 0.1.0.alpha2
+  prerelease: 6
+platform: ruby
+authors:
+- Matheus Afonso Martins Moreira
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &12611440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12611440
+description: 
+email: 
+executables:
+- survivor
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- bin/survivor
+- lib/survivor.rb
+- lib/survivor/core_ext/hash.rb
+- lib/survivor/core_ext/kernel.rb
+- lib/survivor/game.rb
+- lib/survivor/game/creature.rb
+- lib/survivor/game/creature/character.rb
+- lib/survivor/game/logic.rb
+- lib/survivor/game/logic/movement.rb
+- lib/survivor/game/map.rb
+- lib/survivor/game/map/coordinates.rb
+- lib/survivor/game/map/custom_yaml_format.rb
+- lib/survivor/game/map/tile.rb
+- lib/survivor/options.rb
+- lib/survivor/options/parser.rb
+- lib/survivor/ui.rb
+- lib/survivor/ui/curses.rb
+- lib/survivor/version.rb
+- maps/test.map.yaml
+- survivor.gemspec
+homepage: https://github.com/matheusmoreira/survivor
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Survival horror roguelike game
+test_files: []