VanaTime 2.0.0 → 2.1.0

data/lib/Vana/moon_countdown.rb

@@ -1,67 +1,64 @@
 module FFXI
-  class VanaMoonCountdown
-    include FFXI::Constants
-    include FFXI::Common
-    include Observable
+ class VanaMoonCountdown < Util::RubyBean
+  include FFXI::Constants
+  include FFXI::Common
 
-    def initialize(moon)
-      self.moon = moon
-    end
+  property :next_phase_countdown, :optimal_phase_countdown
+  property :next_phase_countdown_string, :optimal_phase_countdown_string
 
-    def moon=(moon)
-      raise "Input needs to be a VanaMoon object" if ! moon.is_a? VanaMoon
-      @moon = moon
-      if @moon.earth_time != @earth_time
-        self.earth_time = @moon.earth_time
-      end
-    end
+  alias to_next next_phase_countdown_string
+  alias to_optimal optimal_phase_countdown_string
 
-    def earth_time=(earth_time)
-      raise "Input needs to be a Time object" if ! earth_time.is_a? Time
-
-      if earth_time != @earth_time
-        @earth_time = earth_time
-        localtime = (@earth_time.to_f * 1000).to_i
-        @elapsed_time = (localtime - MS_MOON_DATE.to_i) % MS_GAME_DAY
+  def initialize(opts={})
+   super()
+   add_listener(opts[:listener]) if opts[:listener]
+   update_moon(opts[:moon]) if opts[:moon]
+  end
 
-        set_countdowns
-      end
-    end
+  def update_moon(moon)
+   raise "Input needs to be a VanaMoon object" if ! moon.is_a? VanaMoon
 
-    attr_reader :to_next_array, :to_optimal_array
-    attr_reader :elapsed_time, :earth_time
+   @next_phase_target = moon.next_phase_target
+   @optimal_phase_target = moon.optimal_phase_target
+   @moon_days = moon.moon_days
 
-    def to_next
-      format_countdown(@to_next_array)
-    end
+   update_earth_time moon.earth_time
+  end
 
-    def to_optimal
-      format_countdown(@to_optimal_array)
-    end
+  def update_earth_time(earth_time)
+   raise "Input needs to be a Time object" if ! earth_time.is_a? Time
 
-    private
+   @earth_time = earth_time
+   localtime = (@earth_time.to_f * 1000).to_i
+   @elapsed_time = (localtime - MS_MOON_DATE.to_i) % MS_GAME_DAY
 
-    def set_countdowns
-      to_next_array = countdown_to(@moon.next_phase_target)
+   update_countdowns if @moon_days
+  end
 
-      if to_next_array != @to_next_array
-        @to_next_array = to_next_array
-        changed
-        notify_observers("next_phase_countdown", self)
-      end
+  def update_vana_time(vt)
+   if vt.is_a? VanaTime
+    update_earth_time(vt.earth_time)
+   else
+    update_earth_time(FFXI::Common.vana_to_earth(vt))
+   end
+  end
 
-      to_optimal_array = countdown_to(@moon.optimal_phase_target)
+  attr_reader :elapsed_time, :earth_time
 
-      if to_optimal_array != @to_optimal_array
-        @to_optimal_array = to_optimal_array
-        changed
-        notify_observers("optimal_phase_countdown", self)
-      end
-    end
+  private
 
-    def countdown_to(target)
-      countdown((target - @moon.moon_days) * MS_GAME_DAY - @elapsed_time)
-    end
+  def update_countdowns
+   self.next_phase_countdown = countdown_to(@next_phase_target)
+   self.next_phase_countdown_string =
+    format_countdown(next_phase_countdown)
+   self.optimal_phase_countdown = countdown_to(@optimal_phase_target)
+   self.optimal_phase_countdown_string =
+    format_countdown(optimal_phase_countdown)
+  end
 
+  def countdown_to(target)
+   countdown((target - @moon_days) * MS_GAME_DAY - @elapsed_time)
   end
-end
+
+ end
+end

data/lib/Vana/skillup_calculator.rb

@@ -0,0 +1,142 @@
+module FFXI
+ class SkillupCalculator < Util::RubyBean
+  include FFXI::Constants
+
+  property :day_crystal_factor, :moon_phase_factor, :base_difficulty
+  property :skillup_difficulty
+
+  def initialize(opts={})
+   super()
+
+   add_listener(opts[:listener]) if opts[:listener]
+
+   @recipe_cap = opts[:recipe_cap] || 0
+   @skill = opts[:skill] || 0
+   update_base_difficulty
+
+   @crystal_element = opts[:crystal_element] if opts[:crystal_element]
+
+   if opts[:vana_day] and opts[:vana_moon]
+    update_day_and_moon(opts[:vana_day], opts[:vana_moon])
+   end
+  end
+
+  def update_day_and_moon(vanaday, vanamoon)
+   if (! vanaday.is_a? VanaDay) || (! vanamoon.is_a? VanaMoon)
+    raise "invalid input. initialize with a VanaDay and VanaMoon object"
+   end
+
+   @day_element = vanaday.day_element
+   @moon_percent = vanamoon.moon_percent
+
+   if @day_element and @moon_percent
+    update_moon_phase_factor
+
+    if ! @crystal_element.nil?
+     update_day_crystal_factor
+     update_skillup_difficulty
+    end
+   end
+  end
+
+  def crystal_element=(element)
+   @crystal_element = element
+
+   if ! @day_element.nil?
+    update_day_crystal_factor
+    update_skillup_difficulty
+   end
+  end
+
+  def recipe_cap=(cap)
+   if @recipe_cap != cap
+    @recipe_cap = cap
+    update_base_difficulty
+    update_skillup_difficulty if ! @crystal_element.nil?
+   end
+  end
+
+  def skill=(skill)
+   if @skill != skill
+    @skill = skill
+    update_base_difficulty
+    update_skillup_difficulty if ! @crystal_element.nil?
+   end
+  end
+
+  attr_reader :crystal_element, :recipe_cap, :skill
+
+  private
+
+  def build_difficulty_hash(type)
+   sum_of_factors = self.base_difficulty - (self.moon_phase_factor +
+     self.day_crystal_factor)
+
+   case type
+   when :success
+    direction = @crystal_element.direction
+    direction_modifier = 0.5
+   when :quality
+    estr = ElementFactory.send "#{@crystal_element.strength}"
+    direction = estr.direction
+    direction_modifier = -0.5
+   when :neutral
+    direction = "Neutral"
+    direction_modifier = 0.0
+   end
+
+   difficulty_hash = {:direction => direction}
+
+   [[:advanced_support, 2], [:free_support, 1], [:no_support, 0]].each do |s,m|
+    support = s
+    support_modifier = m
+
+    difficulty_hash[support] =
+     (sum_of_factors - direction_modifier - support_modifier)
+   end
+
+   difficulty_hash
+  end
+
+  def update_skillup_difficulty
+   success = build_difficulty_hash(:success)
+   neutral = build_difficulty_hash(:neutral)
+   quality = build_difficulty_hash(:quality)
+
+   self.skillup_difficulty = {
+    :success => success,
+    :neutral => neutral,
+    :quality => quality
+   }
+  end
+
+  def update_base_difficulty
+   self.base_difficulty = @recipe_cap - @skill
+  end
+
+  def update_moon_phase_factor
+   self.moon_phase_factor = (@moon_percent.abs - 50.0) / 50
+  end
+
+  def update_day_crystal_factor
+   raise "@crystal_element is unset" if @crystal_element.nil?
+
+   day_element = @day_element.name
+   day_strength = @day_element.strength
+   crystal_element = @crystal_element.name
+
+   if day_element == "Light" and crystal_element != "Darkness"
+    self.day_crystal_factor = 1
+   elsif day_element == "Darkness" and crystal_element != "Light"
+    self.day_crystal_factor = -1
+   elsif day_element == crystal_element
+    self.day_crystal_factor = 1
+   elsif day_strength == crystal_element
+    self.day_crystal_factor = -1
+   else
+    self.day_crystal_factor = 0
+   end
+  end
+
+ end
+end

data/lib/Vana/time.rb

@@ -1,113 +1,101 @@
 module FFXI
-  class VanaTime
-    include FFXI::Constants
-    include FFXI::Common
-    include Observable
-
-    def initialize(time = nil)
-      self.earth_time = time if ! time.nil?
-    end
-
-    def self.at(vt)
-      self.new(Time.at(FFXI::Common.vana_to_earth(vt)))
-    end
-
-    def self.now
-      self.new(Time.now)
-    end
-
-    def earth_time=(time)
-      raise "input needs to be a Time object" if ! time.is_a? Time
-      @earth_time = time
-      vt = FFXI::Common.earth_to_vana(time)
-      set_instance_variables(vt)
-    end
-
-    def vana_time=(vt)
-      @earth_time = Time.at(FFXI::Common.vana_to_earth(vt))
-      set_instance_variables(vt)
-    end
-
-    attr_reader :hour, :minute, :second
-    attr_reader :date, :month, :year, :tomorrow
-    attr_reader :hour_start, :minute_start, :second_start
-    attr_reader :date_start, :month_start, :year_start
-    attr_reader :vana_time, :earth_time
-
-    def to_i
-      @vana_time.to_i
-    end
-
-    def to_f
-      @vana_time.to_f
-    end
-
-    def time_string
-      "#{"%02d" % hour}:#{"%02d" % minute}:#{"%02d" % second}"
-    end
-
-    def date_string
-      "#{year}-#{"%02d" % month}-#{"%02d" % date}"
-    end
-
-    def to_s
-      "#{date_string} #{time_string}"
-    end
-
-    private
-
-    def set_instance_variables(vt)
-      @vana_time = vt.to_f
-
-      set_year if year_has_passed_since(@year_start, @vana_time)
-      set_month if month_has_passed_since(@month_start, @vana_time)
-      set_date if day_has_passed_since(@date_start, @vana_time)
-      set_hour if hour_has_passed_since(@hour_start, @vana_time)
-      set_minute if minute_has_passed_since(@minute_start, @vana_time)
-      set_second if second_has_passed_since(@second_start, @vana_time)
-    end
-
-    def set_year
-      @year = (@vana_time.to_f / MS_YEAR).to_i
-      @year_start = start_of_period(@vana_time, MS_YEAR)
-      changed
-      notify_observers(MS_YEAR, self)
-    end
-
-    def set_month
-      @month = (((@vana_time.to_f % MS_YEAR) / MS_MONTH) + 1).to_i
-      @month_start = start_of_period(@vana_time, MS_MONTH)
-      changed
-      notify_observers(MS_MONTH, self)
-    end
-
-    def set_date
-      @date = (((@vana_time.to_f % MS_MONTH) / MS_DAY) + 1).to_i
-      @date_start = start_of_period(@vana_time, MS_DAY)
-      @tomorrow = @date_start.to_f + MS_DAY
-      changed
-      notify_observers(MS_DAY, self)
-    end
-
-    def set_hour
-      @hour = ((@vana_time % MS_DAY) / MS_HOUR).to_i
-      @hour_start = start_of_period(@vana_time, MS_HOUR)
-      changed
-      notify_observers(MS_HOUR, self)
-    end
-
-    def set_minute
-      @minute = ((@vana_time % MS_HOUR) / MS_MINUTE).to_i
-      @minute_start = start_of_period(@vana_time, MS_MINUTE)
-      changed
-      notify_observers(MS_MINUTE, self)
-    end
-
-    def set_second
-      @second = ((@vana_time % MS_MINUTE) / MS_SECOND).to_i
-      @second_start = start_of_period(@vana_time, MS_SECOND)
-      changed
-      notify_observers(MS_SECOND, self)
-    end
+ class VanaTime < Util::RubyBean
+  include FFXI::Constants
+  include FFXI::Common
+
+  property :hour, :minute, :second
+  property :hour_start, :minute_start, :second_start
+  property :date, :month, :year, :tomorrow
+  property :date_start, :month_start, :year_start
+  property :earth_time, :vana_time
+  property :time_string, :date_string
+
+  def initialize(opts={})
+   super()
+   add_listener(opts[:listener]) if opts[:listener]
+   update_earth_time(opts[:earth_time]) if opts[:earth_time]
   end
+
+  def self.at(vt, listener = nil)
+   opts = {:earth_time => Time.at(FFXI::Common.vana_to_earth(vt))}
+   opts[:listener] = listener if listener
+   self.new(opts)
+  end
+
+  def self.now(listener = nil)
+   opts = {:earth_time => Time.now}
+   opts[:listener] = listener if listener
+   self.new(opts)
+  end
+
+  def update_earth_time(time)
+   raise "input needs to be a Time object" if ! time.is_a? Time
+   self.earth_time = time
+   vt = FFXI::Common.earth_to_vana(time)
+   set_properties(vt)
+  end
+
+  def update_vana_time(vt)
+   self.earth_time = Time.at(FFXI::Common.vana_to_earth(vt))
+   set_properties(vt)
+  end
+
+  def to_i
+   vana_time.to_i
+  end
+
+  def to_f
+   vana_time.to_f
+  end
+
+  def to_s
+   "#{date_string} #{time_string}"
+  end
+
+  private
+
+  def set_properties(vt)
+   self.vana_time = vt.to_f
+
+   set_year if year_has_passed_since(year_start, vana_time)
+   set_month if month_has_passed_since(month_start, vana_time)
+   set_date if day_has_passed_since(date_start, vana_time)
+   set_hour if hour_has_passed_since(hour_start, vana_time)
+   set_minute if minute_has_passed_since(minute_start, vana_time)
+   set_second if second_has_passed_since(second_start, vana_time)
+  end
+
+  def set_year
+   self.year = (vana_time.to_f / MS_YEAR).to_i
+   self.year_start = start_of_period(vana_time, MS_YEAR)
+  end
+
+  def set_month
+   self.month = (((vana_time.to_f % MS_YEAR) / MS_MONTH) + 1).to_i
+   self.month_start = start_of_period(vana_time, MS_MONTH)
+  end
+
+  def set_date
+   self.date = (((vana_time.to_f % MS_MONTH) / MS_DAY) + 1).to_i
+   self.date_start = start_of_period(vana_time, MS_DAY)
+   self.tomorrow = date_start.to_f + MS_DAY
+   self.date_string = "#{year}-#{"%02d" % month}-#{"%02d" % date}"
+  end
+
+  def set_hour
+   self.hour = ((vana_time % MS_DAY) / MS_HOUR).to_i
+   self.hour_start = start_of_period(vana_time, MS_HOUR)
+  end
+
+  def set_minute
+   self.minute = ((vana_time % MS_HOUR) / MS_MINUTE).to_i
+   self.minute_start = start_of_period(vana_time, MS_MINUTE)
+  end
+
+  def set_second
+   self.second = ((vana_time % MS_MINUTE) / MS_SECOND).to_i
+   self.second_start = start_of_period(vana_time, MS_SECOND)
+   self.time_string = "#{"%02d" % hour}:#{"%02d" % minute}:#{"%02d" % second}"
+  end
+ end
 end