osu-db 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in osu-db.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Zejun Wu
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,58 @@
+# Osu::DB
+
+A tool to manipulate osu! beatmap and local scores database.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'osu-db'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install osu-db
+
+## Usage
+
+Load datebase
+
+    require 'osu-db'
+
+    beatmapdb = Osu::DB::BeatmapDB.new
+    beatmapdb.load(IO.read('osu!.db'))
+
+    scoredb = Osu::DB::ScoreDB.new
+    scoredb.load(IO.read('scores.db'))
+
+Let's have fun with touhou music
+
+    beatmapdb.select{|i| i.source =~ /touhou/i}.shuffle.each do |i|
+      puts "#{i.artist_unicode || i.artist} - #{i.title_unicode || i.title}"
+      `mplayer "#{i.audio_path}" 2>&1 >/dev/null`
+    end
+
+Calculate the average accuracy
+
+    scores = scoredb.select{|i| i.game_mode == :osu!}
+    p scores.inject(0){|i, j| i + j.accuracy} / scores.size
+
+Print all taiko scores
+
+    beatmaps = beatmapdb.select{|i| i.mode == :Taiko}.map(&:beatmapcode)
+    scores = scoredb.select{|i| beatmaps.include? i.beatmapcode}
+    scores.sort{|i, j| i.datetime <=> j.datetime}.each do |i|
+      puts "%10s %7d %3d  %s" % [i.user, i.score, i.combo, i.mods]
+    end
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/osu-db.rb

@@ -0,0 +1,3 @@
+require 'osu-db/version'
+require 'osu-db/scoredb'
+require 'osu-db/beatmapdb'

data/lib/osu-db/beatmap.rb

@@ -0,0 +1,172 @@
+require 'osu-db/common'
+
+module Osu
+  module DB
+=begin rdoc
+== Structure of osu!.db
+* *str*[rdoc-ref:StringIO#read_str]
+  #artist, #artist_unicode, #title, #title_unicode, #creator, #version:
+  metadata section in .osu
+* *str*[rdoc-ref:StringIO#read_str] #audio_filename: general section in .osu
+* *str*[rdoc-ref:StringIO#read_str] #beatmapcode: digest of Beatmap
+* *str*[rdoc-ref:StringIO#read_str] #osu_filename:
+* *int*[rdoc-ref:StringIO#read_int] #type:
+  see BeatmapType[rdoc-ref:Osu::DB]
+* *int*[rdoc-ref:StringIO#read_int] #circles, #sliders, #spinners:
+  the number of circles, sliders and spinners
+* *time*[rdoc-ref:StringIO#read_time] #last_edit:
+* *int*[rdoc-ref:StringIO#read_int]
+  #approach_rate, #circle_size, #hp_drain_rate, #overall_difficulty:
+  difficulty section in .osu
+* *double*[rdoc-ref:StringIO#read_double] #slider_multiplier:
+  difficulty section in .osu
+* *int*[rdoc-ref:StringIO#read_int] #draining_time:
+  or play time, in second
+* *int*[rdoc-ref:StringIO#read_int] #total_time:
+  the offset of the last hit object, in millisecond
+* *int*[rdoc-ref:StringIO#read_int] #preview_time:
+  general section in .osu, in millisecond
+* *TimingPoint* #timing_points: timing points section in .osu
+* *int*[rdoc-ref:StringIO#read_int] #beatmapid, #beatmapsetid, #threadid:
+  metadata section in .osu
+* *int*[rdoc-ref:StringIO#read_int] #ratings:
+  user ratings for different GameMode[rdoc-ref:Osu::DB]
+* *int*[rdoc-ref:StringIO#read_int] #your_offset:
+* *float*[rdoc-ref:StringIO#read_float] #stack_leniency:
+  general section in .osu
+* *int*[rdoc-ref:StringIO#read_int] #mode:
+  see GameMode[rdoc-ref:Osu::DB]
+* *str*[rdoc-ref:StringIO#read_str] #source, #tags:
+  metadata section in .osu
+* *str*[rdoc-ref:StringIO#read_int] #online_offset:
+* *str*[rdoc-ref:StringIO#read_str] #letterbox:
+  general section in .osu
+* *bool*[rdoc-ref:StringIO#read_bool] #played?:
+* *time*[rdoc-ref:StringIO#read_time] #last_play:
+* _0_
+* *str*[rdoc-ref:StringIO#read_str] #path:
+  beatmap directory
+* *time*[rdoc-ref:StringIO#read_time] #last_sync:
+* *bool*[rdoc-ref:StringIO#read_bool]
+  #ignore_hitsound?, #ignore_skin?, #disable_storyboard?:
+  visual settings
+* *int*[rdoc-ref:StringIO#read_int] #background_dim:
+  visual settings
+* _0_
+* _unknown_
+* _0|7_
+=end
+    class Beatmap
+      attr_reader :artist, :artist_unicode, :title, :title_unicode, :creator,
+                  :version, :audio_filename, :beatmapcode, :osu_filename,
+                  :type, :circles, :sliders, :spinners, :last_edit,
+                  :approach_rate, :circle_size, :hp_drain_rate,
+                  :overall_difficulty, :slider_multiplier,
+                  :draining_time, :total_time, :preview_time,
+                  :timing_points, :beatmapid, :beatmapsetid, :threadid,
+                  :ratings, :your_offset, :stack_leniency, :mode,
+                  :source, :tags, :online_offset, :letterbox,
+                  :played, :last_play, :zero1, :path, :last_sync,
+                  :ignore_hitsound, :ignore_skin, :disable_storyboard,
+                  :background_dim, :zero2, :int1, :int2
+
+      alias :played?             :played
+      alias :ignore_hitsound?    :ignore_hitsound
+      alias :ignore_skin?        :ignore_skin
+      alias :disable_storyboard? :disable_storyboard
+
+      def initialize(ios = nil)
+        load(ios) if ios
+      end
+
+      def audio_path
+        "#{path}\\#{audio_filename}".gsub('\\', File::SEPARATOR)
+      end
+
+      def osu_path
+        "#{path}\\#{osu_filename}".gsub('\\', File::SEPARATOR)
+      end
+
+      def beatmap_url
+        "http://osu.ppy.sh/b/#{beatmapid}"
+      end
+
+      def beatmapset_url
+        "http://osu.ppy.sh/s/#{beatmapsetid}"
+      end
+
+      def thread_url
+        "http://osu.ppy.sh/forum/t/#{threadid}"
+      end
+
+      def load(ios)
+        @artist         = ios.read_str
+        @artist_unicode = ios.read_str
+        @title          = ios.read_str
+        @title_unicode  = ios.read_str
+        @creator        = ios.read_str
+        @version        = ios.read_str
+        @audio_filename = ios.read_str
+        @beatmapcode    = ios.read_str
+        @osu_filename   = ios.read_str
+
+        @type = BeatmapType[ios.read_int 1]
+        @circles, @sliders, @spinners = *ios.unpack(6, 'v*')
+        @last_edit = ios.read_time
+        # approach_rate(??) might be different from that in .osu
+        @approach_rate, @circle_size, @hp_drain_rate, @overall_difficulty =
+          *ios.unpack(4, 'C*')
+        @slider_multiplier = ios.read_double
+        @draining_time, @total_time, @preview_time = *ios.unpack(12, 'V*')
+        # PreviewTime: -1
+        @preview_time = nil if @preview_time == 0xFFFFFFFF
+
+        n = ios.read_int 4
+        @timing_points = Array.new(n) do
+          bpm = ios.read_double
+          offset = ios.read_double
+          type = ios.read_bool
+          (type ? RegularTimingPoint : InheritedTimingPoint).new(offset, bpm)
+        end
+
+        @beatmapid      = ios.read_int 4
+        @beatmapsetid   = ios.read_int 4
+        @threadid       = ios.read_int 4
+        @ratings        = ios.unpack(4, 'C*')
+        @your_offset    = ios.read_signed_int 2
+        @stack_leniency = ios.read_float
+        @mode           = GameMode[ios.read_int 1]
+        @source         = ios.read_str
+        @tags           = ios.read_str
+        @online_offset  = ios.read_signed_int 2
+
+
+        @letterbox = ios.read_str
+
+        @played    = !ios.read_bool
+        @last_play = ios.read_time
+        # if !@played && @last_play != nil
+        #   raise DBCorruptError, "played=%s doesn't match last_play=%s" %
+        #     [@played, @last_play].map{|i| i.inspect}
+        # end
+
+        @zero1     = ios.read_int 1           # TODO: =0
+        raise if @zero1 != 0
+        @path      = ios.read_str
+        @last_sync = ios.read_time
+
+        @ignore_hitsound    = ios.read_bool
+        @ignore_skin        = ios.read_bool
+        @disable_storyboard = ios.read_bool
+        @background_dim     = ios.read_int 1
+        # @disable_video is not saved
+
+        @zero2     = ios.read_int 1           # TODO: =0
+        raise if @zero2 != 0
+        @int1      = ios.read_int 4           # TODO: almost=0
+        @int2      = ios.read_int 1           # TODO: almost=0, otherwise=7
+        raise unless @int2 == 0 || @int2 == 7 # 0 iff original mode only
+      end
+    end
+  end
+end

data/lib/osu-db/beatmapdb.rb

@@ -0,0 +1,32 @@
+require 'forwardable'
+require 'osu-db/common'
+require 'osu-db/beatmap'
+
+module Osu
+  module DB
+    class BeatmapDB
+      include Enumerable
+      extend Forwardable
+
+      def_delegators :beatmaps, :each
+
+      attr_reader :beatmaps
+
+      def load(str)
+        ios = StringIO.new(str, 'rb')
+        ios.read_version
+
+        folders = ios.read_int 4
+        dummy1  = ios.read_int 4
+        dummy2  = ios.read_int 4
+        dummy3  = ios.read_int 1
+        user    = ios.read_str
+
+        n = ios.read_int 4
+        @beatmaps = Array.new(n) do
+          beatmap = Beatmap.new(ios)
+        end
+      end
+    end
+  end
+end

data/lib/osu-db/common.rb

@@ -0,0 +1,112 @@
+require 'stringio'
+require 'osu-db/mods'
+require 'osu-db/timeutil'
+require 'osu-db/timing_point'
+
+module Osu
+  module DB
+    # There are mainly three different beatmap types:
+    # +:Ranked+:: beatmap with a heart icon
+    # +:Approved+:: beatmap with a flame icon
+    # +:Pending+:: others, including pending, mod requests and graveyard
+    # There is also a special type:
+    # +:ToBeDecided+:: the type information in osu!.db is out of date
+    BeatmapType = {
+      0 => :ToBeDecided,  # Type info is out of date
+      2 => :Pending,
+      4 => :Ranked,
+      5 => :Approved
+    }
+
+    # There are four game modes in osu!:
+    # +:osu!+:: http://osu.ppy.sh/wiki/Standard
+    # +:Taiko+:: http://osu.ppy.sh/wiki/Taiko
+    # +:CatchTheBeat+:: http://osu.ppy.sh/wiki/Catch_The_Beat
+    # <tt>:'osu!mania'</tt>:: http://osu.ppy.sh/wiki/Osu!mania
+    GameMode = [
+      :osu!,
+      :Taiko,
+      :CatchTheBeat,
+      :'osu!mania'
+    ]
+
+    class UnsupportedVersionError < RuntimeError
+    end
+
+    class DBCorruptError < RuntimeError
+    end
+
+    class StringIO < ::StringIO
+      def unpack(bytesize, format)
+        read(bytesize).unpack(format)
+      end
+
+      def read_int(bytesize)
+        unpack(bytesize, "C#{bytesize}").reverse.inject{|h, l| h << 8 | l}
+      end
+
+      def read_signed_int(bytesize)
+        len = 8 * bytesize
+        ret = read_int(bytesize)
+        ret[len - 1] == 0 ? ret : ret - (1 << len)
+      end
+
+      def read_float
+        unpack(4, 'e')[0]
+      end
+
+      def read_double
+        unpack(8, 'E')[0]
+      end
+
+      def read_bool
+        flag = read_int(1)
+        if flag == 0 || flag == 1
+          flag != 0
+        else
+          raise DBCorruptError, "0x00 or 0x01 expected, got #{'0x%02x' % flag}"
+        end
+      end
+
+      def read_7bit_encoded_int
+        ret, off = 0, 0
+        loop do
+          byte = read_int(1)
+          ret |= (byte & 0x7F) << off
+          off += 7
+          break if byte & 0x80 == 0
+        end
+        ret
+      end
+
+      def read_time
+        ticks = read_int(8)
+        ticks == 0 ? nil : TimeUtil.ticks_to_time(ticks)
+      end
+
+      def read_str
+        tag = read_int(1)
+        if tag == 0
+          nil
+        elsif tag == 0x0b
+          len = read_7bit_encoded_int
+          read(len)
+        else
+          raise DBCorruptError, "0x00 or 0x0b expected, got #{'0x%02x' % tag}"
+        end
+      end
+
+      VERSION_MIN = 0x01330689
+      VERSION_MAX = 0x0133068D
+
+      def read_version
+        version = read_int(4)
+        if (VERSION_MIN .. VERSION_MAX).include? version
+          version
+        else
+          raise UnsupportedVersionError, "version = #{'0x%08x' % version}"
+        end
+      end
+    end
+  end
+end

data/lib/osu-db/mods.rb

@@ -0,0 +1,76 @@
+module Osu
+  module DB
+    class Mod
+      def initialize(index, name)
+        @index = index
+        @name = name
+      end
+
+      def to_i
+        1 << @index
+      end
+
+      def to_s
+        @name
+      end
+
+      # Easy
+      EZ = Mod.new(1, 'Easy')
+      # No Fail
+      NF = Mod.new(0, 'NoFail')
+      # Half Time
+      HT = Mod.new(8, 'HalfTime')
+      # Hard Rock
+      HR = Mod.new(4, 'HardRock')
+      # Sudden Death
+      SD = Mod.new(5, 'SuddenDeath')
+      # Perfect (based on SD)
+      PF = Mod.new(14, '+Perfect')
+      # Double Time
+      DT = Mod.new(6, 'DoubleTime')
+      # Night Core (based on DT)
+      NC = Mod.new(9, '+NightCore')
+      # Hidden
+      HD = Mod.new(3, 'Hidden')
+      # Flash Light
+      FL = Mod.new(10, 'FlashLight')
+      # Relax
+      RL = Mod.new(-1, 'Relax')
+      # Auto Pilot
+      AP = Mod.new(-1, 'AutoPilot')
+      # Spun Out
+      SO = Mod.new(12, 'SpunOut')
+      # Auto
+
+      # Return all ranked mods
+      def self.all
+        [EZ, NF, HT, HR, SD, PF, DT, NC, HD, FL, SO]
+      end
+    end
+
+    class Mods
+      include Enumerable
+
+      def initialize(mods)
+        @mods = mods
+      end
+
+      def include?(mod)
+        @mods & mod.to_i != 0
+      end
+
+      def to_a
+        Mod.all.select{|mod| include? mod}
+      end
+
+      def to_i
+        @mods
+      end
+
+      def to_s
+        to_a.map{|mod| mod.to_s} * ','
+      end
+    end
+  end
+end
+

data/lib/osu-db/score.rb

@@ -0,0 +1,170 @@
+require 'osu-db/common'
+
+module Osu
+  module DB
+=begin rdoc
+== Structure of scores.db
+* *str*[rdoc-ref:StringIO#read_str] #beatmapcode: digest of Beatmap
+* *str*[rdoc-ref:StringIO#read_str] #user: username
+* *str*[rdoc-ref:StringIO#read_str] #scorecode: digest of Score
+* *int*[rdoc-ref:StringIO#read_int] #x300, #x100, #x50:
+  the number of 300s, 100s and 50s
+* *int*[rdoc-ref:StringIO#read_int] #geki, #katsu, #miss:
+  these attributes may have different meaning is special modes
+* *int*[rdoc-ref:StringIO#read_int] #score, #combo:
+  score and max combo
+* *bool*[rdoc-ref:StringIO#read_bool] #perfect?:
+  full combo or not
+* *bitset*[rdoc-ref:StringIO#read_int] #mods:
+  mods or game modifiers, see Mod and Mods
+* *time*[rdoc-ref:StringIO#read_time] #datetime:
+  played time
+* _0xFFFFFFFF_
+* *int*[rdoc-ref:StringIO#read_int] #scoreid:
+  score id
+=end
+    class Score
+      attr_reader :game_mode, :beatmapcode, :user, :scorecode,
+                  :x300, :x100, :x50, :geki, :katsu, :miss,
+                  :score, :combo, :perfect, :mods, :datetime, :dummy, :scoreid
+
+      alias :perfect?    :perfect
+      alias :full_combo  :perfect
+      alias :full_combo? :full_combo
+
+      def initialize(game_mode, ios = nil)
+        @game_mode = game_mode
+        load(ios) if ios
+      end
+
+      def hits
+        raise NotImplementedError
+      end
+
+      def accuracy
+        raise NotImplementedError
+      end
+
+      def grade
+        raise NotImplementedError
+      end
+
+      def load(ios)
+        ios.read_version
+
+        @beatmapcode = ios.read_str
+        @user = ios.read_str
+
+        @scorecode = ios.read_str
+        @x300, @x100, @x50, @geki, @katsu, @miss = *ios.unpack(12, 'v6')
+        @score = ios.read_int(4)
+        @combo = ios.read_int(2)
+        @perfect = ios.read_bool
+        @mods = Mods.new(ios.read_int(5))
+        @datetime = ios.read_time
+        @dummy = ios.read_int(4)              # TODO: always = 0xFFFFFFFF
+        @scoreid = ios.read_int(4)
+      end
+    end
+
+    # Score of Standard Mode
+    class OsuScore < Score
+      def hits
+        x300 + x100 + x50 + miss
+      end
+
+      def accuracy
+        (300 * x300 + 100 * x100 + 50 * x50) / (300.0 * hits)
+      end
+
+      def grade
+        if x300 == hits
+          :SS # SS = 100% accuracy
+        elsif 10 * x300 > 9 * hits && 100 * x50 < hits && miss == 0
+          :S  # S = Over 90% 300s, less than 1% 50s and no miss.
+        elsif 10 * x300 > 8 * hits && miss == 0 || 10 * x300 > 9 * hits
+          :A  # A = Over 80% 300s and no miss OR over 90% 300s.
+        elsif 10 * x300 > 7 * hits && miss == 0 || 10 * x300 > 8 * hits
+          :B  # B = Over 70% 300s and no miss OR over 80% 300s.
+        elsif 10 * x300 > 6 * hits
+          :C  # C = Over 60% 300s.
+        else
+          :D
+        end
+      end
+    end
+
+    # Score of Taiko Mode
+    class TaikoScore < Score
+      alias :great :x300
+      alias :good  :x100
+
+      def hits
+        great + good + miss
+      end
+
+      def accuracy
+        (great + good * 0.5) / hits
+      end
+
+      def grade
+        if x300 == hits
+          :SS
+        elsif 10 * x300 > 9 * hits && miss == 0
+          :S
+        elsif 10 * x300 > 8 * hits && miss == 0 || 10 * x300 > 9 * hits
+          :A
+        elsif 10 * x300 > 7 * hits && miss == 0 || 10 * x300 > 8 * hits
+          :B
+        elsif 10 * x300 > 6 * hits
+          :C
+        else
+          :D
+        end
+      end
+    end
+
+    # Score of Catch The Beat Mode
+    class CTBScore < Score
+      alias :droplet_miss :katsu
+
+      def hits
+        x300 + x100 + x50 + droplet_miss + miss
+      end
+
+      def accuracy
+        (x300 + x100 + x50).to_f / hits
+      end
+
+      def grade
+        acc = accuracy
+        [0.85, :D, 0.90, :C, 0.94, :B, 0.98, :A].each_slice(2) do |a, g|
+          return g if acc <= a
+        end
+        acc < 1 ? :S : :SS
+      end
+    end
+
+    # Score of osu!mania Mode
+    class ManiaScore < Score
+      alias :max  :geki
+      alias :x200 :katsu
+
+      def hits
+        max + x300 + x200 + x100 + x50 + miss
+      end
+
+      def accuracy
+        (300 * (max + x300) + 200 * x200 + 100 * x100 + 50 * x50) / (300.0 * hits)
+      end
+
+      def grade
+        acc = accuracy
+        [0.70, :D, 0.80, :C, 0.90, :B, 0.95, :A].each_slice(2) do |a, g|
+          return g if acc <= a
+        end
+        acc < 1 ? :S : :SS
+      end
+    end
+  end
+end

data/lib/osu-db/scoredb.rb

@@ -0,0 +1,49 @@
+require 'osu-db/common'
+require 'osu-db/score'
+
+module Osu
+  module DB
+    class ScoreDB
+      include Enumerable
+
+      @@game_mode_score = {
+        :osu!         => OsuScore,
+        :Taiko        => TaikoScore,
+        :CatchTheBeat => CTBScore,
+        :'osu!mania'  => ManiaScore
+      }
+
+      attr_reader :scores
+
+      def each
+        scores.each do |_, v|
+          v.each do |score|
+            yield score
+          end
+        end
+      end
+
+      def load(str)
+        ios = StringIO.new(str, "rb")
+        @scores = Hash.new{[]}
+
+        ios.read_version
+        n = ios.read_int(4)
+
+        n.times do
+          beatmapcode = ios.read_str
+          m = ios.read_int(4)
+          m.times do
+            game_mode = GameMode[ios.read_int 1]
+            if game_mode && @@game_mode_score[game_mode]
+              score = @@game_mode_score[game_mode].new(game_mode, ios)
+            else
+              score = Score.new(game_mode, ios)
+            end
+            @scores[beatmapcode] <<= score
+          end
+        end
+      end
+    end
+  end
+end

data/lib/osu-db/timeutil.rb

@@ -0,0 +1,36 @@
+module Osu
+  module DB
+    # Conversion between System.DateTime.Ticks in .NET and Time in Ruby
+    # - http://msdn.microsoft.com/en-us/library/system.datetime.ticks.aspx
+    # - http://www.ruby-doc.org/core/Time.html
+    module TimeUtil
+      # A single tick represents one hundred nanoseconds or one ten-millionth
+      # of a second.
+      TICKS_PER_SEC = 10 ** 7
+
+      # The value of DateTime.Ticks represents the number of 100-nanosecond
+      # intervals that have elapsed since 12:00:00 midnight, January 1, 0001,
+      # which represents DateTime.MinValue. It does not include the number of
+      # ticks that are attributable to leap seconds.
+      EPOCH_TO_TICKS = 0 - Time.utc(1, 1, 1).to_i * TICKS_PER_SEC
+
+      # Convert DateTime.Ticks to Time
+      def self.ticks_to_time(ticks)
+        if ticks.kind_of? Numeric
+          Time.at(Rational(ticks - EPOCH_TO_TICKS, TICKS_PER_SEC))
+        else
+          ticks
+        end
+      end
+
+      # Convert Time to DateTime.Ticks
+      def self.time_to_ticks(time)
+        if time.kind_of? Numeric
+          time.to_i
+        else
+          EPOCH_TO_TICKS + (time.to_r * TICKS_PER_SEC).to_i
+        end
+      end
+    end
+  end
+end

data/lib/osu-db/timing_point.rb

@@ -0,0 +1,22 @@
+module Osu
+  module DB
+    class TimingPoint
+      private_class_method :new
+
+      attr_reader :offset, :bpm
+
+      def initialize(offset, bmp)
+        @offset = offset
+        @bpm = bmp
+      end
+    end
+
+    class RegularTimingPoint < TimingPoint
+      public_class_method :new
+    end
+
+    class InheritedTimingPoint < TimingPoint
+      public_class_method :new
+    end
+  end
+end

data/lib/osu-db/version.rb

@@ -0,0 +1,6 @@
+module Osu
+  module DB
+    # :nodoc:
+    VERSION = "0.1.0"
+  end
+end

data/osu-db.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'osu-db/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "osu-db"
+  gem.version       = Osu::DB::VERSION
+  gem.authors       = ["Zejun Wu"]
+  gem.email         = ["zejun.wu@gmail.com"]
+  gem.description   = %q{A tool to manipulate osu! beatmap and local scores database.}
+  gem.summary       = %q{Library to manipulate osu! database}
+  gem.homepage      = "https://github.com/watashi/osu-db"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: osu-db
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Zejun Wu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A tool to manipulate osu! beatmap and local scores database.
+email:
+- zejun.wu@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/osu-db.rb
+- lib/osu-db/beatmap.rb
+- lib/osu-db/beatmapdb.rb
+- lib/osu-db/common.rb
+- lib/osu-db/mods.rb
+- lib/osu-db/score.rb
+- lib/osu-db/scoredb.rb
+- lib/osu-db/timeutil.rb
+- lib/osu-db/timing_point.rb
+- lib/osu-db/version.rb
+- osu-db.gemspec
+homepage: https://github.com/watashi/osu-db
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Library to manipulate osu! database
+test_files: []