extra stuff??

Gemfile

@@ -2,4 +2,4 @@ source 'http://rubygems.org'
 
 gem 'rspec'
 gem 'ruby-debug19'
-gem 'rawline'
+gem 'rawline'

lib/game/engine.rb

@@ -21,10 +21,22 @@ def map
     end
 
     def take_turn
+      activate_objects
+
       active_objects = Game::Object.engine_objects(map.name)[Game::Object::ACTIVE]
       active_objects.each {|obj| obj.active_turn }
     end
 
+    def activate_objects
+      close_tiles = Game::Player.instance.tile.elements_within(2)
+      tile = Game::Player.instance.tile
+      close_tiles.each do |tile|
+        tile.objects.each do |obj|
+          obj.activate if obj.respond_to?(:activate)
+        end
+      end
+    end
+
     def ended?
       !!@ended
     end

lib/game/input.rb

@@ -25,7 +25,7 @@ def bind_keys
 
       bind_key(:' ') { @player.take_action }
 
-      bind_key(:'1') { skip_to('level5') }
+      bind_key(:'1') { skip_to('level9') }
       bind_key(:'2') { skip_to('level6') }
       bind_key(:'3') { skip_to('level7_a') }
       bind_key(:'4') { skip_to('level8') }

lib/game/map.rb

@@ -1,9 +1,11 @@
 class Game
   class Map
-    NORTH = :north
-    SOUTH = :south
-    EAST = :east
-    WEST = :west
+    DIRECTIONS = [
+      NORTH = :north,
+      SOUTH = :south,
+      EAST = :east,
+      WEST = :west
+    ]
 
     def self.load_map(filename)
       new(filename)

lib/game/modules.rb

@@ -1,4 +1,5 @@
 require 'lib/game/modules/object_management'
 require 'lib/game/modules/try_helper'
+require 'lib/game/modules/array_sum'
 require 'lib/game/modules/instance_setter'
 require 'lib/game/modules/impassible'

lib/game/modules/array_sum.rb

@@ -0,0 +1,13 @@
+class Game
+  module Modules
+    module ArraySum
+      def sum(&block)
+        self.inject(0) do |res, value|
+          res + block.call(value)
+        end
+      end
+    end
+  end
+end
+
+Array.send :include, Game::Modules::ArraySum

lib/game/modules/impassible.rb

@@ -4,6 +4,8 @@ module Impassible
       def passible?(player_objects=[])
         false
       end
+
+      alias :activatable? :passible?
     end
   end
 end

lib/game/object/status.rb

@@ -12,12 +12,14 @@ def expire
       end
 
       def activate
+        return if @status == Game::Object::ACTIVE
         Game::Object.remove(Game::Engine.instance.map.name, status, self)
         @status = Game::Object::ACTIVE
         Game::Object.add(Game::Engine.instance.map.name, status, self)
       end
 
       def deactivate
+        return if @status == Game::Object::IDLE
         Game::Object.remove(Game::Engine.instance.map.name, status, self)
         @status = Game::Object::IDLE
         Game::Object.add(Game::Engine.instance.map.name, status, self)

lib/game/player.rb

@@ -1,17 +1,15 @@
 require 'lib/game/player/actions'
+require 'lib/game/player/equipment'
 require 'lib/game/player/life_force'
 require 'lib/game/player/movements'
 
 class Game
   class Player
     include Game::Modules::ObjectManagement
     include Game::Player::Actions
+    include Game::Player::Equipment
     include Game::Player::Movements
     include Game::Player::LifeForce
     include Game::Modules::InstanceSetter
-
-    attr_accessor :tile
-    attr_reader :hp
-
   end
 end

lib/game/player/equipment.rb

@@ -0,0 +1,42 @@
+class Game
+  class Player
+    module Equipment
+      def self.included(base)
+        base.send :attr_reader
+      end
+
+      def initialize(*args)
+        super
+        @space = Hash.new(2)
+      end
+
+      def equip(item)
+        if !equiped?(item) && space_for(item)
+          equipment(item.on) << item
+        end
+      end
+
+      def unequip(item)
+        if equiped?(item)
+          equipment(item.on).delete(item)
+        end
+      end
+
+      def equiped?(item)
+        equipment(item.on).include?(item)
+      end
+
+      def space_for(item)
+        items_size = equipment(item.on).sum(&:size)
+        (@space[item.on] - items_size) >= item.size
+      end
+
+      def equipment(on=nil)
+        @equipment ||= {}
+
+        return @equipment if on.nil?
+        @equipment[on] ||= []
+      end
+    end
+  end
+end

lib/game/player/movements.rb

@@ -3,6 +3,7 @@ class Player
     module Movements
       def self.included(base)
         base.send :attr_reader, :direction
+        base.send :attr_accessor, :tile
       end
 
       def initialize(*args)

lib/game/tile/movement.rb

@@ -11,14 +11,61 @@ def at(direction)
       end
 
       def direction_to(tile)
-        diff_x = x - tile.x
-        diff_y = y - tile.y
+        directions_to(tile).first
+      end
 
-        if diff_x.abs > diff_y.abs
-          diff_x > 0 ? Game::Map::NORTH : Game::Map::SOUTH
-        else
-          diff_y > 0 ? Game::Map::WEST : Game::Map::EAST
+      def elements_within(distance)
+        Path.new(self).elements(distance)
+      end
+
+      def directions_to(tile)
+        Path.new(self, tile).directions
+      end
+
+      class Path
+        def initialize(start, goal=nil)
+          @goal = goal
+          @paths = {start => {:distance => 0, :path => []}}
+        end
+
+        def directions
+          until found_goal do
+            return [] unless try_paths { |tile| tile.passible? }
+          end
+          @paths[@goal][:path]
         end
+
+        def elements(distance)
+          (1..distance).each do
+            break unless try_paths { |tile| tile.activatable? }
+          end
+          @paths.keys
+        end
+
+        def try_paths(&blk)
+          @paths.to_a.map do |location, details|
+            Game::Map::DIRECTIONS.map do |direction|
+              location.try_path(@paths, direction, details, &blk)
+            end.any?
+          end.any?
+        end
+
+        private
+        def found_goal
+          !!@paths[@goal]
+        end
+      end
+
+      def try_path(paths, direction, details)
+        tile = at(direction)
+        return false unless yield(tile)
+        !!tile.try_tile(paths, direction, details)
+      end
+
+      def try_tile(paths, direction, details)
+        distance = (details[:distance] + 1)
+        return false if paths[self] && paths[self][:distance] <= distance
+        paths[self] = {:distance => distance, :path => (details[:path].dup + [direction])}
       end
 
       def in_range?(tile, max=10)

lib/game/tile/passible.rb

@@ -4,6 +4,10 @@ module Passible
       def passible?(player_objects=[])
         objects.all?{|obj| !obj.respond_to?(:passible?) || obj.passible? }
       end
+
+      def activatable?
+        true
+      end
     end
   end
 end

lib/game/tile/wall.rb

@@ -5,14 +5,16 @@ class Wall
       include Game::Tile::Base
       include Game::Tile::Movement
 
-      def passible?(player_objects)
+      def passible?(player_objects=[])
         return false unless has_object?(Game::Object::Passage)
         passage = get_object(Game::Object::Passage)
         return true if passage.passible?
 
         key = player_objects.detect{|obj| obj.id == passage.id}
         passage.open if key.try(:use)
       end
+
+      alias :activatable? :passible?
     end
   end
 end

lib/render/console/draw_map.rb

@@ -92,7 +92,7 @@ def draw_enemies(map)
         if active.size > 0
           append "Active Enemies: ", active.size
           active.each do |enemy|
-            append space(classname_for(enemy)), enemy.hp
+            draw_inventry_object(Game::Player.instance, enemy)
           end
         end
       end

lib/render/console/draw_tile.rb

@@ -56,7 +56,7 @@ def draw_empty
 
         def draw_wall
           if tile.has_object?(Game::Object::Passage)
-            return 'D D' if tile.passible?([])
+            return 'D D' if tile.passible?
             return 'DDD'
           end
 

lib/render/console/player_inventry.rb

@@ -10,20 +10,21 @@ def draw_player_inventry(player)
           append "(EMPTY)"
         else
           player.objects.each do |object|
-            draw_inventry_object(object)
+            @selected ||= object
+            draw_inventry_object(player, object)
           end
         end
         append
       end
 
-      def draw_inventry_object(obj)
-        @selected ||= obj
+      def draw_inventry_object(player, obj)
         options = @selected == obj ? {:color => :invert} : []
         strings = [space(classname_for(obj))]
         details = []
         details << "Att: #{obj.attack}" if obj.respond_to?(:attack)
         details << "HP:  #{obj.hp}" if obj.respond_to?(:hp)
-        strings << '(' << details << ')' unless details.empty?
+        details << "Equiped" if obj.respond_to?(:on) && player.equiped?(obj)
+        strings << '(' << details.join(', ') << ')' unless details.empty?
         append *strings, options
       end