karnowski-ruby-warrior 0.0.1

data/lib/ruby_warrior/game.rb

@@ -0,0 +1,160 @@
+module RubyWarrior
+  class Game
+    
+    def start
+      UI.puts "Welcome to Ruby Warrior"
+      
+      if File.exists?(Config.path_prefix + '/.profile')
+        @profile = Profile.load(Config.path_prefix + '/.profile')
+      else
+        make_game_directory unless File.exists?(Config.path_prefix + '/ruby-warrior')
+      end
+      
+      if profile.epic?
+        UI.delay /= 2 if UI.delay # speed up UI since we're going to be doing a lot here
+        profile.current_epic_score = 0
+        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
+      else
+        if current_level.number.zero?
+          prepare_next_level
+          UI.puts "First level has been generated. See the ruby-warrior directory for instructions."
+        else
+          play_current_level
+        end
+      end
+    end
+    
+    def make_game_directory
+      if UI.ask("No ruby-warrior directory found, would you like to create one?")
+        Dir.mkdir(Config.path_prefix + '/ruby-warrior')
+      else
+        UI.puts "Unable to continue without directory."
+        exit
+      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 rescue the fair maiden Ruby."
+          continue = false
+        end
+        current_level.tally_points
+        request_next_level unless profile.epic?
+      else
+        continue = false
+        UI.puts "Sorry, you failed the level. Change your script and try again."
+        if 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 (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 ruby-warrior directory for the next level README."
+        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 + '/ruby-warrior/**/.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
+    
+    
+    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,93 @@
+module RubyWarrior
+  class Level
+    attr_reader :profile, :number
+    attr_accessor :description, :tip, :clue, :warrior, :floor, :time_bonus
+    
+    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.to_map
+        @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?
+        @profile.current_epic_score += score
+        UI.puts "Total Score: #{@profile.current_epic_score}"
+      else
+        @profile.score += score
+        @profile.abilities = warrior.abilities.keys
+        UI.puts "Total Score: #{@profile.score}"
+      end
+    end
+    
+    def clear_bonus
+      ((warrior.score + time_bonus)*0.2).round
+    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,52 @@
+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 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

data/lib/ruby_warrior/player_generator.rb

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'fileutils'
+require 'erb'
+
+module RubyWarrior
+  class PlayerGenerator
+    def initialize(level)
+      @level = level
+    end
+    
+    def level
+      @level
+    end
+    
+    def previous_level
+      @previous_level ||= Level.new(level.profile, level.number-1)
+    end
+    
+    # TODO refactor and test this method
+    def generate
+      if level.number == 1
+        FileUtils.mkdir_p(level.player_path)
+        FileUtils.cp(templates_path + '/player.rb', level.player_path)
+      end
+      
+      File.open(level.player_path + '/README', 'w') do |f|
+        f.write read_template(templates_path + '/README.erb')
+      end
+    end
+    
+    def templates_path
+      File.expand_path(File.dirname(__FILE__) + "/../../templates")
+    end
+    
+    private
+    
+    def read_template(path)
+      ERB.new(File.read(path), nil, '-').result(binding)
+    end
+  end
+end

data/lib/ruby_warrior/position.rb

@@ -0,0 +1,80 @@
+module RubyWarrior
+  class Position
+    attr_reader :floor
+    DIRECTIONS = [:north, :east, :south, :west]
+    RELATIVE_DIRECTIONS = [:forward, :right, :backward, :left]
+    
+    def initialize(floor, x, y, direction = nil)
+      @floor = floor
+      @x = x
+      @y = y
+      @direction_index = DIRECTIONS.index(direction || :north)
+    end
+    
+    def at?(x, y)
+      @x == x && @y == y
+    end
+    
+    def direction
+      DIRECTIONS[@direction_index]
+    end
+    
+    def rotate(amount)
+      @direction_index += amount
+      @direction_index -= 4 while @direction_index > 3
+      @direction_index += 4 while @direction_index < 0
+    end
+    
+    def relative_space(forward, right = 0)
+      @floor.space(*translate_offset(forward, right))
+    end
+    
+    def space
+      @floor.space(@x, @y)
+    end
+    
+    def move(forward, right = 0)
+      @x, @y = *translate_offset(forward, right)
+    end
+    
+    def distance_from_stairs
+      stairs_x, stairs_y = *@floor.stairs_location
+      (@x - stairs_x).abs + (@y - stairs_y).abs
+    end
+    
+    def relative_direction_of_stairs
+      relative_direction_of(@floor.stairs_space)
+    end
+    
+    def relative_direction_of(space)
+      relative_direction(direction_of(space))
+    end
+    
+    def direction_of(space)
+      space_x, space_y = *space.location
+      if (@x - space_x).abs > (@y - space_y).abs
+        space_x > @x ? :east : :west
+      else
+        space_y > @y ? :south : :north
+      end
+    end
+    
+    def relative_direction(direction)
+      offset = DIRECTIONS.index(direction) - @direction_index
+      offset -= 4 while offset > 3
+      offset += 4 while offset < 0
+      RELATIVE_DIRECTIONS[offset]
+    end
+    
+    private
+    
+    def translate_offset(forward, right)
+      case direction
+      when :north then [@x + right, @y - forward]
+      when :east then [@x + forward, @y + right]
+      when :south then [@x - right, @y + forward]
+      when :west then [@x - forward, @y - right]
+      end
+    end
+  end
+end

data/lib/ruby_warrior/profile.rb

@@ -0,0 +1,86 @@
+require 'base64'
+
+module RubyWarrior
+  class Profile
+    attr_accessor :score, :epic_score, :current_epic_score, :abilities, :level_number, :tower_path, :warrior_name, :player_path
+    
+    def initialize
+      @tower_path = nil
+      @warrior_name = nil
+      @score = 0
+      @current_epic_score = 0
+      @epic_score = 0
+      @abilities = []
+      @level_number = 0
+    end
+    
+    def encode
+      Base64.encode64(Marshal.dump(self))
+    end
+    
+    def save
+      update_epic_score
+      @level_number = 0 if epic?
+      File.open(player_path + '/.profile', 'w') { |f| f.write(encode) }
+    end
+    
+    def self.decode(str)
+      Marshal.load(Base64.decode64(str))
+    end
+    
+    def self.load(path)
+      player = decode(File.read(path))
+      player.player_path = File.dirname(path)
+      player
+    end
+    
+    def player_path
+      @player_path || Config.path_prefix + "/ruby-warrior/#{directory_name}"
+    end
+    
+    def directory_name
+      [warrior_name.downcase.gsub(/[^a-z0-9]+/, '-'), tower.name].join('-')
+    end
+    
+    def to_s
+      if epic?
+        [warrior_name, tower.name, "first score #{score}", "epic score #{epic_score}"].join(' - ')
+      else
+        [warrior_name, tower.name, "level #{level_number}", "score #{score}"].join(' - ')
+      end
+    end
+    
+    def tower
+      Tower.new(@tower_path)
+    end
+    
+    def current_level
+      Level.new(self, level_number)
+    end
+    
+    def next_level
+      Level.new(self, level_number+1)
+    end
+    
+    def add_abilities(*abilities)
+      @abilities += abilities
+      @abilities.uniq!
+    end
+    
+    def enable_epic_mode
+      @epic = true
+      @epic_score ||= 0
+      @current_epic_score ||= 0
+    end
+    
+    def epic?
+      @epic
+    end
+    
+    def update_epic_score
+      if @current_epic_score > @epic_score
+        @epic_score = @current_epic_score
+      end
+    end
+  end
+end