greyhawkweather 0.0.3

data/test/test_greyhawkweather.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestGreyhawkweather < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def test_truth
+    assert true
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'stringio'
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/greyhawkweather'

data/test/test_month.rb

@@ -0,0 +1,36 @@
+require 'test/unit'
+
+require 'rollers/riggedroller'
+
+require 'month'
+
+class TestMonth < Test::Unit::TestCase
+
+  def setup
+    @null_temp_range = TemperatureRange.new(0, [0, 0], [0, 0])
+    @null_sky_conditions = SkyConditions.new((0..0), (0..0), (0..0))
+  end
+  
+  def test_uses_sky_condition_data_to_determine_current_conditions
+    month = Month.new(@null_temp_range, SkyConditions.new((0..34), (35..65), (66..100)))
+    assert_equal(:clear, month.sky_conditions(RiggedRoller.new(25)))
+    assert_equal(:partly_cloudy, month.sky_conditions(RiggedRoller.new(50)))
+    assert_equal(:cloudy, month.sky_conditions(RiggedRoller.new(75)))
+  end
+  
+  def test_uses_temp_range_data_to_determine_current_conditions
+    month = Month.new(TemperatureRange.new(10, [8, 2], [20, 5]), @null_sky_conditions)
+    assert_equal((0..17), month.temp_range(RiggedRoller.new(5)))
+  end
+  
+  def test_handles_record_high
+    month = Month.new(TemperatureRange.new(10, [8, 2], [20, 5]), @null_sky_conditions)
+    assert_equal((14..23), month.temp_range(RiggedRoller.new(1), :high))
+  end
+  
+  def test_determines_precipitation
+    month = Month.new(@null_temp_range, @null_sky_conditions, 50)
+    assert_equal(true, month.has_precipitation(RiggedRoller.new(10)))
+    assert_equal(false, month.has_precipitation(RiggedRoller.new(70)))
+  end
+end

data/test/test_precipitation.rb

@@ -0,0 +1,26 @@
+require 'test/unit'
+
+require 'precipitationinfo'
+require 'precipitation'
+
+require 'rollers/riggedroller'
+
+class TestPrecipitation < Test::Unit::TestCase
+  def test_has_rainbow
+    precip = Precipitation.new(PrecipitationInfo.create_from_data({ :name => "foo", :chance_of_rainbow => 30}),
+                               RiggedRoller.new(10))
+    assert_equal(true, precip.rainbow?)
+  end
+
+  def test_no_rainbow
+    precip = Precipitation.new(PrecipitationInfo.create_from_data({ :name => "foo", :chance_of_rainbow => 30}),
+                               RiggedRoller.new(40))
+    assert_equal(false, precip.rainbow?)
+  end
+  
+  def test_no_rainbow_if_no_chance_of_it
+    precip = Precipitation.new(PrecipitationInfo.create_from_data({ :name => "foo", :chance_of_rainbow => 0}),
+                               RiggedRoller.new(0))
+    assert_equal(false, precip.rainbow?)
+  end
+end

data/test/test_precipitation_occurance.rb

@@ -0,0 +1,93 @@
+require 'test/unit'
+
+require 'rollers/riggedroller'
+
+require 'precipitationoccurance'
+require 'precipitationinfo'
+
+class TestPrecipitationOccurance < Test::Unit::TestCase
+  def test_returns_array_of_precipitation
+    precip_occur = PrecipitationOccurance.new({ (0..20) => create_precip_info({ :name => :light_snowstorm}),
+                                                (21..100) => create_precip_info({ :name => :light_rainstorm})})
+    assert_instance_of(Array, precip_occur.type(RiggedRoller.new(13)))
+    assert_instance_of(Precipitation, precip_occur.type(RiggedRoller.new(13))[0])
+  end
+
+  def test_determines_precipitation
+    precip_occur = PrecipitationOccurance.new({ (0..20) => create_precip_info({ :name => :light_snowstorm}),
+                                                (21..100) => create_precip_info({ :name => :light_rainstorm})})
+    assert_equal(:light_snowstorm, precip_occur.type(RiggedRoller.new(13))[0].name)
+    assert_equal(:light_rainstorm, precip_occur.type(RiggedRoller.new(57))[0].name)
+  end
+  
+  def test_load_from_file
+    precip_occur = PrecipitationOccurance.load("data/precipitationoccurance.yml")
+    assert_equal("Sleetstorm", precip_occur.type(RiggedRoller.new(22))[0].name)
+  end
+  
+  def test_default_value_is_null_precipitation
+    precip_occur = PrecipitationOccurance.new()
+    assert_equal(NullPrecipitationInfo.new().name, precip_occur.type(RiggedRoller.new(13))[0].name)
+  end
+  
+  def test_checks_for_and_computes_continuing_precipitation
+    precip_occur = PrecipitationOccurance.new({ (0..20) => create_precip_info({ :name => :light_snowstorm, :chance_to_continue => 10}),
+                                                (21..100) => create_precip_info({ :name => :light_rainstorm, :chance_to_continue => 10})})
+    assert_equal([:light_rainstorm, :light_snowstorm, :light_rainstorm, :light_rainstorm],
+                 precip_occur.type(RiggedRoller.new(35, 5, 1, 5, 10, 5, 5, 100)).map{ |p| p.name })
+  end
+  
+  def test_no_reroll_if_temp_range_is_ok
+    precip_occur = PrecipitationOccurance.new({ (0..20) => create_precip_info({ :name => :cold, :min_temp => 0}),
+                                                (21..100) => create_precip_info({ :name => :warm, :min_temp => 30})})
+    assert_equal([:warm], precip_occur.type(RiggedRoller.new(35, 10), 40..50).map{ |p| p.name })
+  end
+
+  def test_reroll_if_temp_is_too_low
+    precip_occur = PrecipitationOccurance.new({ (0..20) => create_precip_info({ :name => :cold, :min_temp => 0}),
+                                                (21..100) => create_precip_info({ :name => :warm, :min_temp => 30})})
+    assert_equal(:cold, precip_occur.type(RiggedRoller.new(35, 10), 10..20)[0].name)
+  end
+  
+  def test_reroll_if_temp_is_too_high
+    precip_occur = PrecipitationOccurance.new({ (0..20) => create_precip_info({ :name => :cold, :max_temp => 30}),
+                                                (21..100) => create_precip_info({ :name => :warm, :max_temp => 50})})
+    assert_equal(:warm, precip_occur.type(RiggedRoller.new(10, 35), 40..60)[0].name)
+  end
+
+  def test_rerolls_once_only_for_bad_weather
+    precip_occur = PrecipitationOccurance.new({ (0..20) => create_precip_info({ :name => :cold, :max_temp => 30})})
+    assert_equal(Precipitation.new(NullPrecipitationInfo.new(), nil).name,
+                 precip_occur.type(RiggedRoller.new(10, 10), 60..70)[0].name)
+  end
+  
+  def test_checks_temp_ranges_for_continuing_weather
+    precip_occur = PrecipitationOccurance.new({ (0..20) => create_precip_info({ :name => :cold, 
+                                                                                :chance_to_continue  => 10,
+                                                                                :max_temp => 20}),
+                                                (21..100) => create_precip_info({ :name => :hot, 
+                                                                                  :chance_to_continue => 10,
+                                                                                  :min_temp => 40})})
+    assert_equal([:hot, :hot],
+                 precip_occur.type(RiggedRoller.new(35, 5, 1, 20), 30..50).map{ |p| p.name })
+  end
+  
+  def test_checks_terrain_for_precipitation
+    precip_occur = PrecipitationOccurance.new({ (0..20) => create_precip_info({ :name => :not, :not_allowed_in => [:desert]})})
+    assert_equal(NullPrecipitationInfo.new().name, precip_occur.type(RiggedRoller.new(10), nil, :desert).first.name)
+  end
+
+  def test_checks_terrain_for_continuin_weather
+    precip_occur = PrecipitationOccurance.new({ (0..20) => create_precip_info({ :name => :cold, 
+                                                                                :chance_to_continue  => 10,
+                                                                                :not_allowed_in => [:desert]}),
+                                                (21..100) => create_precip_info({ :name => :hot, 
+                                                                                  :chance_to_continue => 10 })})
+    assert_equal(:hot, precip_occur.type(RiggedRoller.new(35, 5, 1, 20), nil, :desert)[1].name)
+  end
+
+  private 
+  def create_precip_info(hash)
+    PrecipitationInfo.create_from_data(hash)
+  end
+end

data/test/test_singledayweather.rb

@@ -0,0 +1,61 @@
+require 'test/unit'
+
+require 'singledayweather'
+require 'month'
+
+require 'rollers/avgroller'
+require 'rollers/riggedroller'
+
+class TestWeather < Test::Unit::TestCase
+  def test_temp_range_is_calcuated_by_appropriate_die_rolls
+    assert_equal(5..24, SingleDayWeather.new(create_month, AvgRoller.new).temperature_range)
+  end
+  
+  def test_determines_sky_conditions
+    assert_equal(:partly_cloudy, SingleDayWeather.new(create_month, AvgRoller.new).sky_conditions)
+    assert_equal(:clear, SingleDayWeather.new(create_month, RiggedRoller.new(14)).sky_conditions)
+  end
+  
+  def test_determines_precipitation
+    assert_equal("precip", 
+                 SingleDayWeather.new(create_month, RiggedRoller.new(10), 
+                             PrecipitationOccurance.new({ 0..100 => PrecipitationInfo.new("precip")})).
+                   precipitation[0].name)
+    assert_equal(NullPrecipitationInfo.new().name, 
+                 SingleDayWeather.new(create_month, RiggedRoller.new(70),
+                             PrecipitationOccurance.new({ 0..100 => PrecipitationInfo.new("precip")})).
+                 precipitation[0].name)
+  end
+  
+  def test_deals_with_record_highs
+    assert_equal(24..36, SingleDayWeather.new(create_month, RiggedRoller.new(1),
+                                    PrecipitationOccurance.new(),
+                                    :high).temperature_range)
+  end
+  
+  def test_determines_wind
+    assert_equal("9SE", SingleDayWeather.new(create_month, AvgRoller.new).wind.to_s)
+  end
+  
+  def test_checks_for_temp_ranges_on_weather
+    assert_equal(NullPrecipitationInfo.new().name, 
+                 SingleDayWeather.new(create_month, RiggedRoller.new(10),
+                             PrecipitationOccurance.new({ 0..100 => PrecipitationInfo.create_from_data({ :name => "precip",
+                                                                                                         :min_temp => 100})})).
+                                      precipitation[0].name)
+  end
+  
+  def test_checks_for_terrain_on_precipitation
+    assert_equal(NullPrecipitationInfo.new().name, 
+                 SingleDayWeather.new(create_month, RiggedRoller.new(10),
+                             PrecipitationOccurance.new({ 0..100 => 
+                                                          PrecipitationInfo.create_from_data({ :name => "precip",
+                                                                                               :not_allowed_in => [:desert]})}), nil, :desert).
+                 precipitation[0].name)
+  end
+  
+  private
+  def create_month
+    Month.new(TemperatureRange.new(13, [10,6], [8,4]), SkyConditions.new((01..23), (24..50), (51..100)), 50)
+  end
+end

data/test/test_sky_conditions.rb

@@ -0,0 +1,23 @@
+require 'test/unit'
+
+require 'rollers/riggedroller'
+
+require 'skyconditions'
+
+class TestSkyConditions < Test::Unit::TestCase
+  def test_pick_from_ranges
+    conditions = SkyConditions.new((01..23), (24..50), (51..100))
+    assert_equal(:clear, conditions.condition(RiggedRoller.new(01)))
+    assert_equal(:clear, conditions.condition(RiggedRoller.new(23)))
+    assert_equal(:partly_cloudy, conditions.condition(RiggedRoller.new(24)))
+    assert_equal(:partly_cloudy, conditions.condition(RiggedRoller.new(50)))
+    assert_equal(:cloudy, conditions.condition(RiggedRoller.new(51)))
+    assert_equal(:cloudy, conditions.condition(RiggedRoller.new(99)))
+    assert_equal(:cloudy, conditions.condition(RiggedRoller.new(100)))
+  end
+  
+  def test_zero_equals_hundred
+    conditions = SkyConditions.new((01..23), (24..50), (51..100))
+    assert_equal(:cloudy, conditions.condition(RiggedRoller.new(0)))
+  end
+end

data/test/test_temperature_range.rb

@@ -0,0 +1,30 @@
+require 'test/unit'
+
+require 'rollers/avgroller'
+
+require 'temperaturerange'
+
+class TestTemperaratureRange < Test::Unit::TestCase
+  def test_uses_die_roller_for_range_construction 
+    temp = TemperatureRange.new(10, [8, 4], [10, 4])
+    assert_equal((1..18), temp.range(AvgRoller.new))
+  end
+  
+  def test_handles_record_high
+    temp = TemperatureRange.new(10, [8, 2], [8, 2])
+    assert_equal(14..26, temp.range(AvgRoller.new, :high))
+    assert_equal(24..36, temp.range(AvgRoller.new, [:high,:high]))
+  end
+  
+  def test_handles_record_low
+    temp = TemperatureRange.new(10, [8, 2], [8, 2])
+    assert_equal(-6..6, temp.range(AvgRoller.new, :low))
+    assert_equal(-16..-4, temp.range(AvgRoller.new, [:low,:low]))
+  end
+  
+  def test_handles_mix_of_records
+    temp = TemperatureRange.new(10, [8, 2], [8, 2])
+    assert_equal(4..16, temp.range(AvgRoller.new, [:high,:low]))
+    assert_equal(14..26, temp.range(AvgRoller.new, [:high,:low,:high]))
+  end
+end

data/test/test_weather_generator.rb

@@ -0,0 +1,59 @@
+require 'test/unit'
+
+require 'WeatherGenerator'
+require 'BaselineData'
+
+require 'rollers/avgroller'
+require 'rollers/riggedroller'
+
+class TestBaselineData < BaselineData
+  def initialize (all_data)
+    @all_data = all_data
+  end
+end
+
+class TestWeatherGenerator < Test::Unit::TestCase
+  def setup
+    @testbaseline = TestBaselineData.new [{ :temp_range => TemperatureRange.new(10, [4, 0], [4, 0]),
+                                            :sky_conditions => { :clear => (0..0), :partly => (0..0), :cloudy => (0..0) },
+                                            :precipitation_chance => 40 },
+                                          { :temp_range => TemperatureRange.new(100, [4, 0], [4, 0]),
+                                            :sky_conditions => { :clear => (0..0), :partly => (0..0), :cloudy => (0..0) },
+                                            :precipitation_chance => 70 }]
+    @testprecipchart = PrecipitationOccurance.new({ 0..25 => PrecipitationInfo.create_from_data({ :name => "Rain", :not_allowed_in => [:desert]}),
+                                                    26..50 => PrecipitationInfo.create_from_data({ :name => "Snow"}),
+                                                    51..75 => PrecipitationInfo.create_from_data({ :name => "Hail"}),
+                                                    76..100 => PrecipitationInfo.create_from_data({ :name => "Smog"})})
+  end
+
+  def test_generator_creates_num_days_of_weather
+    generator = WeatherGenerator.new @testbaseline, @testprecipchart, 1, 1, AvgRoller.new
+    assert_equal(1, generator.days.length, "Should have only generated 1 day of weeather")
+    
+    generator = WeatherGenerator.new @testbaseline, @testprecipchart, 1, 13, AvgRoller.new
+    assert_equal(13, generator.days.length, "Should have generated 13 day of weeather")
+  end
+  
+  def test_generated_days_cross_month_boundaries
+    generator = WeatherGenerator.new @testbaseline, @testprecipchart, 1, 31, RiggedRoller.new(1)
+    unique_ranges = generator.days.collect{ |d| d.temperature_range}.uniq
+    assert_equal(2, unique_ranges.length, "Not all ranges should be the same")
+    assert_equal(28, generator.days.select{ |d| d.temperature_range.begin < 50 }.length, "should have 28 items from the first month")
+    assert_equal(3, generator.days.select{ |d| d.temperature_range.begin > 50 }.length, "Should have 3 items from the first month")
+  end
+  
+  def test_months_wrap_around_if_past_end_of_year
+    generator = WeatherGenerator.new @testbaseline, @testprecipchart, 2, 29, RiggedRoller.new(1)
+    assert_equal(true, generator.days.last.temperature_range.begin < 50, "Last one should be first month")
+  end
+
+  def test_checks_for_record_high_low
+    generator = WeatherGenerator.new @testbaseline, @testprecipchart, 1, 1, RiggedRoller.new(1)
+    assert_equal(-3..-1, generator.days.first.temperature_range, "Extreme record low")
+  end
+  
+  def test_uses_terrain_for_precipitation_check
+    generator = WeatherGenerator.new @testbaseline, @testprecipchart, 1, 1, RiggedRoller.new(1), :desert
+    assert_equal(NullPrecipitationInfo.new.name, generator.days.first.precipitation.first.name)
+  end
+end

data/test/test_wind.rb

@@ -0,0 +1,11 @@
+require 'test/unit'
+
+require 'rollers/avgroller'
+
+require 'wind'
+
+class TestWind < Test::Unit::TestCase
+  def test_default_wind_calculation
+    assert_equal("9SE", Wind.new(AvgRoller.new).to_s)
+  end
+end

data/todo.org

@@ -0,0 +1,48 @@
+* Release #1
+Minimum features needed to let me use the tool in my own game
+** DONE determine base temp given the month
+** DONE calc date's temp range given date
+** DONE Need a good way to store/define the baseline data - hardcoded in the baselinedata file is ugly!
+** DONE add a readme file to make github happy.
+** DONE get weather for multiple days
+** DONE remove current 'day' parameter
+** DONE add numdays parameter
+** DONE get weather from beginning of month for that many days
+** DONE handle getting number of days overlapping with another month
+** DONE need to calc current weather condition (sunny/partly-cloudy/cloudy)
+** DONE determine if there is precip for a date
+** DONE add to baseline and add acceptance test.
+** DONE determine if there is record high/low
+** DONE wind speed / direction
+** DONE determine what sort of precip it is
+*** DONE just baseline data of precip
+*** DONE refactor to have array of precip
+*** DONE refactor to have null precip
+*** DONE new Precipitation class seprate from PrecipitationInfo.  New class embodies the actual precipitation
+*** DONE determine continuing precip
+*** DONE determine rainbow
+** DONE standardize output like my sheets
+** DONE check for requirements on precip
+*** DONE temp range
+*** DONE terrain
+** need to calc diff in base temp caused by latitude
+** duration of record high/low
+
+** determine windspeed from precipitation
+
+* fix infinite loop in weather generation (probaly only a problem in tests)
+* need to calc diff in sun-rise/-set time caused by longitude
+* need to calc diff in base temp caused by altitude
+* phase of moons for date
+* sunrise/sunset times for date
+* modify weather given terrain
+* interpret special precipitation (based upon terrain)
+* report wind chill temp
+* report high wind effect table
+* report affects of precip (duration etc.)
+* humidity
+* arbitrary start day
+* greyhawk calendar festivals
+* DONE rearrange code a bit (helper classes in subdirectories etc.)
+* precipitation occurance chart should not be publically a ranged hash?
+* ranged hash sorting is bad stuff (and not yet complete!)

metadata

@@ -0,0 +1,210 @@
+--- !ruby/object:Gem::Specification 
+name: greyhawkweather
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- Mark Simpson
+autorequire: 
+bindir: bin
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDNjCCAh6gAwIBAgIBADANBgkqhkiG9w0BAQUFADBBMRMwEQYDVQQDDAp2ZXJk
+  YW1tZWx0MRUwEwYKCZImiZPyLGQBGRYFZ21haWwxEzARBgoJkiaJk/IsZAEZFgNj
+  b20wHhcNMTAxMjI5MjAxNjI3WhcNMTExMjI5MjAxNjI3WjBBMRMwEQYDVQQDDAp2
+  ZXJkYW1tZWx0MRUwEwYKCZImiZPyLGQBGRYFZ21haWwxEzARBgoJkiaJk/IsZAEZ
+  FgNjb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDQQsRTtwd0rN0X
+  ffw6plu3tUBiGXpRGWOlIZq6xjyAjjvmwMWnmwU5juNBlPJZzYiMmCIC821s3fgb
+  TM69f/cgqeevyI/h4Soxl2Le8NVGSeyvaZSNM8s1n9EQ5kN7VogYD0DbB4kHlfCM
+  JgD72juXiAKXnsXH8NvcBXCkoPiq7CjDJCmrqilTu1atELmP5RJ/Vm+Nt2odVDF5
+  t2x2ANmLVOZn59BTvHNXYbwrCIs82W4SwOSF4wL/I5ElH7dzr8PZN1yNBZPHtxpe
+  +4eTt6c4+DSP+rCOjLxBQxGPemY54zVawVtg4LjE/oOaAri99hz1Nl+PLgXg+oEP
+  veV2pcnDAgMBAAGjOTA3MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQW
+  BBTJ6wHlTv0Ievjg5o1zGil1w639SjANBgkqhkiG9w0BAQUFAAOCAQEAfXKfM9vA
+  u1ukuGjhd4mej3Daw8bnaX2URwy5/4ogP5+9rK+WTni5UpS09ksvN/I/PWnfwNWE
+  kzV0tl0DvQMpz+obpw02pt1uEzAHyPOYDGrgRweVaJbvrH2G3xAkSBwfkaDlzSrk
+  KomP5Nct1Nnkmg0mAAGjvS/ib3GbEANt8qSP6hfn6vEXMUnhnCmo69dbdqDwVDOJ
+  FVV9Kd1o7T8NmmDdn+G26uPPAX5EeJtyB1rV6pSPkQW99opIKcz6iEPNkAtVniwM
+  AM5LT+EO74YD568fpYjJUw+T4/TsPJBWyU/f21QoaRXI+x3VNSEqDZEf67Lsp2Ew
+  rPnJW2hNpPLFrA==
+  -----END CERTIFICATE-----
+
+date: 2010-12-29 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rangehash
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 29
+        segments: 
+        - 0
+        - 0
+        - 1
+        version: 0.0.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rubyforge
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 0
+        - 4
+        version: 2.0.4
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: gemcutter
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 0
+        - 6
+        - 1
+        version: 0.6.1
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 2
+        - 5
+        - 0
+        version: 2.5.0
+  type: :development
+  version_requirements: *id004
+description: |-
+  This program will assist in the generation of randomized weather for
+  the Greyhawk AD&D Campaign setting.  It uses data from the Greyhawk
+  Boxed set (circa 1983) for AD&D 1e.
+  
+  The todo.org file lists the "stories" for this project in prioritzed
+  order. If a story is marked DONE then it is in theory working.
+email: 
+- verdammelt@gmail.com
+executables: 
+- greyweathergen
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+- Rakefile
+- bin/greyweathergen
+- data/baselinedata.yml
+- data/precipitationoccurance.yml
+- lib/baselinedata.rb
+- lib/greyhawkweather.rb
+- lib/greyhawkweathergenerator.rb
+- lib/month.rb
+- lib/precipitation.rb
+- lib/precipitationinfo.rb
+- lib/precipitationoccurance.rb
+- lib/singledayweather.rb
+- lib/skyconditions.rb
+- lib/temperaturerange.rb
+- lib/util/dieroller.rb
+- lib/weathergenerator.rb
+- lib/wind.rb
+- script/console
+- script/destroy
+- script/generate
+- test/rollers/avgroller.rb
+- test/rollers/riggedroller.rb
+- test/test_acceptance.rb
+- test/test_dieroller.rb
+- test/test_greyhawkweather.rb
+- test/test_helper.rb
+- test/test_month.rb
+- test/test_precipitation.rb
+- test/test_precipitation_occurance.rb
+- test/test_singledayweather.rb
+- test/test_sky_conditions.rb
+- test/test_temperature_range.rb
+- test/test_weather_generator.rb
+- test/test_wind.rb
+- todo.org
+has_rdoc: true
+homepage: http://github.com/verdammelt/Greyhawk-Weather
+licenses: []
+
+post_install_message: PostInstall.txt
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: greyhawkweather
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: This program will assist in the generation of randomized weather for the Greyhawk AD&D Campaign setting
+test_files: 
+- test/test_acceptance.rb
+- test/test_dieroller.rb
+- test/test_greyhawkweather.rb
+- test/test_helper.rb
+- test/test_month.rb
+- test/test_precipitation.rb
+- test/test_precipitation_occurance.rb
+- test/test_singledayweather.rb
+- test/test_sky_conditions.rb
+- test/test_temperature_range.rb
+- test/test_weather_generator.rb
+- test/test_wind.rb