VanaTime 2.0.0 → 2.1.0

data/lib/Vana/constants.rb

@@ -11,36 +11,35 @@
 # minutes to an hour. I don't know who originally discovered the following, but,
 # the following information can be used to set an "epoch" for Vana'diel time
 # compared to Earth time:
-
+#
 # Earth time: 2002/06/23 15:00:00 GMT
 # Vana'diel time: 0898/02/01 00:00:00
-
+#
 # Using that, you can take any given Earth time, subtract the starting Earth
 # date to set time to "0", and then multiply that by 25 to convert to Vana'diel
 # time.
-
 module FFXI
-  module Constants
-    MINUTE = 60
-    HOUR = MINUTE * 60
-    DAY = HOUR * 24
+ module Constants
+  MINUTE = 60
+  HOUR = MINUTE * 60
+  DAY = HOUR * 24
 
-    MS_SECOND = 1000
-    MS_DAY = DAY * MS_SECOND
-    MS_HOUR = HOUR * MS_SECOND
-    MS_MINUTE = MINUTE * MS_SECOND
+  MS_SECOND = 1000
+  MS_DAY = DAY * MS_SECOND
+  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
+  # correct for the game time calculations anyways
+  MS_MONTH = 30 * MS_DAY
+  MS_YEAR = 360 * MS_DAY
 
-    MS_GAME_DAY = (MS_DAY / 25)
+  MS_GAME_DAY = (MS_DAY / 25)
 
-    BASIS_DATE = Time.utc(2002,6,23,15,0,0,0)
-    MOON_DATE = Time.utc(2004,1,25,2,31,12,0)
+  BASIS_DATE = Time.utc(2002,6,23,15,0,0,0)
+  MOON_DATE = Time.utc(2004,1,25,2,31,12,0)
 
-    MS_BASIS_VANA = ((898 * 360 + 30) * MS_DAY).to_f
-    MS_BASIS_DATE = BASIS_DATE.to_f * MS_SECOND
-    MS_MOON_DATE = MOON_DATE.to_f * MS_SECOND
-  end
+  MS_BASIS_VANA = ((898 * 360 + 30) * MS_DAY).to_f
+  MS_BASIS_DATE = BASIS_DATE.to_f * MS_SECOND
+  MS_MOON_DATE = MOON_DATE.to_f * MS_SECOND
+ end
 end

data/lib/Vana/day.rb

@@ -1,54 +1,57 @@
 module FFXI
-  class VanaDay
-    include FFXI::Constants
-    include Observable
-
-    VANA_DAYS = ["Firesday", "Earthsday", "Watersday", "Windsday", "Iceday",
-      "Lightningday", "Lightsday", "Darksday"]
-    DAY_ELEMENTS = ["Fire", "Earth", "Water", "Wind", "Ice", "Thunder",
-      "Light", "Darkness"]
-
-    def initialize(vana_time=VanaTime.now)
-      self.vana_time = vana_time.to_f
-    end
-
-    def vana_time=(vt)
-      if vt != @vana_time
-        @vana_time = vt
-
-        set_day
-      end
-    end
-
-    attr_reader :element, :weakness
-    attr_reader :vana_time
-
-    def to_i
-      @day.to_i
-    end
+ class VanaDay < Util::RubyBean
+  include FFXI::Constants
+
+  VANA_DAYS = ["Firesday", "Earthsday", "Watersday", "Windsday", "Iceday",
+   "Lightningday", "Lightsday", "Darksday"]
+  DAY_ELEMENTS = ["Fire", "Earth", "Water", "Wind", "Ice", "Thunder",
+   "Light", "Darkness"]
+
+  property :day, :day_element, :day_weakness, :day_strength
+  property :day_string, :day_html
+
+  alias element day_element
+  alias weakness day_weakness
+  alias strength day_strength
+  alias to_s day_string
+  alias to_html day_html
+
+  def initialize(opts={})
+   super()
+   add_listener(opts[:listener]) if opts[:listener]
+   update_vana_time opts[:vana_time] if opts[:vana_time]
+  end
 
-    def to_s
-      VANA_DAYS[@day]
-    end
+  def update_vana_time(vt)
+   @vana_time = vt.to_f
+   set_day
+  end
 
-    def to_html
-      "<b><font color=\"#{@element.color}\">#{VANA_DAYS[@day]}</font></b>"
-    end
+  def update_earth_time(time)
+   update_vana_time FFXI::Common.earth_to_vana(time)
+  end
 
-    private
+  attr_reader :vana_time
 
-    def set_day
-      day = (@vana_time.to_f % (8 * MS_DAY)) / (MS_DAY)
+  def to_i
+   day.to_i
+  end
 
-      if day != @day
-        @day = day
-        @element = FFXI::ElementFactory.send DAY_ELEMENTS[@day]
-        @weakness = FFXI::ElementFactory.send(@element.weakness)
+  def to_f
+   day.to_f
+  end
 
-        changed
-        notify_observers("day", self)
-      end
-    end
+  private
 
+  def set_day
+   self.day = (@vana_time.to_f % (8 * MS_DAY)) / (MS_DAY)
+   self.day_element = FFXI::ElementFactory.send DAY_ELEMENTS[day]
+   self.day_weakness = FFXI::ElementFactory.send(day_element.weakness)
+   self.day_strength = FFXI::ElementFactory.send(day_element.strength)
+   self.day_string = VANA_DAYS[day]
+   self.day_html =
+    "<b><font color=\"#{day_element.color}\">#{VANA_DAYS[day]}</font></b>"
   end
+
+ end
 end

data/lib/Vana/element.rb

@@ -1,49 +1,54 @@
 module FFXI
-  module ElementFactory
-    Element = Struct.new(:name, :strength, :weakness, :color, :enfeeble,
-      :attribute, :ninjutsu, :avatar)
+ module ElementFactory
+  Element = Struct.new(:name, :direction, :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"]
+  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"]
+  ELEMENT_DIRECTION = ["North-West", "East", "South-East", "South",
+   "South-West", "West"]
 
-    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"]]
+  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"]]
+  SPECIAL_ELEMENT_DIRECTION = ["North-East", "North"]
 
-    def self.method_missing(name, *args)
-      element = name.to_s.capitalize
+  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]
+   if SPECIAL_ELEMENTS.include? element
+    index = SPECIAL_ELEMENTS.index element
+    direction = SPECIAL_ELEMENTS_DIRECTION[index]
+    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, direction, opposed, opposed, color, enfeeble,
+     attribute, nil, avatar)
+   elsif ELEMENTS.include? element
+    index = ELEMENTS.index element
+    direction = ELEMENT_DIRECTION[index]
+    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
+    Element.new(element, direction, strength, weakness, color, enfeeble,
+     attribute, ninjutsu, avatar)
+   else
+    raise "Unknown element"
+   end
   end
+ end
 end

data/lib/Vana/moon.rb

@@ -1,143 +1,135 @@
 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 = 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 = (((@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
-
-      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)
-        @moon_phase = 0
-        @next_phase_target = 3
-      when (90..100)
-        @moon_phase = 0
-        @next_phase_target = 3 + 84
-      when (-93..-62)
-        @moon_phase = 1
-        @next_phase_target = 17
-      when (-61..-41)
-        @moon_phase = 2
-        @next_phase_target = 25
-      when (-40..-11)
-        @moon_phase = 3
-        @next_phase_target = 38
-      when (-10..6)
-        @moon_phase = 4
-        @next_phase_target = 45
-      when (7..36)
-        @moon_phase = 5
-        @next_phase_target = 58
-      when (37..56)
-        @moon_phase = 6
-        @next_phase_target = 66
-      when (57..89)
-        @moon_phase = 7
-        @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
-        @optimal_phase_target = 38
-        @optimal_phase_target += 84 if (90..100).include? @moon_percent
-      when (4..7)
-        @next_optimal_phase = 0
-        @optimal_phase_target = 80
-      end
-
-      if @next_optimal_phase != old_optimal
-        changed
-        notify_observers("next_optimal_phase", self)
-      end
-    end
+ class VanaMoon < Util::RubyBean
+  include FFXI::Constants
+  include FFXI::Common
+
+  MOON_PHASES = ["Full", "Waning Gibbous", "Last Quarter Moon",
+   "Waning Crescent", "New Moon", "Waxing Crescent", "First Quarter Moon",
+   "Waxing Gibbous"]
+  SHORT_MOON_PHASES = ["FM", "WNG", "LQM", "WNC", "NM", "WXC", "FQM", "WXG"]
+
+  property :moon_days, :moon_percent, :moon_percent_string
+  property :moon_phase, :moon_phase_name, :moon_phase_short_name
+  property :moon_string
+  property :next_phase_name, :next_phase_short_name
+  property :optimal_phase_name, :optimal_phase_short_name
+  property :next_phase_target, :optimal_phase_target
+
+  alias to_i moon_percent
+  alias percent moon_percent_string
+  alias phase moon_phase_name
+  alias to_s moon_string
+  alias next_phase next_phase_name
+  alias optimal_phase optimal_phase_name
+
+  def initialize(opts={})
+   super()
+   add_listener(opts[:listener]) if opts[:listener]
+
+   if opts[:vana_time].is_a? VanaTime
+    update_earth_time opts[:vana_time].earth_time
+   elsif opts[:earth_time]
+    update_earth_time opts[:earth_time]
+   end
+  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
+
+   @earth_time = time
+   set_moon_days
+   set_percent
+   set_phase
+   set_moon_string
+   set_optimal
+  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
+
+  attr_reader :earth_time
+
+  private
 
+  def set_moon_days
+   # Each lunar cycle takes exactly 84 game days
+   # (3 days, 8 hours, 38 minutes, 24 seconds)
+   self.moon_days = (((@earth_time.to_f * 1000).to_i -
+      MS_MOON_DATE.to_i) / MS_GAME_DAY).floor % 84
   end
+
+  def set_percent
+   self.moon_percent = - ((42 - moon_days).to_f / 42 * 100).round
+   self.moon_percent_string = "#{moon_percent.abs}%"
+  end
+
+  def set_phase
+   case moon_percent
+   when (-100..-94)
+    self.moon_phase = 0
+    self.next_phase_target = 3
+   when (90..100)
+    self.moon_phase = 0
+    self.next_phase_target = 3 + 84
+   when (-93..-62)
+    self.moon_phase = 1
+    self.next_phase_target = 17
+   when (-61..-41)
+    self.moon_phase = 2
+    self.next_phase_target = 25
+   when (-40..-11)
+    self.moon_phase = 3
+    self.next_phase_target = 38
+   when (-10..6)
+    self.moon_phase = 4
+    self.next_phase_target = 45
+   when (7..36)
+    self.moon_phase = 5
+    self.next_phase_target = 58
+   when (37..56)
+    self.moon_phase = 6
+    self.next_phase_target = 66
+   when (57..89)
+    self.moon_phase = 7
+    self.next_phase_target = 80
+   end
+
+   self.moon_phase_name = MOON_PHASES[moon_phase]
+   self.moon_phase_short_name = SHORT_MOON_PHASES[moon_phase]
+   self.next_phase_name = MOON_PHASES[(moon_phase + 1) % 8]
+   self.next_phase_short_name = MOON_PHASES[(moon_phase + 1) % 8]
+  end
+
+  def set_moon_string
+   self.moon_string = "#{moon_percent_string} #{moon_phase_name}"
+  end
+
+  def set_optimal
+   case moon_phase
+   when (0..3)
+    @next_optimal_phase = 4
+    opt = 38
+    opt += 84 if (90..100).include? moon_percent
+    self.optimal_phase_target = opt
+   when (4..7)
+    @next_optimal_phase = 0
+    self.optimal_phase_target = 80
+   end
+
+   self.optimal_phase_name = MOON_PHASES[@next_optimal_phase]
+   self.optimal_phase_short_name = SHORT_MOON_PHASES[@next_optimal_phase]
+  end
+
+ end
 end