VanaTime 1.2.1 → 2.0.0

data/CHANGELOG

@@ -1,3 +1,8 @@
+== 2.0.0 / 2007-09-08
+
+* rewritten to support a callback based arch, added element information,
+  moved moon phase countdowns into their own class
+
 == 1.2.1 / 2007-09-02
 
 * fixed a silly typo describing the waxing gibbous moon phase. This corrects the

data/Manifest

@@ -2,8 +2,12 @@ README
 Manifest
 LICENSE
 lib/vana_time.rb
+lib/Vana/time_manager.rb
 lib/Vana/time.rb
+lib/Vana/moon_countdown.rb
 lib/Vana/moon.rb
+lib/Vana/element.rb
 lib/Vana/day.rb
 lib/Vana/constants.rb
+lib/Vana/common.rb
 CHANGELOG

data/README

@@ -1,7 +1,7 @@
-VanaTime 1.1.0 README
+VanaTime 2.0.0 README
 =====================
 
-This document was last updated on Thu Aug 30 22:58:05 EDT 2007.
+This document was last updated on Sat Sep  8 13:41:50 EDT 2007.
 
 
 Introduction to VanaTime
@@ -16,14 +16,48 @@ VanaTime is a work in progress and the API may change from time to time...
 you may want to use explicit versioning in any code depending on it.
 
 
+FFXI::TimeManager
+=================
+
+This will probably be the only class you end up using. It wraps everything
+else up in a convenient callback system that keeps things in sync, only
+does updates when necessary, and fires off your code on events. Huzzah! Here's
+a quick example text clock:
+
+include FFXI::Constants
+tm = FFXI::TimeManager.now
+tm.callback(MS_SECOND) {|time| puts "Vana'diel Time: #{time}" }
+loop {tm.earth_time=(Time.now) ; sleep 0.04}
+
+If you want to manage existing VanaTime, VanaDay, and VanaMoon objects you
+can create a blank TimeManager and call manage on them:
+
+tm = FFXI::TimeManager.new
+tm.manage(time, day, moon)
+
+The following are the supported events for adding callbacks:
+
+MS_SECOND
+MS_MINUTE
+MS_HOUR
+MS_DAY
+MS_MONTH
+MS_YEAR
+day (of the week, fires off seperately from MS_DAY)
+moon_days
+moon_percent
+moon_phase
+next_optimal_phase
+next_phase_countdown
+optimal_phase_countdown
+
 FFXI::VanaTime API
 ==================
 
   * new(Time)
-      accepts a Time object to initialize a new VanaTime, using the current
-      time if no Time object is passed
+      accepts a Time object to initialize a new VanaTime
   * now
-      an alias for new as a convenience method
+      calls new with Time.now
   * at(VanaTime)
       accepts a VanaTime object, int, or float representing vana time to
       initialize a new VanaTime object
@@ -38,20 +72,26 @@ FFXI::VanaTime API
       returns a float with the internal representation of vana time without
       losing any accuracy
   * year
+  * year_start
   * month
+  * month_start
   * date
+  * date_start
+  * tomorrow
   * hour
+  * hour_start
   * minute
+  * minute_start
   * second
+  * second_start
       these methods return various times, what we're interested in
   * to_s
       returns a string in the format:
       YYYY-MM-DD hh:mm:ss
-  * day
-      returns a VanaDay object initialized with the current VanaTime
-  * moon
-      returns a VanaMoon object initialized with the current time
-
+  * time_string
+      returns just the time portion of to_s
+  * date_string
+      returns just the date portion of to_s
 
 FFXI::VanaDay API
 =================
@@ -65,19 +105,32 @@ FFXI::VanaDay API
       returns a base zero number representing the day of the week
   * to_s
       returns the name of the day of the week
-  * weak_element
-      returns the element that the current day is weak to
-  * day_start
-      returns a VanaTime object representing the start of the current day
-  * tomorrow
-      returns a VanaTime object representing the start of the next vana day
+  * to_html
+      returns the day's name in a font tag with the day's color
+  * element
+      returns an Element object with the current day's element
+  * weakness
+      returns an Element object with the current day's elemental weakness
+
+FFXI::ElementFactory::Element
+=============================
 
+  * name
+  * strength
+  * weakness
+  * color
+  * enfeeble
+  * attribute
+  * ninjutsu
+  * avatar
 
 FFXI::VanaMoon API
 ==================
 
   * new(Time)
-      Unlike VanaDay, VanaMoon is initialized with the current earth time
+      Unlike VanaDay, VanaMoon is initialized with earth time
+  * now
+      calls new with the current time
   * to_i
       returns a number representing the exact position along the progression
       of moon phases
@@ -87,17 +140,21 @@ FFXI::VanaMoon API
       returns the name of the current moon phase
   * to_s
       returns a string in the format: moon_percent.abs phase_name
+  * next_phase
+      returns the name of the next moon phase
+  * optimal_phase
+      returns the name of the next optimal moon phase
+
+FFXI::VanaMoonCountdown API
+===========================
+
   * to_next_array
       returns an array containing the days, hours, minutes, and seconds until
       the next moon phase
   * to_next
       returns a formatted countdown until the next moon phase
-  * next_phase
-      returns the name of the next moon phase
   * to_optimal_array
       returns an array containing the days, hours, minutes, and seconds until
       the next optimal moon phase
   * to_optimal
       returns a formatted countdown until the next optimal moon phase
-  * optimal_phase
-      returns the name of the next optimal moon phase

data/VanaTime.gemspec

@@ -1,11 +1,11 @@
 
-# Gem::Specification for Vanatime-1.2.1
+# Gem::Specification for Vanatime-2.0.0
 # Originally generated by Echoe
 
 Gem::Specification.new do |s|
   s.name = %q{VanaTime}
-  s.version = "1.2.1"
-  s.date = %q{2007-09-02}
+  s.version = "2.0.0"
+  s.date = %q{2007-09-08}
   s.summary = %q{A library for converting realtime to vanadiel time}
   s.email = %q{ttilley@gmail.com}
   s.homepage = %q{http://vanatime.rubyforge.org/}
@@ -13,13 +13,13 @@ Gem::Specification.new do |s|
   s.description = %q{A library for converting realtime to vanadiel time}
   s.has_rdoc = true
   s.authors = ["Travis Tilley"]
-  s.files = ["README", "Manifest", "LICENSE", "lib/vana_time.rb", "lib/Vana/time.rb", "lib/Vana/moon.rb", "lib/Vana/day.rb", "lib/Vana/constants.rb", "CHANGELOG", "VanaTime.gemspec"]
+  s.files = ["README", "Manifest", "LICENSE", "lib/vana_time.rb", "lib/Vana/time_manager.rb", "lib/Vana/time.rb", "lib/Vana/moon_countdown.rb", "lib/Vana/moon.rb", "lib/Vana/element.rb", "lib/Vana/day.rb", "lib/Vana/constants.rb", "lib/Vana/common.rb", "CHANGELOG", "VanaTime.gemspec"]
 end
 
 
 # # Original Rakefile source (requires the Echoe gem):
 # 
-# version = "1.2.1"
+# version = "2.0.0"
 # 
 # ENV['RUBY_FLAGS'] = ""
 # 

data/lib/Vana/common.rb

@@ -0,0 +1,86 @@
+module FFXI
+  module Common
+    include FFXI::Constants
+
+    def self.vana_to_earth(vana_time)
+      (((vana_time.to_f - ((898 * 360 + 30) * MS_DAY.to_f)) / 25) +
+          MS_BASIS_DATE.to_f) / MS_SECOND
+    end
+
+    def self.earth_to_vana(earth_time)
+      ((898 * 360 + 30) * MS_DAY) + ((earth_time.to_f * MS_SECOND) -
+          MS_BASIS_DATE) * 25
+    end
+
+    private
+
+    def start_of_period(vana_time, period)
+      vana_time.to_f - (vana_time.to_f % period )
+    end
+
+    def end_of_period(vana_time, period)
+      start_of_period(vana_time, period) + period
+    end
+
+    def period_has_passed_since(period, since, vana_time)
+      if since.nil?
+        true
+      else
+        elapsed = vana_time.to_f - since.to_f
+
+        if elapsed < 0
+          # if we're going -back- in time, we need to measure from the END of
+          # the period instead of the start.
+          elapsed = (since.to_f + period) - vana_time.to_f
+        end
+
+        elapsed >= period
+      end
+    end
+
+    def second_has_passed_since(since, vana_time)
+      period_has_passed_since(MS_SECOND, since, vana_time)
+    end
+
+    def minute_has_passed_since(since, vana_time)
+      period_has_passed_since(MS_MINUTE, since, vana_time)
+    end
+
+    def hour_has_passed_since(since, vana_time)
+      period_has_passed_since(MS_HOUR, since, vana_time)
+    end
+
+    def day_has_passed_since(since, vana_time)
+      period_has_passed_since(MS_DAY, since, vana_time)
+    end
+
+    def month_has_passed_since(since, vana_time)
+      period_has_passed_since(MS_MONTH, since, vana_time)
+    end
+
+    def year_has_passed_since(since, vana_time)
+      period_has_passed_since(MS_YEAR, since, vana_time)
+    end
+
+    def countdown(time)
+      day_left = time.to_f / MS_DAY
+      hour_left = (day_left.to_f - day_left.floor) * 24
+      min_left = (hour_left.to_f - hour_left.floor) * 60
+      sec_left = (min_left.to_f - min_left.floor) * 60
+
+      [day_left.floor, hour_left.floor, min_left.floor, sec_left.floor]
+    end
+
+    def format_countdown(countdown)
+      formatted = String.new
+      countdown[0..2].each do |part|
+        if (part > 0)
+          formatted += "%02d" % part
+          formatted += ":"
+        end
+      end
+      formatted += "%02d" % countdown[3]
+      formatted
+    end
+  end
+end

data/lib/Vana/constants.rb

@@ -30,6 +30,10 @@ module FFXI
     MS_HOUR = HOUR * MS_SECOND
     MS_MINUTE = MINUTE * MS_SECOND
 
+    # correct for the game time calculations anyways
+    MS_MONTH = 30 * MS_DAY
+    MS_YEAR = 360 * MS_DAY
+
     MS_GAME_DAY = (MS_DAY / 25)
 
     BASIS_DATE = Time.utc(2002,6,23,15,0,0,0)

data/lib/Vana/day.rb

@@ -1,52 +1,54 @@
 module FFXI
   class VanaDay
     include FFXI::Constants
+    include Observable
 
     VANA_DAYS = ["Firesday", "Earthsday", "Watersday", "Windsday", "Iceday",
       "Lightningday", "Lightsday", "Darksday"]
-
-    DAY_WEAKNESS = ["Ice", "Lightning", "Fire", "Earth", "Wind", "Water",
-      "Darkness", "Light"]
+    DAY_ELEMENTS = ["Fire", "Earth", "Water", "Wind", "Ice", "Thunder",
+      "Light", "Darkness"]
 
     def initialize(vana_time=VanaTime.now)
-      self.vana_time = vana_time
+      self.vana_time = vana_time.to_f
     end
 
-    attr_reader :vana_time
-
-    def vana_time=(vana_time)
-      @vana_time = vana_time
+    def vana_time=(vt)
+      if vt != @vana_time
+        @vana_time = vt
 
-      vana_day = (@vana_time.to_f % (8 * MS_DAY)) / (MS_DAY)
-
-      if @vana_day.nil?
-        @vana_day = vana_day
-      elsif @vana_day != vana_day
-        @vana_day = vana_day
-        @vana_day_start = nil
-        @vana_day_tomorrow = nil
+        set_day
       end
     end
 
+    attr_reader :element, :weakness
+    attr_reader :vana_time
+
     def to_i
-      @vana_day.to_i
+      @day.to_i
     end
 
     def to_s
-      VANA_DAYS[@vana_day]
+      VANA_DAYS[@day]
     end
 
-    def weak_element
-      DAY_WEAKNESS[@vana_day]
+    def to_html
+      "<b><font color=\"#{@element.color}\">#{VANA_DAYS[@day]}</font></b>"
     end
 
-    def day_start
-      @vana_day_start ||=
-        VanaTime.at(@vana_time.to_f - (@vana_time.to_f % MS_DAY ))
-    end
+    private
+
+    def set_day
+      day = (@vana_time.to_f % (8 * MS_DAY)) / (MS_DAY)
+
+      if day != @day
+        @day = day
+        @element = FFXI::ElementFactory.send DAY_ELEMENTS[@day]
+        @weakness = FFXI::ElementFactory.send(@element.weakness)
 
-    def tomorrow
-      @vana_day_tomorrow ||= VanaTime.at(day_start.to_f + MS_DAY)
+        changed
+        notify_observers("day", self)
+      end
     end
+
   end
 end

data/lib/Vana/element.rb

@@ -0,0 +1,49 @@
+module FFXI
+  module ElementFactory
+    Element = Struct.new(:name, :strength, :weakness, :color, :enfeeble,
+      :attribute, :ninjutsu, :avatar)
+
+    ELEMENTS = ["Fire", "Ice", "Wind", "Earth", "Thunder", "Water"]
+    ELEMENT_COLORS = ["red", "aqua", "green", "yellow", "purple", "blue"]
+    ELEMENT_ENFEEBLE = ["Burn", "Frost", "Choke", "Rasp", "Shock", "Drown"]
+    ELEMENT_ATTRIBUTE = ["STR", "INT", "AGI", "VIT", "DEX", "MND"]
+    ELEMENT_NINJUTSU = ["Katon", "Hyoton", "Huton", "Doton", "Raiton", "Suiton"]
+    ELEMENT_AVATAR = ["Ifrit", "Shiva", "Garuda", "Titan", "Ramuh", "Leviathan"]
+
+    SPECIAL_ELEMENTS = ["Light", "Darkness"]
+    SPECIAL_ELEMENT_COLORS = ["gray", "black"]
+    SPECIAL_ELEMENT_ENFEEBLE = ["Dia", "Bio"]
+    SPECIAL_ELEMENT_ATTRIBUTE = ["CHR", nil]
+    SPECIAL_ELEMENT_AVATAR = ["Carbuncle", ["Fenrir", "Diabolos"]]
+
+    def self.method_missing(name, *args)
+      element = name.to_s.capitalize
+
+      if SPECIAL_ELEMENTS.include? element
+        index = SPECIAL_ELEMENTS.index element
+        opposed = SPECIAL_ELEMENTS[(index - 1) % 2]
+        color = SPECIAL_ELEMENT_COLORS[index]
+        enfeeble = SPECIAL_ELEMENT_ENFEEBLE[index]
+        attribute = SPECIAL_ELEMENT_ATTRIBUTE[index]
+        avatar = SPECIAL_ELEMENT_AVATAR[index]
+
+        Element.new(element, opposed, opposed, color, enfeeble, attribute, nil,
+          avatar)
+      elsif ELEMENTS.include? element
+        index = ELEMENTS.index element
+        weakness = ELEMENTS[(index - 1) % 6]
+        strength = ELEMENTS[(index + 1) % 6]
+        color = ELEMENT_COLORS[index]
+        enfeeble = ELEMENT_ENFEEBLE[index]
+        attribute = ELEMENT_ATTRIBUTE[index]
+        ninjutsu = ELEMENT_NINJUTSU[index]
+        avatar = ELEMENT_AVATAR[index]
+
+        Element.new(element, strength, weakness, color, enfeeble, attribute,
+          ninjutsu, avatar)
+      else
+        raise "Unknown element"
+      end
+    end
+  end
+end

data/lib/Vana/moon.rb

@@ -1,17 +1,88 @@
 module FFXI
   class VanaMoon
     include FFXI::Constants
+    include FFXI::Common
+    include Observable
 
     MOON_PHASES = ["Full", "Waning Gibbous", "Last Quarter", "Waning Crescent",
       "New Moon", "Waxing Crescent", "First Quarter", "Waxing Gibbous"]
 
-    def initialize(time = Time.now)
-      localtime = (time.to_f * 1000).to_i
+    def initialize(time = nil)
+      self.earth_time = time if ! time.nil?
+    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
+      if time != @earth_time
+        @earth_time = time
+
+        set_moon_days
+        set_percent
+        set_phase
+        set_optimal
+      end
+    end
+
+    attr_reader :moon_days, :next_phase_target, :optimal_phase_target
+    attr_reader :earth_time
+
+    def to_i
+      @moon_percent
+    end
+
+    def percent
+      "#{@moon_percent.abs}%"
+    end
+
+    def phase
+      MOON_PHASES[@moon_phase]
+    end
+
+    def to_s
+      "#{percent} #{phase}"
+    end
+
+    def next_phase
+      MOON_PHASES[(@moon_phase + 1) % 8]
+    end
+
+    def optimal_phase
+      MOON_PHASES[@next_optimal_phase]
+    end
+
+    private
+
+    def set_moon_days
+      old_moon_days = @moon_days
+
       # Each lunar cycle takes exactly 84 game days
       # (3 days, 8 hours, 38 minutes, 24 seconds)
-      @moon_days = ((localtime - MS_MOON_DATE.to_i) / MS_GAME_DAY).floor % 84
+      @moon_days = (((@earth_time.to_f * 1000).to_i -
+            MS_MOON_DATE.to_i) / MS_GAME_DAY).floor % 84
+
+      if @moon_days != old_moon_days
+        changed
+        notify_observers("moon_days", self)
+      end
+    end
+
+    def set_percent
+      old_moon_percent = @moon_percent
+
       @moon_percent = - ((42 - @moon_days).to_f / 42 * 100).round
-      @elapsed_time = (localtime - MS_MOON_DATE.to_i) % MS_GAME_DAY
+
+      if @moon_percent != old_moon_percent
+        changed
+        notify_observers("moon_percent", self)
+      end
+    end
+
+    def set_phase
+      old_phase = @moon_phase
 
       case @moon_percent
       when (-100..-94)
@@ -43,6 +114,15 @@ module FFXI
         @next_phase_target = 80
       end
 
+      if @moon_phase != old_phase
+        changed
+        notify_observers("moon_phase", self)
+      end
+    end
+
+    def set_optimal
+      old_optimal = @next_optimal_phase
+
       case @moon_phase
       when (0..3)
         @next_optimal_phase = 4
@@ -52,75 +132,12 @@ module FFXI
         @next_optimal_phase = 0
         @optimal_phase_target = 80
       end
-    end
-
-    attr_reader :elapsed_time, :moon_days
-
-    def to_i
-      @moon_percent
-    end
-
-    def percent
-      "#{@moon_percent.abs}%"
-    end
-
-    def phase
-      MOON_PHASES[@moon_phase]
-    end
-
-    def to_s
-      "#{percent} #{phase}"
-    end
-
-    def to_next_array
-      countdown_to(@next_phase_target)
-    end
 
-    def to_next
-      format_countdown(to_next_array)
-    end
-
-    def next_phase
-      MOON_PHASES[(@moon_phase + 1) % 8]
-    end
-
-    def to_optimal_array
-      countdown_to(@optimal_phase_target)
-    end
-
-    def to_optimal
-      format_countdown(to_optimal_array)
-    end
-
-    def optimal_phase
-      MOON_PHASES[@next_optimal_phase]
-    end
-
-    private
-
-    def countdown(time)
-      day_left = time.to_f / MS_DAY
-      hour_left = (day_left.to_f - day_left.floor) * 24
-      min_left = (hour_left.to_f - hour_left.floor) * 60
-      sec_left = (min_left.to_f - min_left.floor) * 60
-
-      [day_left.floor, hour_left.floor, min_left.floor, sec_left.floor]
-    end
-
-    def countdown_to(target)
-      countdown((target - @moon_days) * MS_GAME_DAY - @elapsed_time)
-    end
-
-    def format_countdown(countdown)
-      formatted = String.new
-      countdown[0..2].each do |part|
-        if (part > 0)
-          formatted += "%02d" % part
-          formatted += ":"
-        end
+      if @next_optimal_phase != old_optimal
+        changed
+        notify_observers("next_optimal_phase", self)
       end
-      formatted += "%02d" % countdown[3]
-      formatted
     end
+
   end
 end

data/lib/Vana/moon_countdown.rb

@@ -0,0 +1,67 @@
+module FFXI
+  class VanaMoonCountdown
+    include FFXI::Constants
+    include FFXI::Common
+    include Observable
+
+    def initialize(moon)
+      self.moon = moon
+    end
+
+    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
+
+    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
+
+        set_countdowns
+      end
+    end
+
+    attr_reader :to_next_array, :to_optimal_array
+    attr_reader :elapsed_time, :earth_time
+
+    def to_next
+      format_countdown(@to_next_array)
+    end
+
+    def to_optimal
+      format_countdown(@to_optimal_array)
+    end
+
+    private
+
+    def set_countdowns
+      to_next_array = countdown_to(@moon.next_phase_target)
+
+      if to_next_array != @to_next_array
+        @to_next_array = to_next_array
+        changed
+        notify_observers("next_phase_countdown", self)
+      end
+
+      to_optimal_array = countdown_to(@moon.optimal_phase_target)
+
+      if to_optimal_array != @to_optimal_array
+        @to_optimal_array = to_optimal_array
+        changed
+        notify_observers("optimal_phase_countdown", self)
+      end
+    end
+
+    def countdown_to(target)
+      countdown((target - @moon.moon_days) * MS_GAME_DAY - @elapsed_time)
+    end
+
+  end
+end

data/lib/Vana/time.rb

@@ -1,50 +1,38 @@
 module FFXI
   class VanaTime
     include FFXI::Constants
+    include FFXI::Common
+    include Observable
 
-    def initialize(time = Time.now)
-      self.earth_time = time
+    def initialize(time = nil)
+      self.earth_time = time if ! time.nil?
     end
 
-    def update_instance_variables
-      # the day object knows how to update only what is necessary, so if there
-      # is an existing VanaDay object, update it
-      if ! @vDay.nil?
-        @vDay.vana_time = @vana_time
-      end
+    def self.at(vt)
+      self.new(Time.at(FFXI::Common.vana_to_earth(vt)))
+    end
 
-      # nil these until they're used and updated later
-      @vYear=@vMon=@vDate=@vHour=@vMin=@vSec=@vana_moon=nil
+    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
-      ms_earth_time = @earth_time.to_f * MS_SECOND
-      @vana_time = ((898 * 360 + 30) * MS_DAY) +
-        (ms_earth_time - MS_BASIS_DATE) * 25
-
-      update_instance_variables
+      vt = FFXI::Common.earth_to_vana(time)
+      set_instance_variables(vt)
     end
 
-    attr_reader :earth_time
-
-    def self.vana_to_earth(vana_time)
-      (((vana_time.to_f - ((898 * 360 + 30) * MS_DAY.to_f)) / 25) +
-          MS_BASIS_DATE.to_f) / MS_SECOND
+    def vana_time=(vt)
+      @earth_time = Time.at(FFXI::Common.vana_to_earth(vt))
+      set_instance_variables(vt)
     end
 
-    def vana_time=(vana_time)
-      @vana_time = vana_time.to_f
-      @earth_time = Time.at(self.class.vana_to_earth(vana_time))
-
-      update_instance_variables
-    end
-
-    def self.at(vana_time)
-      self.new(Time.at(self.vana_to_earth(vana_time)))
-    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
@@ -54,46 +42,72 @@ module FFXI
       @vana_time.to_f
     end
 
-    def year
-      @vYear ||= (@vana_time / (360 * MS_DAY)).to_i
+    def time_string
+      "#{"%02d" % hour}:#{"%02d" % minute}:#{"%02d" % second}"
     end
 
-    def month
-      @vMon ||= (((@vana_time % (360 * MS_DAY)) / (30 * MS_DAY)) + 1).to_i
+    def date_string
+      "#{year}-#{"%02d" % month}-#{"%02d" % date}"
     end
 
-    def date
-      @vDate ||= (((@vana_time % (30 * MS_DAY)) / (MS_DAY)) + 1).to_i
+    def to_s
+      "#{date_string} #{time_string}"
     end
 
-    def hour
-      @vHour ||= ((@vana_time % MS_DAY) / MS_HOUR).to_i
-    end
+    private
+
+    def set_instance_variables(vt)
+      @vana_time = vt.to_f
 
-    def minute
-      @vMin ||= ((@vana_time % MS_HOUR) / MS_MINUTE).to_i
+      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 second
-      @vSec ||= ((@vana_time % MS_MINUTE) / MS_SECOND).to_i
+    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 day
-      @vDay ||= VanaDay.new(@vana_time)
+    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 moon
-      @vana_moon ||= VanaMoon.new(@earth_time)
+    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 self.now
-      self.new
+    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 to_s
-      "#{year}-#{"%02d" % month}-#{"%02d" % date}" +
-        " #{"%02d" % hour}:#{"%02d" % minute}:#{"%02d" % second}"
+    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
   end
 end

data/lib/Vana/time_manager.rb

@@ -0,0 +1,82 @@
+module FFXI
+  class TimeManager
+    include FFXI::Constants
+
+    def initialize(earth_time=nil)
+      @callbacks = {}
+      setup(earth_time) if ! earth_time.nil?
+    end
+
+    def self.now
+      self.new(Time.now)
+    end
+
+    def reset
+      earth_time = @time.earth_time
+      setup(earth_time)
+    end
+
+    def manage(time, day, moon)
+      raise "time needs to be a VanaTime" if ! time.is_a? VanaTime
+      raise "day needs to be a VanaDay" if ! day.is_a? VanaDay
+      raise "moon needs to be a VanaMoon" if ! moon.is_a? VanaMoon
+
+      @time = time
+      @day = day
+      @moon = moon
+      @moon_countdown = VanaMoonCountdown.new(@moon)
+
+      observe
+    end
+
+    def earth_time=(earth_time)
+      raise "I don't have a VanaTime to update" if @time.nil?
+      raise "Input needs to be a Time object" if ! earth_time.is_a? Time
+
+      @time.earth_time=(earth_time)
+    end
+
+    def callback_proc(type, callback)
+      raise "callback needs to be a Proc/lambda" if ! callback.is_a? Proc
+
+      @callbacks[type] = [] if @callbacks[type].nil?
+      @callbacks[type] << callback
+    end
+
+    def callback(type, &block)
+      callback_proc(type, block)
+    end
+
+    def update(type, updater)
+      case type
+      when MS_SECOND
+        @moon_countdown.earth_time = @time.earth_time
+      when MS_DAY
+        @day.vana_time = @time.to_f
+        @moon.earth_time = @time.earth_time
+      when "moon_days"
+        @moon_countdown.moon = @moon
+      end
+
+      @callbacks[type].each {|c| c.call(updater)} if ! @callbacks[type].nil?
+    end
+
+    private
+
+    def setup(time)
+      @time = VanaTime.new(time)
+      @day = VanaDay.new(@time.date_start)
+      @moon = VanaMoon.new(@time.earth_time)
+      @moon_countdown = VanaMoonCountdown.new(@moon)
+
+      observe
+    end
+
+    def observe
+      @time.add_observer(self)
+      @day.add_observer(self)
+      @moon.add_observer(self)
+      @moon_countdown.add_observer(self)
+    end
+  end
+end

data/lib/vana_time.rb

@@ -1,6 +1,12 @@
 $:.unshift File.dirname(__FILE__)
 
+require 'observer'
+
 require 'Vana/constants'
+require 'Vana/common'
+require 'Vana/time'
+require 'Vana/element'
 require 'Vana/day'
 require 'Vana/moon'
-require 'Vana/time'
+require 'Vana/moon_countdown'
+require 'Vana/time_manager'

metadata

@@ -1,48 +1,59 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: VanaTime
+version: !ruby/object:Gem::Version 
+  version: 2.0.0
+date: 2007-09-08 00:00:00 -04:00
+summary: A library for converting realtime to vanadiel time
+require_paths: 
+- lib
+email: ttilley@gmail.com
 homepage: http://vanatime.rubyforge.org/
-extensions: []
-executables: []
-version: !ruby/object:Gem::Version
-  version: 1.2.1
+rubyforge_project: vanatime
+description: A library for converting realtime to vanadiel time
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
 post_install_message: 
-date: 2007-09-02 04:00:00 +00:00
+authors: 
+- Travis Tilley
 files: 
 - README
 - Manifest
 - LICENSE
 - lib/vana_time.rb
+- lib/Vana/time_manager.rb
 - lib/Vana/time.rb
+- lib/Vana/moon_countdown.rb
 - lib/Vana/moon.rb
+- lib/Vana/element.rb
 - lib/Vana/day.rb
 - lib/Vana/constants.rb
+- lib/Vana/common.rb
 - CHANGELOG
 - VanaTime.gemspec
-rubygems_version: 0.9.4
-rdoc_options: []
-signing_key: 
-cert_chain: 
-name: VanaTime
-has_rdoc: true
-platform: ruby
-summary: A library for converting realtime to vanadiel time
-default_executable: 
-bindir: bin
-required_ruby_version: !ruby/object:Gem::Version::Requirement
-  version: 
-  requirements: 
-  - - '>'
-    - !ruby/object:Gem::Version
-      version: 0.0.0
-require_paths: 
-- lib
-specification_version: 1
 test_files: []
-dependencies: []
-description: A library for converting realtime to vanadiel time
-authors: 
-- Travis Tilley
-email: ttilley@gmail.com
+
+rdoc_options: []
+
 extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
 requirements: []
-rubyforge_project: vanatime
-autorequire: 
+
+dependencies: []
+