rubywarrior 0.1.0

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,25 @@
+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
+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,193 @@
+module RubyWarrior
+  class Game
+    
+    def start
+      UI.puts "Welcome to Ruby Warrior"
+      
+      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
+      
+      profile.epic? ? play_epic_mode : play_normal_mode
+    end
+    
+    def make_game_directory
+      if UI.ask("No rubywarrior directory found, would you like to create one?")
+        Dir.mkdir(Config.path_prefix + '/rubywarrior')
+      else
+        UI.puts "Unable to continue without directory."
+        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 "Unable to practice level while not in epic mode, remove -l option."
+      else
+        if current_level.number.zero?
+          prepare_next_level
+          UI.puts "First level has been generated. See the rubywarrior/#{profile.directory_name}/README for instructions."
+        else
+          play_current_level
+        end
+      end
+    end
+    
+    def play_current_level
+      continue = true
+      current_level.load_player
+      UI.puts "Starting Level #{current_level.number}"
+      current_level.play
+      if current_level.passed?
+        if next_level.exists?
+          UI.puts "Success! You have found the stairs."
+        else
+          UI.puts "CONGRATULATIONS! You have climbed to the top of the tower and rescued the fair maiden Ruby."
+          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 "Sorry, you failed level #{current_level.number}. Change your script and try again."
+        if !Config.skip_input? && current_level.clue && UI.ask("Would you like to read the additional clues for this level?")
+          UI.puts current_level.clue
+        end
+      end
+      continue
+    end
+    
+    def request_next_level
+      if !Config.skip_input? && (next_level.exists? ? UI.ask("Would you like to continue on to the next level?") : UI.ask("Would you like to continue on to epic mode?"))
+        if next_level.exists?
+          prepare_next_level
+          UI.puts "See the updated README in the rubywarrior/#{profile.directory_name} directory."
+        else
+          prepare_epic_mode
+          UI.puts "Run rubywarrior again to play epic mode."
+        end
+      else
+        UI.puts "Staying on current level. Try to earn more points next time."
+      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
+    
+    
+    # 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('tower', towers).path
+      profile.warrior_name = UI.request('Enter a name for your warrior: ')
+      profile
+    end
+    
+    
+    # towers
+    
+    def towers
+      tower_paths.map { |path| Tower.new(path) }
+    end
+    
+    def tower_paths
+      Dir[File.expand_path(File.dirname(__FILE__) + '/../../towers/*')]
+    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 << "Your average grade for this tower is: #{Level.grade_letter(profile.calculate_average_grade)}\n\n"
+        profile.current_epic_grades.keys.sort.each do |level|
+          report << "  Level #{level}: #{Level.grade_letter(profile.current_epic_grades[level])}\n"
+        end
+        report << "\nTo practice a level, use the -l option:\n\n  rubywarrior -l 3"
+        report
+      end
+    end
+    
+    private
+    
+    def choose_profile # REFACTORME
+      profile = UI.choose('profile', profiles + [[:new, 'New Profile']])
+      if profile == :new
+        profile = new_profile
+        if profiles.any? { |p| p.player_path == profile.player_path }
+          if UI.ask("Are you sure you want to replace your existing profile for this tower?")
+            UI.puts "Replacing existing profile."
+            profile
+          else
+            UI.puts "Not replacing profile."
+            exit
+          end
+        else
+          profile
+        end
+      else
+        profile
+      end
+    end
+    
+  end
+end

data/lib/ruby_warrior/level.rb

@@ -0,0 +1,119 @@
+module RubyWarrior
+  class Level
+    attr_reader :profile, :number
+    attr_accessor :description, :tip, :clue, :warrior, :floor, :time_bonus, :ace_score
+    
+    def self.grade_letter(percent)
+      if    percent >= 1.0 then "S"
+      elsif percent >= 0.9 then "A"
+      elsif percent >= 0.8 then "B"
+      elsif percent >= 0.7 then "C"
+      elsif percent >= 0.6 then "D"
+      else                      "F"
+      end
+    end
+    
+    def initialize(profile, number)
+      @profile = profile
+      @number = number
+      @time_bonus = 0
+    end
+    
+    def player_path
+      @profile.player_path
+    end
+    
+    def load_path
+      @profile.tower_path + "/level_" + @number.to_s.rjust(3, '0') + ".rb"
+    end
+    
+    def load_level
+      LevelLoader.new(self).instance_eval(File.read(load_path))
+    end
+    
+    def load_player
+      $: << player_path
+      load 'player.rb'
+    end
+    
+    def generate_player_files
+      load_level
+      PlayerGenerator.new(self).generate
+    end
+    
+    def play(turns = 1000)
+      load_level
+      turns.times do |n|
+        return if passed? || failed?
+        UI.puts "- turn #{n+1} -"
+        UI.print @floor.character
+        @floor.units.each { |unit| unit.prepare_turn }
+        @floor.units.each { |unit| unit.perform_turn }
+        yield if block_given?
+        @time_bonus -= 1 if @time_bonus > 0
+      end
+    end
+    
+    def tally_points
+      score = 0
+      
+      UI.puts "Level Score: #{warrior.score}"
+      score += warrior.score
+      
+      UI.puts "Time Bonus: #{time_bonus}"
+      score += @time_bonus
+      
+      if floor.other_units.empty?
+        UI.puts "Clear Bonus: #{clear_bonus}"
+        score += clear_bonus
+      end
+      
+      if @profile.epic?
+        UI.puts "Level Grade: #{grade_for(score)}" if grade_for(score)
+        UI.puts "Total Score: " + score_calculation(@profile.current_epic_score, score)
+        @profile.current_epic_grades[@number] = (score / ace_score.to_f) if ace_score
+        @profile.current_epic_score += score
+      else
+        UI.puts "Total Score: " + score_calculation(@profile.score, score)
+        @profile.score += score
+        @profile.abilities = warrior.abilities.keys
+      end
+    end
+    
+    def grade_for(score)
+      if ace_score
+        self.class.grade_letter(score / ace_score.to_f)
+      end
+    end
+    
+    def clear_bonus
+      ((warrior.score + time_bonus)*0.2).round
+    end
+    
+    def score_calculation(current_score, addition)
+      if current_score.zero?
+        addition.to_s
+      else
+        "#{current_score} + #{addition} = #{current_score + addition}"
+      end
+    end
+    
+    def passed?
+      @floor.stairs_space.warrior?
+    end
+    
+    def failed?
+      !@floor.units.include?(warrior)
+    end
+    
+    def exists?
+      File.exist? load_path
+    end
+    
+    def setup_warrior(warrior)
+      @warrior = warrior
+      @warrior.add_abilities(*profile.abilities)
+      @warrior.name = profile.warrior_name
+    end
+  end
+end

data/lib/ruby_warrior/level_loader.rb

@@ -0,0 +1,56 @@
+module RubyWarrior
+  class LevelLoader
+    def initialize(level)
+      @floor = RubyWarrior::Floor.new
+      @level = level
+      @level.floor = @floor
+    end
+    
+    def description(desc)
+      @level.description = desc
+    end
+    
+    def tip(tip)
+      @level.tip = tip
+    end
+    
+    def clue(clue)
+      @level.clue = clue
+    end
+    
+    def time_bonus(bonus)
+      @level.time_bonus = bonus
+    end
+    
+    def ace_score(score)
+      @level.ace_score = score
+    end
+    
+    def size(width, height)
+      @floor.width = width
+      @floor.height = height
+    end
+    
+    def stairs(x, y)
+      @floor.place_stairs(x, y)
+    end
+    
+    def unit(unit, x, y, facing = :north)
+      unit = unit_to_constant(unit).new unless unit.kind_of? Units::Base
+      @floor.add(unit, x, y, facing)
+      yield unit if block_given?
+      unit
+    end
+    
+    def warrior(*args, &block)
+      @level.setup_warrior unit(Units::Warrior.new, *args, &block)
+    end
+    
+    private
+    
+    def unit_to_constant(name)
+      camel = name.to_s.split('_').map { |s| s.capitalize }.join
+      eval("Units::#{camel}")
+    end
+  end
+end