rubywarrior-i18n 0.0.2

data/lib/ruby_warrior/abilities/explode.rb

@@ -0,0 +1,28 @@
+module RubyWarrior
+  module Abilities
+    class Explode < Base
+      attr_accessor :time
+      
+      def description
+        "#{R18n.t.explode.description}"
+      end
+      
+      def perform
+        if @unit.position
+          @unit.say "#{R18n.t.explode.collapsing_the_ceiling}"
+          @unit.position.floor.units.map do |unit|
+            unit.take_damage(100)
+          end
+        end
+      end
+      
+      def pass_turn
+        if @time && @unit.position
+          @unit.say "#{R18n.t.explode.is_ticking}"
+          @time -= 1
+          perform if @time.zero?
+        end
+      end
+    end
+  end
+end

data/lib/ruby_warrior/abilities/feel.rb

@@ -0,0 +1,14 @@
+module RubyWarrior
+  module Abilities
+    class Feel < Base
+      def description
+        "#{R18n.t.feel.description}"
+      end
+      
+      def perform(direction = :forward)
+        verify_direction(direction)
+        space(direction)
+      end
+    end
+  end
+end

data/lib/ruby_warrior/abilities/form.rb

@@ -0,0 +1,25 @@
+module RubyWarrior
+  module Abilities
+    class Form < Base
+      def description
+        "#{R18n.t.form.description}"
+      end
+      
+      def perform(direction = :forward, &block)
+        verify_direction(direction)
+        if space(direction).empty?
+          x, y = @unit.position.translate_offset(*offset(direction))
+          health = (@unit.health/2.0).floor
+          golem = @unit.base_golem
+          golem.max_health = health
+          golem.turn = block
+          @unit.health -= health
+          @unit.position.floor.add(golem, x, y, @unit.position.direction)
+          @unit.say "#{R18n.t.form.golem_gives_health(R18n.t.direction[direction], health)}"
+        else
+          @unit.say "#{R18n.t.form.fails}"
+        end
+      end
+    end
+  end
+end

data/lib/ruby_warrior/abilities/health.rb

@@ -0,0 +1,13 @@
+module RubyWarrior
+  module Abilities
+    class Health < Base
+      def description
+        "#{R18n.t.health.description}"
+      end
+      
+      def perform
+        @unit.health
+      end
+    end
+  end
+end

data/lib/ruby_warrior/abilities/listen.rb

@@ -0,0 +1,15 @@
+module RubyWarrior
+  module Abilities
+    class Listen < Base
+      def description
+        "#{R18n.t.listen.description}"
+      end
+      
+      def perform
+        @unit.position.floor.units.map do |unit|
+          unit.position.space unless unit == @unit
+        end.compact
+      end
+    end
+  end
+end

data/lib/ruby_warrior/abilities/look.rb

@@ -0,0 +1,16 @@
+module RubyWarrior
+  module Abilities
+    class Look < Base
+      def description
+        "#{R18n.t.look.description}"
+      end
+      
+      def perform(direction = :forward)
+        verify_direction(direction)
+        [1, 2, 3].map do |amount|
+          space(direction, amount)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_warrior/abilities/pivot.rb

@@ -0,0 +1,17 @@
+module RubyWarrior
+  module Abilities
+    class Pivot < Base
+      ROTATION_DIRECTIONS = [:forward, :right, :backward, :left]
+      
+      def description
+        "#{R18n.t.rotate.description}"
+      end
+      
+      def perform(direction = :backward)
+        verify_direction(direction)
+        @unit.position.rotate(ROTATION_DIRECTIONS.index(direction))
+        @unit.say "#{R18n.t.rotate.pivots} #{R18n.t.direction[direction]}"
+      end
+    end
+  end
+end

data/lib/ruby_warrior/abilities/rescue.rb

@@ -0,0 +1,24 @@
+module RubyWarrior
+  module Abilities
+    class Rescue < Base
+      def description
+        "#{R18n.t.rescue.description}"
+      end
+      
+      def perform(direction = :forward)
+        verify_direction(direction)
+        if space(direction).captive?
+          recipient = unit(direction)
+          @unit.say R18n.t.rescue.unbinds_and_rescues(R18n.t.direction[direction], "#{recipient}")
+          recipient.unbind
+          if recipient.kind_of? Units::Captive
+            recipient.position = nil
+            @unit.earn_points(20)
+          end
+        else
+          @unit.say "#{R18n.t.rescue.unbinds_and_rescues_nothing(direction)}"
+        end
+      end
+    end
+  end
+end

data/lib/ruby_warrior/abilities/rest.rb

@@ -0,0 +1,20 @@
+module RubyWarrior
+  module Abilities
+    class Rest < Base
+      def description
+        "#{R18n.t.rest.description}"
+      end
+      
+      def perform
+        if @unit.health < @unit.max_health
+          amount = (@unit.max_health*0.1).round
+          amount = @unit.max_health-@unit.health if (@unit.health + amount) > @unit.max_health
+          @unit.health += amount
+          @unit.say "#{R18n.t.rest.receives_health(amount, @unit.health)}"
+        else
+          @unit.say "#{R18n.t.rest.fit_fiddle}"
+        end
+      end
+    end
+  end
+end

data/lib/ruby_warrior/abilities/shoot.rb

@@ -0,0 +1,24 @@
+module RubyWarrior
+  module Abilities
+    class Shoot < Base
+      def description
+        "#{R18n.t.shoot.description}"
+      end
+      
+      def perform(direction = :forward)
+        verify_direction(direction)
+        receiver = multi_unit(direction, 1..3).compact.first
+        if receiver
+          @unit.say "#{R18n.t.shoot.and_hits(R18n.t.direction[direction], receiver)}"
+          damage(receiver, @unit.shoot_power)
+        else
+          @unit.say "#{R18n.t.shoot.and_hits_nothing}"
+        end
+      end
+      
+      def multi_unit(direction, range)
+        range.map { |n| unit(direction, n) }
+      end
+    end
+  end
+end

data/lib/ruby_warrior/abilities/walk.rb

@@ -0,0 +1,21 @@
+module RubyWarrior
+  module Abilities
+    class Walk < Base
+      def description
+        "#{R18n.t.direction.move_forward_default}"
+      end
+      
+      def perform(direction = :forward)
+        verify_direction(direction)
+        if @unit.position
+          @unit.say "#{R18n.t.walk.s} #{R18n.t.direction[direction]}"
+          if space(direction).empty?
+            @unit.position.move(*offset(direction))
+          else
+            @unit.say "#{R18n.t.direction.bumps_into} #{space(direction)}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_warrior/config.rb

@@ -0,0 +1,22 @@
+module RubyWarrior
+  class Config
+    class << self
+      attr_accessor :delay, :in_stream, :out_stream, :practice_level
+      attr_writer :path_prefix, :skip_input
+      
+      def path_prefix
+        @path_prefix || "."
+      end
+      
+      def skip_input?
+        @skip_input
+      end
+      
+      def reset
+        [:@path_prefix, :@skip_input, :@delay, :@in_stream, :@out_stream, :@practice_level].each do |i|
+          remove_instance_variable(i) if instance_variable_defined?(i)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_warrior/core_additions.rb

@@ -0,0 +1,29 @@
+class String
+  def camelize
+    gsub(/(?:^|_)(.)/) { $1.upcase }
+  end
+  
+  def constantize
+    unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ self
+      raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
+    end
+    
+    Object.module_eval("::#{$1}", __FILE__, __LINE__)
+  end
+  
+  def underscore
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
+  end
+  
+  def humanize
+    gsub(/_/, " ").capitalize
+  end
+
+  def titleize
+    underscore.humanize.gsub(/\b('?[a-z])/) { $1.capitalize }
+  end
+  
+  def hard_wrap(width = 80)
+    gsub(/(.{1,#{width}})(\s+|$)/, "\\1\n").strip
+  end
+end

data/lib/ruby_warrior/floor.rb

@@ -0,0 +1,71 @@
+module RubyWarrior
+  class Floor
+    attr_accessor :width, :height, :grid
+    attr_reader :stairs_location
+    
+    def initialize
+      @width = 0
+      @height = 0
+      @units = []
+      @stairs_location = [-1, -1]
+    end
+    
+    def add(unit, x, y, direction = nil)
+      @units << unit
+      unit.position = Position.new(self, x, y, direction)
+    end
+    
+    def place_stairs(x, y)
+      @stairs_location = [x, y]
+    end
+    
+    def stairs_space
+      space(*@stairs_location)
+    end
+    
+    def units
+      @units.reject { |u| u.position.nil? }
+    end
+    
+    def other_units
+      units.reject { |u| u.kind_of? Units::Warrior }
+    end
+    
+    def get(x, y)
+      units.detect do |unit|
+        unit.position.at?(x, y)
+      end
+    end
+    
+    def space(x, y)
+      Space.new(self, x, y)
+    end
+    
+    def out_of_bounds?(x, y)
+      x < 0 || y < 0 || x > @width-1 || y > @height-1
+    end
+    
+    def character
+      rows = []
+      rows << " " + ("-" * @width)
+      @height.times do |y|
+        row = "|"
+        @width.times do |x|
+          row << space(x, y).character
+        end
+        row << "|"
+        rows << row
+      end
+      rows << " " + ("-" * @width)
+      rows.join("\n") + "\n"
+    end
+    
+    def unique_units
+      unique_units = []
+      units.each do |unit|
+        unique_units << unit unless unique_units.map { |u| u.class }.include?(unit.class)
+      end
+      unique_units
+    end
+  end
+end

data/lib/ruby_warrior/game.rb

@@ -0,0 +1,209 @@
+module RubyWarrior
+  
+  class Game
+    
+    def start
+      UI.puts R18n.t.welcome
+      
+      if File.exist?(Config.path_prefix + '/.profile')
+        @profile = Profile.load(Config.path_prefix + '/.profile')
+      else
+        if File.exist?(Config.path_prefix + "/ruby-warrior")
+          FileUtils.mv(Config.path_prefix + '/ruby-warrior', Config.path_prefix + '/rubywarrior')
+        end
+        make_game_directory unless File.exist?(Config.path_prefix + '/rubywarrior')
+      end
+      
+      if profile.epic?
+        if profile.level_after_epic?
+          go_back_to_normal_mode
+        else
+          play_epic_mode
+        end
+      else
+        play_normal_mode
+      end
+    end
+    
+    def make_game_directory
+      if UI.ask(R18n.t.directory.not_found)
+        Dir.mkdir(Config.path_prefix + '/rubywarrior')
+      else
+        UI.puts R18n.t.directory.cannot_continue
+        exit
+      end
+    end
+    
+    def play_epic_mode
+      Config.delay /= 2 if Config.delay # speed up UI since we're going to be doing a lot here
+      profile.current_epic_score = 0
+      profile.current_epic_grades = {}
+      if Config.practice_level
+        @current_level = @next_level = nil
+        profile.level_number = Config.practice_level
+        play_current_level
+      else
+        playing = true
+        while playing
+          @current_level = @next_level = nil
+          profile.level_number += 1
+          playing = play_current_level
+        end
+        profile.save # saves the score for epic mode
+      end
+    end
+    
+    def play_normal_mode
+      if Config.practice_level
+        UI.puts R18n.t.practice_level.unable_not_in_epic_mode
+      else
+        if current_level.number.zero?
+          prepare_next_level
+          UI.puts R18n.t.first_level_generated(profile.directory_name)
+        else
+          play_current_level
+        end
+      end
+    end
+    
+    def play_current_level
+      continue = true
+      current_level.load_player
+      UI.puts R18n.t.level.starting(current_level.number)
+      current_level.play
+      if current_level.passed?
+        if next_level.exists?
+          UI.puts R18n.t.stairs.found
+        else
+          UI.puts R18n.t.end_of_game
+          continue = false
+        end
+        current_level.tally_points
+        if profile.epic?
+          UI.puts final_report if final_report && !continue
+        else
+          request_next_level
+        end
+      else
+        continue = false
+        UI.puts R18n.t.level.failed(current_level.number)
+        if !Config.skip_input? && current_level.clue && UI.ask(R18n.t.level.clues)
+          UI.puts current_level.clue.hard_wrap
+        end
+      end
+      continue
+    end
+    
+    def request_next_level
+      if !Config.skip_input? && (next_level.exists? ? UI.ask(R18n.t.level.continue_next) : UI.ask(R18n.t.level.continue_epic_mode))
+        if next_level.exists?
+          prepare_next_level
+          UI.puts R18n.t.readme.see_updated(profile.directory_name)
+        else
+          prepare_epic_mode
+          UI.puts R18n.t.to_play_epic_mode
+        end
+      else
+        UI.puts R18n.t.level.staying_on_current
+      end
+    end
+    
+    def prepare_next_level
+      next_level.generate_player_files
+      profile.level_number += 1
+      profile.save # this saves score and new abilities too
+    end
+    
+    def prepare_epic_mode
+      profile.enable_epic_mode
+      profile.level_number = 0
+      profile.save # this saves score too
+    end
+    
+    def go_back_to_normal_mode
+      profile.enable_normal_mode
+      prepare_next_level
+      UI.puts R18n.t.mode.back_to_normal
+      UI.puts R18n.t.readme.see_updated(profile.directory_name)
+    end
+    
+    
+    # profiles
+    
+    def profiles
+      profile_paths.map { |profile| Profile.load(profile) }
+    end
+    
+    def profile_paths
+      Dir[Config.path_prefix + '/rubywarrior/**/.profile']
+    end
+    
+    def profile
+      @profile ||= choose_profile
+    end
+    
+    def new_profile
+      profile = Profile.new
+      profile.tower_path = UI.choose(R18n.t.game.tower, towers).path
+      profile.warrior_name = UI.request(R18n.t.warrior.enter_name)
+      profile
+    end
+    
+    
+    # towers
+    
+    def towers
+      tower_paths.map { |path| Tower.new(path) }
+    end
+    
+    def tower_paths
+      Dir[File.expand_path('../../../towers/*', __FILE__)]
+    end
+    
+    
+    # levels
+    
+    def current_level
+      @current_level ||= profile.current_level
+    end
+    
+    def next_level
+      @next_level ||= profile.next_level
+    end
+    
+    def final_report
+      if profile.calculate_average_grade && !Config.practice_level
+        report = ""
+        report << R18n.t.game.average_grade_for_tower(Level.grade_letter(profile.calculate_average_grade))
+        profile.current_epic_grades.keys.sort.each do |level|
+          report << "  #{R18n.t.level.number(level)} #{Level.grade_letter(profile.current_epic_grades[level])}\n"
+        end
+        report << R18n.t.level.to_practice
+        report
+      end
+    end
+    
+    private
+    
+    def choose_profile # REFACTORME
+      profile = UI.choose(R18n.t.profile.profile, profiles + [[:new, R18n.t.profile.new]])
+      if profile == :new
+        profile = new_profile
+        if profiles.any? { |p| p.player_path == profile.player_path }
+          if UI.ask(R18n.t.profile.replace_existing_for_tower)
+            UI.puts R18n.t.profile.replace_existing
+            profile
+          else
+            UI.puts R18n.t.profile.not_replacing
+            exit
+          end
+        else
+          profile
+        end
+      else
+        profile
+      end
+    end
+    
+  end
+end