rubywarrior 0.1.0

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,104 @@
+require 'base64'
+
+module RubyWarrior
+  class Profile
+    attr_accessor :score, :epic_score, :current_epic_score, :average_grade, :current_epic_grades, :abilities, :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
+    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, "first score #{score}", "epic score #{epic_score_with_grade}"].join(' - ')
+      else
+        [warrior_name, tower.name, "level #{level_number}", "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(@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
+        @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,33 @@
+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.8
+      parse_options
+      @game.start
+    end
+    
+    private
+    
+    def parse_options
+      options = OptionParser.new 
+      options.banner = "Usage: rubywarrior [options]"
+      options.on('-d', '--directory DIR', "Run under given directory")  { |dir| Config.path_prefix = dir }
+      options.on('-l', '--level LEVEL',   "Practice level on epic")     { |level| Config.practice_level = level.to_i }
+      options.on('-s', '--skip',          "Skip user input")            { Config.skip_input = true }
+      options.on('-t', '--time SECONDS',  "Delay each turn by seconds") { |seconds| Config.delay = seconds.to_f }
+      options.on('-h', '--help',          "Show this message")          { puts(options); exit }
+      options.parse!(@arguments)
+    end
+  end
+end

data/lib/ruby_warrior/space.rb

@@ -0,0 +1,63 @@
+module RubyWarrior
+  class Space
+    def initialize(floor, x, y)
+      @floor, @x, @y = floor, x, y
+    end
+    
+    def wall?
+      @floor.out_of_bounds? @x, @y
+    end
+    
+    def warrior?
+      unit.kind_of? Units::Warrior
+    end
+    
+    def enemy?
+      unit && !warrior? && !captive?
+    end
+    
+    def captive?
+      unit && unit.bound?
+    end
+    
+    def empty?
+      unit.nil? && !wall?
+    end
+    
+    def stairs?
+      @floor.stairs_location == location
+    end
+    
+    def ticking?
+      unit.respond_to?(:bomb_time) && unit.bomb_time
+    end
+    
+    def unit
+      @floor.get(@x, @y)
+    end
+    
+    def location
+      [@x, @y]
+    end
+    
+    def character
+      if unit
+        unit.character
+      elsif stairs?
+        ">"
+      else
+        " "
+      end
+    end
+    
+    def to_s
+      if unit
+        unit.to_s
+      elsif wall?
+        'wall'
+      else
+        'nothing'
+      end
+    end
+  end
+end

data/lib/ruby_warrior/tower.rb

@@ -0,0 +1,14 @@
+module RubyWarrior
+  class Tower
+    attr_reader :path
+    
+    def initialize(path)
+      @path = path
+    end
+    
+    def name
+      File.basename(path)
+    end
+    alias_method :to_s, :name
+  end
+end

data/lib/ruby_warrior/turn.rb

@@ -0,0 +1,38 @@
+module RubyWarrior
+  class Turn
+    attr_reader :action
+    
+    def initialize(abilities)
+      @action = nil
+      @senses = {}
+      
+      abilities.each do |name, sense|
+        if name.to_s =~ /\!$/
+          add_action(name)
+        else
+          add_sense(name, sense)
+        end
+      end
+    end
+    
+    private
+    
+    def add_action(action)
+      instance_eval <<-EOS
+        def #{action}(*args)
+          raise "Only one action can be performed per turn." if @action
+          @action = [:#{action}, *args]
+        end
+      EOS
+    end
+    
+    def add_sense(name, sense)
+      instance_eval <<-EOS
+        def #{name}(*args)
+          @senses[:#{name}].perform(*args)
+        end
+      EOS
+      @senses[name] = sense
+    end
+  end
+end

data/lib/ruby_warrior/ui.rb

@@ -0,0 +1,54 @@
+module RubyWarrior
+  class UI
+    class << self
+      def puts(msg)
+        Config.out_stream.puts(msg) if Config.out_stream
+      end
+      
+      def puts_with_delay(msg)
+        result = puts(msg)
+        sleep(Config.delay) if Config.delay
+        result
+      end
+      
+      def print(msg)
+        Config.out_stream.print(msg) if Config.out_stream
+      end
+      
+      def gets
+        Config.in_stream ? Config.in_stream.gets : ''
+      end
+      
+      def request(msg)
+        print(msg)
+        gets.chomp
+      end
+      
+      def ask(msg)
+        request("#{msg} [yn] ") == 'y'
+      end
+      
+      # REFACTORME
+      def choose(item, options)
+        if options.length == 1
+          response = options.first
+        else
+          options.each_with_index do |option, i|
+            if option.kind_of? Array
+              puts "[#{i+1}] #{option.last}"
+            else
+              puts "[#{i+1}] #{option}"
+            end
+          end
+          choice = request("Choose #{item} by typing the number: ")
+          response = options[choice.to_i-1]
+        end
+        if response.kind_of? Array
+          response.first
+        else
+          response
+        end
+      end
+    end
+  end
+end

data/lib/ruby_warrior/units/archer.rb

@@ -0,0 +1,34 @@
+module RubyWarrior
+  module Units
+    class Archer < Base
+      def initialize
+        add_abilities :shoot!, :look
+      end
+      
+      def play_turn(turn)
+        [:forward, :left, :right].each do |direction|
+          turn.look(direction).each do |space|
+            if space.warrior?
+              turn.shoot!(direction)
+              return
+            elsif !space.empty?
+              break
+            end
+          end
+        end
+      end
+      
+      def shoot_power
+        3
+      end
+      
+      def max_health
+        7
+      end
+      
+      def character
+        "a"
+      end
+    end
+  end
+end