greyhawkweather 0.0.6 → 0.0.7

data/spec/dieroller_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'util/dieroller'
+
+describe DieRoller do
+  it "should use Kernel::rand" do
+    subject.stub(:rand).and_return 0
+    subject.should_receive(:rand).with(6)
+    subject.roll(6)
+  end
+
+  it "should return random number +1" do
+    subject.stub(:rand).and_return 0
+    subject.should_receive :rand
+    subject.roll(6).should == 1
+  end
+
+  it "should apply modifier if given" do
+    subject.stub(:rand).and_return 1
+    subject.roll(6, 2).should equal 4
+    subject.roll(6, -3).should == -1
+  end
+end

data/spec/latitude_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'singledayweather'
+require 'util/dieroller'
+
+describe "Base temperature modified by latitude" do
+  let(:month) {
+    month = mock(:Month).as_null_object
+    month.stub(:temp_range).and_return((10..20))
+    month
+  }
+
+  let(:roller) {
+    rigged_roller_mock 10
+  }
+
+  it "should increase base temp by 2 degrees Farenheit for each degree latitude below 40" do
+    weather = SingleDayWeather.new(month, roller, PrecipitationOccurance.new, nil, :plains, 30)
+    weather.temperature_range.should == (-10..0)
+  end
+
+  it "should decrease base temp by 2 degrees Farenheit for each degree latitude above 40" do
+    weather = SingleDayWeather.new(month, roller, PrecipitationOccurance.new, nil, :plains, 50)
+    weather.temperature_range.should == (30..40)
+  end
+end

data/spec/month_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'month'
+
+describe Month do
+  it "uses sky condition data to determine current conditions" do
+    month = Month.new(nil, SkyConditions.new((0..34), (35..65), (66..100)))
+    month.sky_conditions(make_roller(25)).should eq(:clear)
+    month.sky_conditions(make_roller(50)).should eq(:partly_cloudy)
+    month.sky_conditions(make_roller(75)).should eq(:cloudy)
+  end
+
+  it "uses temp range data to determine current conditions" do
+    month = Month.new(TemperatureRange.new(10, [8, 2], [20, 5]), nil)
+    month.temp_range(make_roller(5)).should == (0..17)
+  end
+
+  it "handles record high" do
+    month = Month.new(TemperatureRange.new(10, [8, 2], [20, 5]), nil)
+    month.temp_range(make_roller(1), :high).should == (14..23)
+  end
+
+  it "determines precipitation" do
+    month = Month.new(nil, nil, 50)
+    month.has_precipitation(make_roller(10)).should be_true
+    month.has_precipitation(make_roller(70)).should be_false
+  end
+
+  private
+  def make_roller(roll)
+    roller = mock(:DieRoller)
+    roller.stub(:roll) { |n, m| roll + (m || 0)}
+    roller
+  end
+end 

data/spec/options_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'options'
+
+describe 'WeatherGeneratorOptions' do
+  describe 'defaults' do
+    subject { WeatherGeneratorOptions.new }
+    its(:month) { should == 1 }
+    its(:num_days) { should == 28 }
+    its(:terrain) { should == :plains }
+    its(:dieroller) { should be_instance_of(DieRoller) }
+  end
+
+  describe 'overriding defaults' do
+    class SpecialDieRoller < DieRoller
+    end
+    subject { WeatherGeneratorOptions.new({:month => 4,
+                                             :num_days => 10,
+                                             :terrain => :hills,
+                                             :dieroller => SpecialDieRoller.new})}
+    its(:month) { should == 4 }
+    its(:num_days) { should == 10 }
+    its(:terrain) { should == :hills }
+    its(:dieroller) { should be_instance_of(SpecialDieRoller) }
+  end
+end

data/spec/precipation_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'precipitation'
+require 'precipitationinfo'
+
+describe Precipitation do
+  it "has rainbow" do
+    precip = Precipitation.new(PrecipitationInfo.create_from_data({:name => "foo", :chance_of_rainbow => 30}),
+                                rigged_roller_mock(10))
+    precip.rainbow?.should be_true
+  end
+
+  it "has no rainbow" do
+    precip = Precipitation.new(PrecipitationInfo.create_from_data({:name => "foo", :chance_of_rainbow => 30}),
+                                rigged_roller_mock(40))
+    precip.rainbow?.should be_false
+  end
+
+  it "has no rainbow if there is no chance of rainbow" do
+    precip = Precipitation.new(PrecipitationInfo.create_from_data({ :name => "foo", :chance_of_rainbow => 0}),
+                               rigged_roller_mock(0))
+    precip.rainbow?.should be_false
+  end
+end

data/spec/precipitation_occurance_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+require 'precipitationoccurance'
+
+describe PrecipitationOccurance do
+  it "returns array of precipitation" do
+    roller = make_roller(13)
+    precip_occur = PrecipitationOccurance.new({(0..20) => mock(:PrecipitationInfo).as_null_object,
+                                                (21..100) => mock(:PrecipitationInfo).as_null_object})
+    precip_occur.type(roller).should be_instance_of Array
+    precip_occur.type(roller)[0].should be_instance_of Precipitation
+  end
+
+  it "determines precipitation" do
+    snowstorm = create_test_precipitation(:light_snowstorm)
+    rainstorm = create_test_precipitation(:light_rainstorm)
+
+    precip_occur = PrecipitationOccurance.new({(0..20) => snowstorm,
+                                                (21..100) => rainstorm})
+    { 13 => :light_snowstorm,
+      57 => :light_rainstorm
+    }.each_pair { |roll, precip|
+      precip_occur.type(make_roller(roll))[0].name.should == precip
+    }
+  end
+
+  it "loads from file" do
+    precip_occur = PrecipitationOccurance.load("data/precipitationoccurance.yml")
+    precip_occur.type(make_roller(22))[0].name.should == "Sleetstorm"
+  end
+
+  it "defaults to null precipitation" do
+    PrecipitationOccurance.new.type(make_roller(13))[0].name.should == NullPrecipitationInfo.new.name
+  end
+
+  it "checks for and computes continuing precipitation" do
+    snowstorm = create_test_precipitation(:light_snowstorm)
+    rainstorm = create_test_precipitation(:light_rainstorm)
+    precip_occur = PrecipitationOccurance.new({(0..20) => snowstorm,
+                                                (21..100) => rainstorm})
+    precip_occur.type(make_roller(35, 5, 1, 5, 10, 5, 5, 100)).map{ |p| p.name }.should ==
+      [:light_rainstorm, :light_snowstorm, :light_rainstorm, :light_rainstorm]
+  end
+
+  it "checks terrain for precipitation" do
+    precip = mock(:PrecipitationInfo)
+    precip.stub(:not_allowed_in).and_return([:desert])
+
+    precip_occur = PrecipitationOccurance.new({ (0..20) => precip})
+    precip_occur.type(make_roller(10), nil, :desert).first.name.should == NullPrecipitationInfo.new.name
+  end
+
+  it "does no reroll if temp_range is ok" do
+    precip = create_test_precipitation(:foo, 0, [10,50])
+    precip_occur = PrecipitationOccurance.new({(0..20) => precip})
+
+    roller = make_roller(10)
+    roller.should_receive(:roll).exactly(1) 
+    
+    precip_occur.type(roller, (20..40))
+  end
+
+  it "rerolls if temp is too low" do
+    precip = create_test_precipitation(:foo, 0, [20,20])
+    precip_occur = PrecipitationOccurance.new({(0..20) => precip})
+
+    roller = make_roller(10)
+    roller.should_receive(:roll).exactly(2) 
+    
+    precip_occur.type(roller, (0..10))
+  end
+
+  it "rerolls if temp is too high" do
+    precip = create_test_precipitation(:foo, 0, [20,20])
+    precip_occur = PrecipitationOccurance.new({(0..20) => precip})
+
+    roller = make_roller(10)
+    roller.should_receive(:roll).exactly(2)
+
+    precip_occur.type(roller, (50..60))
+     
+  end
+
+  it "checks temp ranges for continuing weather" do
+    precipcold = create_test_precipitation(:cold, 0, [20,20])
+    precipwarm = create_test_precipitation(:warm, 10, [30,30])
+
+    precip_occur = PrecipitationOccurance.new({(0..20) => precipcold, (30..50) => precipwarm})
+     
+    roller = make_roller(40, 10, 10)
+    roller.should_receive(:roll).exactly(3)
+
+    precipitations = precip_occur.type(roller, (30..30))
+    precipitations.collect { |p|  p.name }.should == [:warm, "No Precipitation"]
+  end
+
+
+  private
+  def make_roller(*rolls)
+    roller = mock(:DieRoller)
+    roller.stub(:roll).and_return(*rolls)
+    roller
+  end
+
+  def create_test_precipitation (name, chance_to_continue = 10, min_max = [0, 100])
+    precip = mock(:Precipitation)
+    precip.stub(:not_allowed_in).and_return([])
+    precip.stub(:min_temp).and_return(min_max[0])
+    precip.stub(:max_temp).and_return(min_max[1])
+    precip.stub(:name).and_return(name)
+    precip.stub(:chance_of_rainbow).and_return(0)
+    precip.stub(:chance_to_continue).and_return(chance_to_continue)
+    precip
+  end
+end 

data/spec/singledayweather_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'singledayweather'
+
+describe SingleDayWeather do
+  it "temp range is calculated by appropriate die rolls" do
+    roller = rigged_roller_mock 0
+    month = mock(:Month).as_null_object
+    month.should_recieve(:temp_range).with(roller, nil)
+    month.stub(:temp_range).and_return((5..24))
+    SingleDayWeather.new(month, roller).temperature_range.should == (5..24)
+  end
+
+  it "determines sky conditions" do
+    roller = rigged_roller_mock 50
+    month = mock(:Month).as_null_object
+    month.stub(:sky_conditions).and_return(:partly_cloudy)
+    SingleDayWeather.new(month, roller).sky_conditions.should == :partly_cloudy
+  end
+
+  it "determines precipitation" do
+    roller = rigged_roller_mock 0
+
+    month = mock(:Month).as_null_object
+
+    precip = mock(:PrecipitationInfo)
+
+    precipitation = mock(:PrecipitationOccurance).as_null_object
+    precipitation.should_receive(:type).with(roller, anything(), anything()).and_return([precip])
+    SingleDayWeather.new(month, roller, precipitation).precipitation.should == [precip]
+  end
+
+  it "deals with record highs" do
+    roller = rigged_roller_mock 0
+    month = mock(:Month).as_null_object
+    month.should_recieve(:temp_range).with(anything(), anything(), :high)
+    precip_occur =  mock(:PrecipitationOccurance).as_null_object
+    precip_occur.stub(:type)
+    SingleDayWeather.new(month, roller, precip_occur, :high)
+  end
+
+  it "determines wind" do
+    SingleDayWeather.new(mock(:Month).as_null_object, avg_roller_mock).wind.to_s.should == "9SE"
+  end
+end 

data/spec/sky_conditions_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'skyconditions'
+
+describe 'SkyConditions' do
+  let(:conditions) { SkyConditions.new((01..23), (24..50), (51..100)) }
+
+  it 'picks from ranges' do
+    conditions.condition(rigged_roller_mock(1)).should eq(:clear)
+    conditions.condition(rigged_roller_mock(23)).should eq(:clear)
+    conditions.condition(rigged_roller_mock(24)).should eq(:partly_cloudy)
+    conditions.condition(rigged_roller_mock(50)).should eq(:partly_cloudy)
+    conditions.condition(rigged_roller_mock(51)).should eq(:cloudy)
+    conditions.condition(rigged_roller_mock(99)).should eq(:cloudy)
+    conditions.condition(rigged_roller_mock(100)).should eq(:cloudy)
+  end
+
+  it 'should treat 0 as 100' do
+    conditions.condition(rigged_roller_mock(0)).should eq(:cloudy)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+begin
+  require 'rspec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  gem 'rspec'
+  require 'rspec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'greyhawkweather'
+
+def avg_roller_mock
+  roller = mock(:DieRoller)
+  roller.stub(:roll) {|n, m|  n/2 + (m||0)}
+  roller
+end
+
+def rigged_roller_mock(n)
+  roller = mock(:DieRoller)
+  roller.stub(:roll).and_return n
+  roller
+end

data/spec/temperature_range_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'temperaturerange'
+
+describe "TemperatureRange" do
+  let(:roller) do
+     avg_roller_mock()
+  end
+
+  subject {TemperatureRange.new(10, [8, 2], [8, 2])}
+
+  it "uses die roller for range construction" do
+    subject.range(roller).should == (4..16)
+  end
+
+  it "handles record highs and lows (including mixtures" do
+    HIGHS_AND_LOWS = {
+      :high => (14..26),
+      [:high, :high] => (24..36),
+      :low => (-6..6),
+      [:low, :low] => (-16..-4),
+      [:high, :low] => (4..16),
+      [:high, :low, :high] => (14..26) }
+
+    HIGHS_AND_LOWS.each { |record, temp_range|
+      subject.range(roller, record) == temp_range }
+  end
+end

data/spec/weathergenerator_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'weathergenerator'
+require 'options'
+
+describe 'WeatherGenerator' do
+  let(:roller) do
+    avg_roller_mock
+  end
+  let(:baseline) do
+    baseline = mock(:BaselineData)
+    baseline.stub(:month) do |m|
+      month = mock(:month)
+      month.stub(:temp_range) { m..m+1 }
+      month
+    end
+    baseline
+  end
+
+  before(:each) do
+    SingleDayWeather.stub(:new) do |m, roller, precip, hilo, terrain|
+      day = mock(:SingleDayWeather)
+      day.stub(:temperature_range) { m.temp_range }
+      day.stub(:record){ hilo }
+      day.stub(:terrain) { terrain }
+      day
+    end
+  end
+
+  it 'creates num_days of weather' do
+    options = WeatherGeneratorOptions.new({:month => 1, :num_days => 13, :dieroller => roller })
+    generator = WeatherGenerator.new baseline, nil, options
+    generator.days.length.should == 13
+  end
+
+  it 'generates weather across month boundaries' do
+    baseline.stub(:num_months) { 2 }
+
+    options = WeatherGeneratorOptions.new({:month => 1, :num_days => 31, :dieroller => roller })
+    generator = WeatherGenerator.new baseline, nil, options
+    generator.days.select {|d| d.temperature_range.begin == 1 }.should have(28).items
+    generator.days.select {|d| d.temperature_range.begin == 2 }.length.should == 3
+  end
+
+  it 'generates days across year boundaries' do
+    baseline.stub(:num_months) { 2 }
+    options = WeatherGeneratorOptions.new({:month => 2, :num_days => 29, :dieroller => roller })
+    generator = WeatherGenerator.new baseline, nil, options
+    generator.days.last.temperature_range.begin.should == 1
+  end
+
+  it 'checks for record high and low' do
+    roller.stub(:roll) { 1 }
+    options = WeatherGeneratorOptions.new({:month => 1, :num_days => 1, :dieroller => roller })
+    generator = WeatherGenerator.new baseline, nil, options
+    generator.days.first.record.should == [:low, :low, :low]
+  end
+
+  it 'uses terrain for precipitation check' do
+    options = WeatherGeneratorOptions.new({:month => 1, :num_days => 1, :dieroller => roller, :terrain => :desert })
+    generator = WeatherGenerator.new baseline, nil, options
+    generator.days.first.terrain.should == :desert
+  end
+end

data/spec/wind_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'wind'
+
+describe Wind do
+  it "does default calculation" do
+    Wind.new(avg_roller_mock).to_s.should == "9SE"
+  end
+end