greyhawkweather 0.0.3

data/lib/month.rb

@@ -0,0 +1,25 @@
+require 'skyconditions'
+require 'temperaturerange'
+
+class Month
+  def initialize(temp_range = TemperatureRange.new(0, [0, 0], [0, 0]), 
+                 conditions = SkyConditions.new((0..100), (100..100), (100..100)), 
+                 precipitation_chance = 0)
+    @temp_range = temp_range
+    @sky_condition = conditions
+    @precipitation_chance = precipitation_chance
+  end
+  
+  def sky_conditions (dieroller)
+    @sky_condition.condition(dieroller)
+  end
+  
+  def temp_range (dieroller, record_temp=nil)
+    @temp_range.range(dieroller, record_temp)
+  end
+  
+  def has_precipitation (dieroller)
+    @precipitation_chance >= dieroller.roll(100)
+  end
+end
+

data/lib/precipitation.rb

@@ -0,0 +1,16 @@
+class Precipitation
+  attr_reader :name
+  def initialize(info, dieroller)
+    @name = info.name
+    @chance_for_rainbow = info.chance_of_rainbow
+    @roller = dieroller
+  end
+  
+  def rainbow?
+    @chance_for_rainbow > 0 && @roller.roll(100) <= @chance_for_rainbow
+  end
+
+  def to_s
+    "[#{@name}; rainbow: #{rainbow?}]"
+  end
+end

data/lib/precipitationinfo.rb

@@ -0,0 +1,32 @@
+class PrecipitationInfo
+  attr_reader :name
+  attr_reader :min_temp
+  attr_reader :max_temp
+  attr_reader :chance_to_continue
+  attr_reader :chance_of_rainbow
+  attr_reader :not_allowed_in
+
+  def self.create_from_data(arg_hash)
+    PrecipitationInfo.new(arg_hash[:name], 
+                          arg_hash[:min_temp], 
+                          arg_hash[:max_temp], 
+                          arg_hash[:chance_to_continue], 
+                          arg_hash[:chance_of_rainbow], 
+                          arg_hash[:not_allowed_in])
+  end
+  
+  def initialize(name, min_temp=nil, max_temp=nil, chance_to_continue=0, chance_of_rainbow=0, not_allowed_in=[])
+    @name = name
+    @min_temp = min_temp
+    @max_temp = max_temp
+    @chance_to_continue = chance_to_continue || 0
+    @chance_of_rainbow = chance_of_rainbow || 0
+    @not_allowed_in = not_allowed_in || []
+  end
+end
+
+class NullPrecipitationInfo < PrecipitationInfo
+  def initialize()
+    super "No Precipitation"
+  end
+end

data/lib/precipitationoccurance.rb

@@ -0,0 +1,83 @@
+require 'YAML'
+
+require 'rangehash'
+
+require 'precipitationinfo'
+require 'precipitation'
+
+class PrecipitationOccurance < RangeHash
+  def self.load(file)
+    data = YAML.load_file(file)
+    data.each_pair { |k, v| data[k] = PrecipitationInfo.create_from_data(v)}
+    PrecipitationOccurance.new(data)
+  end
+
+  def initialize(args = nil)
+    super args, NullPrecipitationInfo.new()
+  end
+  
+  def type(dieroller, temp_range = nil, terrain = :plains)
+    get_all_precip initial_precip(dieroller, temp_range, terrain), dieroller, temp_range, terrain
+  end
+  
+  private
+  def invalid_precip?(precip_info, temp_range, terrain)
+    (temp_range and 
+      ((precip_info.min_temp and !(precip_info.min_temp <= temp_range.last)) or
+       (precip_info.max_temp and !(precip_info.max_temp >= temp_range.first)))) or
+      (terrain and precip_info.not_allowed_in.include?(terrain))
+  end
+
+  def initial_precip (dieroller, temp_range, terrain)
+    precip_info = self[dieroller.roll(100)]
+
+    if invalid_precip?(precip_info, temp_range, terrain)
+        precip_info = self[dieroller.roll(100)]
+        
+      if invalid_precip?(precip_info, temp_range, terrain)
+          precip_info = NullPrecipitationInfo.new()
+      end
+    end
+    precip_info
+  end
+
+  def get_all_precip (precip_info, dieroller, temp_range, terrain)
+    all_precip = Array.new().push(Precipitation.new(precip_info, dieroller))
+
+    while precip_continues?(dieroller, precip_info)
+      next_precip_info = next_precip_info(dieroller, precip_info)
+      precip_info = next_precip_info unless invalid_precip?(next_precip_info, temp_range, terrain)
+      all_precip.push(Precipitation.new(precip_info, dieroller))
+    end
+
+    all_precip
+  end
+
+  def precip_continues?(dieroller, precip_info)
+    precip_info.chance_to_continue > 0 && 
+      dieroller.roll(100) <= precip_info.chance_to_continue
+  end
+
+  def next_precip_info(dieroller, precip_info)
+    continue_roll = dieroller.roll(10)
+    return line_above(precip_info) if continue_roll == 1
+    return line_below(precip_info) if continue_roll == 10
+    precip_info
+  end
+
+  def line_above(precip_info)
+    prev_key = sorted_keys[[0,index_of_precip(precip_info)-1].max]
+    @key_value_hash[prev_key]
+  end
+  
+  def line_below(precip_info)
+    next_key = sorted_keys[[sorted_keys.length,index_of_precip(precip_info)+1].min]
+    @key_value_hash[next_key]
+  end
+  
+  def index_of_precip(precip_info)
+    key = @key_value_hash.index(precip_info)
+    index_of_key = sorted_keys.index(key)
+  end
+  
+end

data/lib/singledayweather.rb

@@ -0,0 +1,29 @@
+require 'month'
+require 'precipitationoccurance'
+require 'precipitationinfo'
+require 'wind'
+
+class SingleDayWeather
+  attr_reader :temperature_range
+  attr_reader :sky_conditions
+  attr_reader :precipitation
+  attr_reader :wind
+  
+  def initialize (month, dieroller, 
+                  precipitation_occurance_chart=PrecipitationOccurance.new({ 0..100 => NullPrecipitationInfo.new() }),
+                  record_temp=nil,
+                  terrain = :plains)
+    @temperature_range = month.temp_range(dieroller, record_temp)
+    @sky_conditions = month.sky_conditions(dieroller)
+    @record_temp = record_temp
+    @precipitation =
+      precipitation_occurance_chart.type(month.has_precipitation(dieroller) ? dieroller : NullDieRoller.new(),
+                                         @temperature_range, terrain)
+    @wind = Wind.new(dieroller)
+  end
+  
+  def inspect
+    "#{@record_temp} #{@temperature_range} #{@sky_conditions} #{@precipitation} #{@wind}"
+  end
+end
+

data/lib/skyconditions.rb

@@ -0,0 +1,15 @@
+require 'rangehash'
+
+class SkyConditions
+  def initialize (clear_range, partly_range, cloudy_range)
+    hash = { clear_range => :clear, partly_range => :partly_cloudy, cloudy_range => :cloudy}
+    @condition_ranges = RangeHash.new(hash , :none)
+  end
+  
+  def condition(roller)
+    roll = roller.roll(100)
+    roll = 100 if roll == 0
+    @condition_ranges[roll]
+  end
+end
+

data/lib/temperaturerange.rb

@@ -0,0 +1,26 @@
+class TemperatureRange
+  def initialize (base, high_adj, low_adj)
+    @base = base
+    @high_adj = high_adj
+    @low_adj = low_adj
+  end
+  
+  def range (roller, record=nil)
+    base = calculate_todays_base(record)
+    (base - roller.roll(@low_adj[0], @low_adj[1])..base+ roller.roll(@high_adj[0], @high_adj[1]))
+  end
+  
+  private
+  def calculate_todays_base(record)
+    record = make_record_array record
+
+    base = @base
+    base = base + (record.find_all{ |r| r == :high}.length * (@high_adj[0] + @high_adj[1]))
+    base = base - (record.find_all{ |r| r == :low}.length * (@low_adj[0] + @low_adj[1]))
+    base
+  end
+  
+  def make_record_array(record)
+    ((record.class == Array) ? record : [record])
+  end
+end

data/lib/util/dieroller.rb

@@ -0,0 +1,11 @@
+class DieRoller
+  def roll(nSides, modifier=0)
+    rand(nSides) + 1 + modifier
+  end
+end
+
+class NullDieRoller
+  def roll(nSides, modifier=0)
+    -1
+  end
+end

data/lib/weathergenerator.rb

@@ -0,0 +1,44 @@
+require 'singledayweather'
+
+class WeatherGenerator
+  attr_reader :days
+
+  def initialize (baselinedata, precipitation_occurance_chart, month_index, num_days, dieroller, terrain = :plains)
+    month_for_each_day = make_months_for_days_array(baselinedata, month_index, num_days)
+    @days = month_for_each_day.map { |month| make_weather month, dieroller, precipitation_occurance_chart, terrain}
+  end
+  
+  private
+  def make_months_for_days_array(baselinedata, month_index, num_days)
+    months = Array.new
+    while num_days > 0
+      if (num_days > 28)
+        28.times { months.push baselinedata.month(month_index) }
+        num_days -= 28
+        month_index += 1
+        if month_index > baselinedata.num_months
+          month_index = 1
+        end
+      else
+        num_days.times { months.push baselinedata.month(month_index) }
+        num_days = 0
+      end
+    end
+    months
+  end
+
+  def make_weather(month, dieroller, precipitation_occurance_chart, terrain)
+    SingleDayWeather.new(month, dieroller, precipitation_occurance_chart, check_record_high_low(dieroller), terrain)
+  end
+  
+  def check_record_high_low(dieroller)
+    record_high_low_range = RangeHash.new({ 1 => [:low, :low, :low],
+                                          2 => [:low, :low],
+                                          3..4 => :low,
+                                          97..98 => :high,
+                                          99 => [:high, :high],
+                                          100 => [:high, :high, :high]},
+                                          :normal)
+    record_high_low_range[dieroller.roll(100)]
+  end
+end

data/lib/wind.rb

@@ -0,0 +1,11 @@
+
+class Wind
+  def initialize(dieroller)
+    @speed = dieroller.roll(20, -1)
+    @direction = [:N, :NE, :E, :SE, :S, :SW, :W, :NW][dieroller.roll(8, -1)]
+  end
+  
+  def to_s
+    @speed.to_s + @direction.to_s
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/greyhawkweather.rb'}"
+puts "Loading greyhawkweather gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/test/rollers/avgroller.rb

@@ -0,0 +1,7 @@
+require 'util/dieroller'
+
+class AvgRoller < DieRoller
+  def roll(nsides, modifier=0)
+    return nsides/2 + modifier
+  end
+end

data/test/rollers/riggedroller.rb

@@ -0,0 +1,11 @@
+require 'util/dieroller'
+
+class RiggedRoller < DieRoller
+  def initialize(*rolls)
+    @last_roll = rolls.pop
+    @rolls = rolls.reverse
+  end
+  def roll(nSides, modifier=0)
+    (@rolls.pop || @last_roll) + modifier
+  end
+end

data/test/test_acceptance.rb

@@ -0,0 +1,36 @@
+require 'test/unit'
+
+require 'rollers/avgroller'
+require 'rollers/riggedroller'
+
+require 'greyhawkweathergenerator'
+
+class TestAcceptanceTests < Test::Unit::TestCase
+  def test_generate_weather_for_three_days_in_planting
+    weather_generator = GreyhawkWeatherGenerator.create_weather_generator(4, 3, AvgRoller.new)
+    assert_equal(3, weather_generator.days.length, "should have generated 3 days")
+  end
+
+  def test_generate_weather_for_planting
+    weather_generator = GreyhawkWeatherGenerator.create_weather_generator(4, 1, AvgRoller.new)
+    weather = weather_generator.days[0]
+    assert_equal(44..63, weather.temperature_range)
+    assert_equal(:partly_cloudy, weather.sky_conditions)
+    assert_equal(NullPrecipitationInfo.new().name, weather.precipitation[0].name)
+  end
+
+  def test_generate_weather_for_goodmonth
+    weather_generator = GreyhawkWeatherGenerator.create_weather_generator(8, 1, AvgRoller.new)
+    weather = weather_generator.days[0]
+    assert_equal(66..83, weather.temperature_range)
+    assert_equal(:partly_cloudy, weather.sky_conditions)
+    assert_equal(NullPrecipitationInfo.new().name, weather.precipitation[0].name)
+  end
+  
+  def test_generate_weather_with_terrain
+    weather_generator = GreyhawkWeatherGenerator.create_weather_generator(1, 1, RiggedRoller.new(30), :desert)
+    weather = weather_generator.days[0]
+    # without terrain the above would generate "Fog, Heavy" for precipitation
+    assert_equal(NullPrecipitationInfo.new().name, weather.precipitation[0].name)
+  end
+end

data/test/test_dieroller.rb

@@ -0,0 +1,30 @@
+require 'test/unit'
+
+require 'util/dieroller'
+
+$next_defined_random_number = 0
+$max_arg_to_rand = -1
+
+def rand (max=0)
+  $max_arg_to_rand = max
+  $next_defined_random_number
+end
+
+class TestDieRoller < Test::Unit::TestCase
+  def test_D6
+    $next_defined_random_number = 3
+    assert_equal(4, DieRoller.new.roll(6), "should return random number (+1)")
+    assert_equal(6, $max_arg_to_rand, "should have defined 6 as maximum number to rand")
+  end
+  
+  def test_is_1_to_N_range
+    $next_defined_random_number = 0
+    assert_equal(1, DieRoller.new.roll(6), "should use 1..N range")
+  end
+
+  def test_applies_modifier_if_given
+    $next_defined_random_number = 1
+    assert_equal(4, DieRoller.new.roll(6, +2), "Should have added the +2")
+    assert_equal(-1, DieRoller.new.roll(6, -3), "Should have added the -3")
+  end
+end