rubywarrior-i18n 0.0.2

data/lib/ruby_warrior/level.rb

@@ -0,0 +1,123 @@
+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
+      File.join(
+        File.expand_path('../../../towers/', __FILE__),
+        File.basename(@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 "- #{R18n.t.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 "#{R18n.t.level.score}: #{warrior.score}"
+      score += warrior.score
+      
+      UI.puts "#{R18n.t.bonus.time}: #{time_bonus}"
+      score += @time_bonus
+      
+      if floor.other_units.empty?
+        UI.puts "#{R18n.t.bonus.clear}: #{clear_bonus}"
+        score += clear_bonus
+      end
+      
+      if @profile.epic?
+        UI.puts "#{R18n.t.level.grade}: #{grade_for(score)}" if grade_for(score)
+        UI.puts "#{R18n.t.score.total}: " + 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 "#{R18n.t.score.total}: " + 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

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) unless File.exists? 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("../../../templates", __FILE__)
+    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,82 @@
+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
+      distance_of(@floor.stairs_space)
+    end
+    
+    def distance_of(space)
+      x, y = *space.location
+      (@x - x).abs + (@y - 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
+    
+    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,120 @@
+require 'base64'
+
+module RubyWarrior
+  class Profile
+    attr_accessor :score, :epic_score, :current_epic_score, :average_grade, :current_epic_grades, :abilities, :level_number, :last_level_number, :tower_path, :warrior_name, :player_path
+    
+    def initialize
+      @tower_path = nil
+      @warrior_name = nil
+      @score = 0
+      @current_epic_score = 0
+      @current_epic_grades = {}
+      @epic_score = 0
+      @average_grade = nil
+      @abilities = []
+      @level_number = 0
+      @last_level_number = nil
+    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 + "/rubywarrior/#{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, "#{R18n.t.score.first} #{score}", "#{R18n.t.score.epic} #{epic_score_with_grade}"].join(' - ')
+      else
+        [warrior_name, tower.name, "#{R18n.t.level.level} #{level_number}", "#{R18n.t.score.score} #{score}"].join(' - ')
+      end
+    end
+    
+    def epic_score_with_grade
+      if average_grade
+        "#{epic_score} (#{Level.grade_letter(average_grade)})"
+      else
+        epic_score
+      end
+    end
+    
+    def tower
+      Tower.new(File.basename @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
+      @last_level_number ||= @level_number
+    end
+    
+    def enable_normal_mode
+      @epic = false
+      @epic_score = 0
+      @current_epic_score = 0
+      @current_epic_grades = {}
+      @average_grade = nil
+      @level_number = @last_level_number
+      @last_level_number = nil
+    end
+    
+    def epic?
+      @epic
+    end
+    
+    def level_after_epic?
+      Level.new(self, last_level_number+1).exists? if last_level_number
+    end
+    
+    def update_epic_score
+      if @current_epic_score > @epic_score
+        @epic_score = @current_epic_score
+        @average_grade = calculate_average_grade
+      end
+    end
+    
+    def calculate_average_grade
+      if @current_epic_grades.size > 0
+        sum = @current_epic_grades.values.inject(0) { |sum, value| sum + value }
+        sum / @current_epic_grades.size
+      end
+    end
+  end
+end

data/lib/ruby_warrior/runner.rb

@@ -0,0 +1,34 @@
+require 'optparse'
+
+module RubyWarrior
+  class Runner
+    def initialize(arguments, stdin, stdout)
+      @arguments = arguments
+      @stdin = stdin
+      @stdout = stdout
+      @game = RubyWarrior::Game.new
+    end
+    
+    def run
+      Config.in_stream = @stdin
+      Config.out_stream = @stdout
+      Config.delay = 0.6
+      parse_options
+      @game.start
+    end
+    
+    private
+    
+    def parse_options
+      t = R18n.t.runner.options
+      options = OptionParser.new 
+      options.banner = t.banner
+      options.on('-d', '--directory DIR', t.directory)  { |dir| Config.path_prefix = dir }
+      options.on('-l', '--level LEVEL',   t.level)      { |level| Config.practice_level = level.to_i }
+      options.on('-s', '--skip',          t.skip)       { Config.skip_input = true }
+      options.on('-t', '--time SECONDS',  t.time)       { |seconds| Config.delay = seconds.to_f }
+      options.on('-h', '--help',          t.help)       { puts(options); exit }
+      options.parse!(@arguments)
+    end
+  end
+end