rubywarrior-i18n 0.0.2

data/spec/ruby_warrior/abilities/rest_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe RubyWarrior::Abilities::Rest do
+  before(:each) do
+    @warrior = RubyWarrior::Units::Warrior.new
+    @rest = RubyWarrior::Abilities::Rest.new(@warrior)
+  end
+  
+  it "should give 10% health back" do
+    @warrior.stubs(:max_health).returns(20)
+    @warrior.health = 10
+    @rest.perform
+    @warrior.health.should == 12
+  end
+  
+  it "should add health when at max" do
+    @warrior.stubs(:max_health).returns(20)
+    @warrior.health = 20
+    @rest.perform
+    @warrior.health.should == 20
+  end
+  
+  it "should not go over max health" do
+    @warrior.stubs(:max_health).returns(20)
+    @warrior.health = 19
+    @rest.perform
+    @warrior.health.should == 20
+  end
+end

data/spec/ruby_warrior/abilities/shoot_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe RubyWarrior::Abilities::Shoot do
+  before(:each) do
+    @shooter = stub(:position => stub, :shoot_power => 2, :say => nil)
+    @shoot = RubyWarrior::Abilities::Shoot.new(@shooter)
+  end
+  
+  it "should shoot only first unit" do
+    receiver = stub(:alive? => true)
+    receiver.expects(:take_damage).with(2)
+    other = stub(:alive? => true)
+    other.expects(:take_damage).never
+    @shoot.expects(:multi_unit).with(:forward, anything).returns([nil, receiver, other, nil])
+    @shoot.perform
+  end
+  
+  it "should shoot and do nothing if no units in the way" do
+    @shoot.expects(:multi_unit).with(:forward, anything).returns([nil, nil])
+    lambda { @shoot.perform }.should_not raise_error
+  end
+end

data/spec/ruby_warrior/abilities/throw_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe RubyWarrior::Abilities::Detonate do
+  before(:each) do
+    @floor = RubyWarrior::Floor.new
+    @floor.width = 3
+    @floor.height = 3
+    @warrior = RubyWarrior::Units::Warrior.new
+    @floor.add(@warrior, 0, 0, :south)
+    @detonate = RubyWarrior::Abilities::Detonate.new(@warrior)
+  end
+  
+  it "should subtract 8 from forward unit and 4 from surrounding units" do
+    target_unit = RubyWarrior::Units::Base.new
+    target_unit.health = 15
+    second_unit = RubyWarrior::Units::Base.new
+    second_unit.health = 15
+    @floor.add(target_unit, 0, 1)
+    @floor.add(second_unit, 1, 1)
+    @detonate.perform
+    target_unit.health.should == 7
+    second_unit.health.should == 11
+  end
+  
+  it "should subtract 8 from left unit and 4 from surrounding units" do
+    target_unit = RubyWarrior::Units::Base.new
+    target_unit.health = 15
+    second_unit = RubyWarrior::Units::Base.new
+    second_unit.health = 15
+    @floor.add(target_unit, 1, 0)
+    @floor.add(second_unit, 1, 1)
+    @detonate.perform(:left)
+    target_unit.health.should == 7
+    second_unit.health.should == 11
+  end
+  
+  it "should detonate an explosive if any unit has one" do
+    captive = RubyWarrior::Units::Captive.new
+    captive.health = 1
+    captive.add_abilities :explode!
+    @floor.add(captive, 1, 1)
+    @detonate.perform
+    captive.health.should == -99
+    @warrior.health.should == -80
+  end
+end

data/spec/ruby_warrior/abilities/walk_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe RubyWarrior::Abilities::Walk do
+  before(:each) do
+    @space = stub(:empty? => true, :unit => nil)
+    @position = stub(:relative_space => @space, :move => nil)
+    @walk = RubyWarrior::Abilities::Walk.new(stub(:position => @position, :say => nil))
+  end
+  
+  it "should move position forward when calling perform" do
+    @position.expects(:move).with(1, 0)
+    @walk.perform
+  end
+  
+  it "should move position right if that is direction" do
+    @position.expects(:move).with(0, 1)
+    @walk.perform(:right)
+  end
+  
+  it "should keep position if something is in the way" do
+    @position.stubs(:move).raises("shouldn't be called")
+    @space.stubs(:empty?).returns(false)
+    lambda { @walk.perform(:right) }.should_not raise_error
+  end
+end

data/spec/ruby_warrior/core_additions_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe String do
+  it "should wrap text at white space when over a specific character length" do
+    "foo bar blah".hard_wrap(10).should == "foo bar\nblah"
+  end
+end

data/spec/ruby_warrior/floor_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe RubyWarrior::Floor do
+  describe "2x3" do
+    before(:each) do
+      @floor = RubyWarrior::Floor.new
+      @floor.width = 2
+      @floor.height = 3
+    end
+  
+    it "should be able to add a unit and fetch it at that position" do
+      unit = RubyWarrior::Units::Base.new
+      @floor.add(unit, 0, 1, :north)
+      @floor.get(0, 1).should == unit
+    end
+  
+    it "should not consider unit on floor if no position" do
+      unit = RubyWarrior::Units::Base.new
+      @floor.add(unit, 0, 1, :north)
+      unit.position = nil
+      @floor.units.should_not include(unit)
+    end
+  
+    it "should fetch other units not warrior" do
+      unit = RubyWarrior::Units::Base.new
+      warrior = RubyWarrior::Units::Warrior.new
+      @floor.add(unit, 0, 0, :north)
+      @floor.add(warrior, 1, 0, :north)
+      @floor.other_units.should_not include(warrior)
+      @floor.other_units.should include(unit)
+    end
+  
+    it "should not consider corners out of bounds" do
+      @floor.should_not be_out_of_bounds(0, 0)
+      @floor.should_not be_out_of_bounds(1, 0)
+      @floor.should_not be_out_of_bounds(1, 2)
+      @floor.should_not be_out_of_bounds(0, 2)
+    end
+  
+    it "should consider out of bounds when going beyond sides" do
+      @floor.should be_out_of_bounds(-1, 0)
+      @floor.should be_out_of_bounds(0, -1)
+      @floor.should be_out_of_bounds(0, 3)
+      @floor.should be_out_of_bounds(2, 0)
+    end
+  
+    it "should return space at the specified location" do
+      @floor.space(0, 0).should be_kind_of(RubyWarrior::Space)
+    end
+  
+    it "should place stairs and be able to fetch the location" do
+      @floor.place_stairs(1, 2)
+      @floor.stairs_location.should == [1, 2]
+    end
+  end
+  
+  describe "3x1" do
+    before(:each) do
+      @floor = RubyWarrior::Floor.new
+      @floor.width = 3
+      @floor.height = 1
+    end
+  
+    it "should print map with stairs and unit" do
+      @floor.add(RubyWarrior::Units::Warrior.new, 0, 0)
+      @floor.place_stairs(2, 0)
+      @floor.character.should == <<-MAP
+ ---
+|@ >|
+ ---
+MAP
+    end
+    
+    it "should return unique units" do
+      u1 = RubyWarrior::Units::Base.new
+      @floor.add(u1, 0, 0)
+      @floor.add(RubyWarrior::Units::Base.new, 1, 0)
+      @floor.unique_units.should == [u1]
+    end
+  end
+end

data/spec/ruby_warrior/game_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe RubyWarrior::Game do
+  before(:each) do
+    @game = RubyWarrior::Game.new
+  end
+  
+  # GAME DIR
+  
+  it "should make game directory if player says so" do
+    RubyWarrior::UI.stubs(:ask).returns(true)
+    Dir.expects(:mkdir).with('./rubywarrior')
+    @game.make_game_directory
+  end
+  
+  it "should not make game and exit if player says no" do
+    RubyWarrior::UI.stubs(:ask).returns(false)
+    Dir.stubs(:mkdir).raises('should not be called')
+    lambda { @game.make_game_directory }.should raise_error(SystemExit)
+  end
+  
+  
+  # PROFILES
+  
+  it "should load profiles for each profile path" do
+    RubyWarrior::Profile.expects(:load).with('foo/.profile').returns(1)
+    RubyWarrior::Profile.expects(:load).with('bar/.profile').returns(2)
+    @game.stubs(:profile_paths).returns(['foo/.profile', 'bar/.profile'])
+    @game.profiles.should == [1, 2]
+  end
+  
+  it "should find profile paths using Dir[] search" do
+    Dir.expects(:[]).with("./rubywarrior/**/.profile")
+    @game.profile_paths
+  end
+  
+  it "should try to create profile when no profile paths are specified" do
+    @game.stubs(:profiles).returns([])
+    @game.expects(:new_profile).returns('profile')
+    @game.profile.should == 'profile'
+  end
+  
+  it "should ask a player to choose a profile if multiple profiles are available, but only once" do
+    RubyWarrior::UI.expects(:choose).with('profile', [:profile1, [:new, 'New Profile']]).returns(:profile1)
+    @game.stubs(:profiles).returns([:profile1])
+    2.times { @game.profile.should == :profile1 }
+  end
+  
+  it "should ask user to choose a tower when creating a new profile" do
+    RubyWarrior::UI.stubs(:gets).returns('')
+    @game.stubs(:towers).returns([:tower1, :tower2])
+    RubyWarrior::UI.expects(:choose).with('tower', [:tower1, :tower2]).returns(stub(:path => '/foo/bar'))
+    @game.new_profile
+  end
+  
+  it "should pass name and selected tower to profile" do
+    profile = stub
+    RubyWarrior::UI.stubs(:choose).returns(stub(:path => 'tower_path'))
+    RubyWarrior::UI.stubs(:request).returns('name')
+    RubyWarrior::Profile.expects(:new).returns(profile)
+    profile.expects(:tower_path=).with('tower_path')
+    profile.expects(:warrior_name=).with('name')
+    @game.new_profile.should == profile
+  end
+  
+  
+  # TOWERS
+  
+  it "load towers for each tower path" do
+    RubyWarrior::Tower.expects(:new).with('towers/foo').returns(1)
+    RubyWarrior::Tower.expects(:new).with('towers/bar').returns(2)
+    @game.stubs(:tower_paths).returns(['towers/foo', 'towers/bar'])
+    @game.towers.should == [1, 2]
+  end
+  
+  it "should find tower paths using Dir[] search" do
+    Dir.expects(:[]).with(File.expand_path('../../../towers/*', __FILE__))
+    @game.tower_paths
+  end
+  
+  
+  # LEVEL
+  
+  it "should fetch current level from profile and cache it" do
+    @game.stubs(:profile).returns(stub)
+    @game.profile.expects(:current_level).returns('foo')
+    2.times { @game.current_level.should == 'foo' }
+  end
+  
+  it "should fetch next level from profile and cache it" do
+    @game.stubs(:profile).returns(stub)
+    @game.profile.expects(:next_level).returns('bar')
+    2.times { @game.next_level.should == 'bar' }
+  end
+  
+  it "should report final grade" do
+    profile = RubyWarrior::Profile.new
+    profile.current_epic_grades = { 1 => 0.7, 2 => 0.9 }
+    @game.stubs(:profile).returns(profile)
+    report = @game.final_report
+    report.should include("Your average grade for this tower is: B")
+    report.should include("Level 1: C\n  Level 2: A")
+  end
+  
+  it "should have an empty final report if no epic grades are available" do
+    profile = RubyWarrior::Profile.new
+    profile.current_epic_grades = {}
+    @game.stubs(:profile).returns(profile)
+    @game.final_report.should be_nil
+  end
+  
+  it "should have an empty final report if practice level" do
+    RubyWarrior::Config.practice_level = 2
+    profile = RubyWarrior::Profile.new
+    profile.current_epic_grades = { 1 => 0.7, 2 => 0.9 }
+    @game.stubs(:profile).returns(profile)
+    @game.final_report.should be_nil
+  end
+end

data/spec/ruby_warrior/level_loader_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe RubyWarrior::LevelLoader do
+  describe "with profile" do
+    before(:each) do
+      @profile = RubyWarrior::Profile.new
+      @level = RubyWarrior::Level.new(@profile, 1)
+      @loader = RubyWarrior::LevelLoader.new(@level)
+    end
+    
+    it "should be able to add description, tip and clue" do
+      @loader.description "foo"
+      @loader.tip "bar"
+      @loader.clue "clue"
+      @level.description.should == "foo"
+      @level.tip.should == "bar"
+      @level.clue.should == "clue"
+    end
+    
+    it "should be able to set size" do
+      @loader.size 5, 3
+      @level.floor.width.should == 5
+      @level.floor.height.should == 3
+    end
+    
+    it "should be able to add stairs" do
+      @level.floor.expects(:place_stairs).with(1, 2)
+      @loader.stairs 1, 2
+    end
+    
+    it "should yield new unit when building" do
+      @loader.unit :base, 1, 2 do |unit|
+        unit.should be_kind_of(RubyWarrior::Units::Base)
+        unit.position.should be_at(1, 2)
+      end
+    end
+    
+    it "should be able to add multi-word units" do
+      lambda { @loader.unit :thick_sludge, 1, 2 }.should_not raise_error
+    end
+    
+    it "should build warrior from profile" do
+      @loader.warrior 1, 2 do |unit|
+        unit.should be_kind_of(RubyWarrior::Units::Warrior)
+        unit.position.should be_at(1, 2)
+      end
+    end
+    
+    it "should be able to set time bonus" do
+      @loader.time_bonus 100
+      @level.time_bonus.should == 100
+    end
+  end
+end

data/spec/ruby_warrior/level_spec.rb

@@ -0,0 +1,203 @@
+require 'spec_helper'
+require 'set'
+
+describe RubyWarrior::Level do
+  before(:each) do
+    @profile = RubyWarrior::Profile.new
+    @floor = RubyWarrior::Floor.new
+    @level = RubyWarrior::Level.new(@profile, 1)
+    @level.floor = @floor
+    @level.stubs(:failed?).returns(false)
+  end
+  
+  it "should consider passed when warrior is on stairs" do
+    @level.warrior = RubyWarrior::Units::Warrior.new
+    @floor.add(@level.warrior, 0, 0, :north)
+    @floor.place_stairs(0, 0)
+    @level.should be_passed
+  end
+  
+  it "should default time bonus to zero" do
+    @level.time_bonus.should be_zero
+  end
+  
+  it "should have a grade relative to ace score" do
+    @level.ace_score = 100
+    @level.grade_for(110).should == "S"
+    @level.grade_for(100).should == "S"
+    @level.grade_for(99).should == "A"
+    @level.grade_for(89).should == "B"
+    @level.grade_for(79).should == "C"
+    @level.grade_for(69).should == "D"
+    @level.grade_for(59).should == "F"
+  end
+  
+  it "should have no grade if there is no ace score" do
+    @level.ace_score.should be_nil
+    @level.grade_for(100).should be_nil
+  end
+  
+  it "should load file contents into level" do
+    @level.stubs(:load_path).returns('path/to/level.rb')
+    File.expects(:read).with('path/to/level.rb').returns("description 'foo'")
+    @level.load_level
+    @level.description.should == 'foo'
+  end
+  
+  it "should have a player path from profile" do
+    @profile.stubs(:player_path).returns('path/to/player')
+    @level.player_path.should == 'path/to/player'
+  end
+  
+  it "should have a load path from profile tower with level number in it" do
+    @profile.stubs(:tower_path).returns('path/to/tower')
+    @level.load_path.should == File.expand_path('towers/tower/level_001.rb')
+  end
+  
+  it "should exist if file exists" do
+    @level.stubs(:load_path).returns('/foo/bar')
+    File.expects(:exist?).with('/foo/bar').returns(true)
+    @level.exists?.should be_true
+  end
+  
+  it "should load player and player path" do
+    @level.stubs(:player_path).returns('player/path')
+    $:.expects(:<<).with('player/path')
+    @level.expects(:load).with('player.rb')
+    @level.load_player
+  end
+  
+  it "should generate player files" do
+    @level.expects(:load_level)
+    generator = stub
+    generator.expects(:generate)
+    RubyWarrior::PlayerGenerator.expects(:new).with(@level).returns(generator)
+    @level.generate_player_files
+  end
+  
+  it "should setup warrior with profile abilities" do
+    @profile.abilities = [:foo, :bar]
+    warrior = stub_everything
+    warrior.expects(:add_abilities).with(:foo, :bar)
+    @level.setup_warrior(warrior)
+  end
+  
+  it "should setup warrior with profile name" do
+    @profile.warrior_name = "Joe"
+    warrior = stub_everything
+    warrior.expects(:name=).with("Joe")
+    @level.setup_warrior(warrior)
+  end
+  
+  describe "playing" do
+    before(:each) do
+      @level.stubs(:load_level)
+    end
+    
+    it "should load level once when playing multiple turns" do
+      @level.expects(:load_level)
+      @level.play(2)
+    end
+    
+    it "should call prepare_turn and play_turn on each object specified number of times" do
+      object = RubyWarrior::Units::Base.new
+      object.expects(:prepare_turn).times(2)
+      object.expects(:perform_turn).times(2)
+      @floor.add(object, 0, 0, :north)
+      @level.play(2)
+    end
+  
+    it "should return immediately when passed" do
+      object = RubyWarrior::Units::Base.new
+      object.expects(:turn).times(0)
+      @floor.add(object, 0, 0, :north)
+      @level.stubs(:passed?).returns(true)
+      @level.play(2)
+    end
+  
+    it "should yield to block in play method for each turn" do
+      int = 0
+      @level.play(2) do
+        int += 1
+      end
+      int.should == 2
+    end
+  
+    it "should count down time_bonus once each turn" do
+      @level.time_bonus = 10
+      @level.play(3)
+      @level.time_bonus.should == 7
+    end
+  
+    it "should count down time_bonus below 0" do
+      @level.time_bonus = 2
+      @level.play(5)
+      @level.time_bonus.should be_zero
+    end
+    
+    it "should have a pretty score calculation" do
+      @level.score_calculation(123, 45).should == "123 + 45 = 168"
+    end
+    
+    it "should not have a score calculation when starting score is zero" do
+      @level.score_calculation(0, 45).should == "45"
+    end
+  end
+  
+  describe "tallying points" do
+    before(:each) do
+      @warrior = stub(:score => 0, :abilities => {})
+      @level.stubs(:warrior).returns(@warrior)
+      @level.floor.stubs(:other_units).returns([stub])
+    end
+    
+    it "should add warrior score to profile" do
+      @warrior.stubs(:score).returns(30)
+      @level.tally_points
+      @profile.score.should == 30
+    end
+    
+    it "should add warrior score to profile for epic mode" do
+      @profile.enable_epic_mode
+      @warrior.stubs(:score).returns(30)
+      @level.tally_points
+      @profile.current_epic_score.should == 30
+    end
+    
+    it "should add level grade percent to profile for epic mode" do
+      @level.ace_score = 100
+      @profile.enable_epic_mode
+      @warrior.stubs(:score).returns(30)
+      @level.tally_points
+      @profile.current_epic_grades.should == { 1 => 0.3 }
+    end
+    
+    it "should not add level grade if ace score is not set" do
+      @level.ace_score = nil
+      @profile.enable_epic_mode
+      @warrior.stubs(:score).returns(30)
+      @level.tally_points
+      @profile.current_epic_grades.should == {}
+    end
+    
+    it "should apply warrior abilities to profile" do
+      @warrior.stubs(:abilities).returns({:foo => nil, :bar => nil})
+      @level.tally_points
+      @profile.abilities.to_set.should == [:foo, :bar].to_set
+    end
+    
+    it "should apply time bonus to profile score" do
+      @level.time_bonus = 20
+      @level.tally_points
+      @profile.score.should == 20
+    end
+    
+    it "should give 20% bonus when no other units left" do
+      @level.floor.stubs(:other_units).returns([])
+      @warrior.stubs(:score).returns(10)
+      @level.time_bonus = 10
+      @level.tally_points
+      @profile.score.should == 24
+    end
+  end
+end