bathtub 0.5.2

data/VERSION

@@ -0,0 +1 @@
+0.5.2

data/bathtub/character.rb

@@ -0,0 +1,232 @@
+#
+# character.rb
+#
+
+class Combo
+  include Task
+  
+  def self.load
+    @@font = SDL::TTF.open("image/curving.ttf", 20)
+  end
+  attr_accessor :x,:y,:value
+  
+  def init
+    @step = 0
+  end
+  
+  def act(dt,i)
+    @step += dt
+    @active = false if @step > 500
+  end
+    
+  def draw(i)
+    @@font.drawBlendedUTF8(i.scr,"#{@value} COMBO", @x,@y-(@step/10) , 255,100,100)
+  end
+  
+end
+
+class Bath
+  extend SingleTask
+  
+  Shibuki = Struct.new(:x,:y,:step)
+  
+  WAIT_STAFF_ANIM = 80
+  MOVE_WAIT = 3
+  
+  STAFF_IMGS = 4
+  SHIBUKI_IMGS = 3
+  Y0  = 342
+  
+  attr_reader :x,:y
+  
+  def init
+    @img_bath = SDL::Surface.loadBMP("image/bath.bmp")
+    @img_bath.setColorKey(SDL::SRCCOLORKEY,[255,0,255])
+    @img_rstaff = Util.cut_image(56,67,STAFF_IMGS, SDL::Surface.loadBMP("image/staff.bmp"), 0,0,  [255,0,255])
+    @img_lstaff = Util.cut_image(56,67,STAFF_IMGS, SDL::Surface.loadBMP("image/staff.bmp"), 0,67, [255,0,255])
+    @img_shibuki = Util.cut_image(94,105,SHIBUKI_IMGS, SDL::Surface.loadBMP("image/shibuki.bmp"),0,0,[255,255,255])
+    Sound.open(:scratch, "BB_Scratch_19.wav", 40)
+    @movetimer = Timer.new(MOVE_WAIT)
+    @staff_anim_timer = Timer.new(WAIT_STAFF_ANIM)
+    @shibuki_timer = Timer.new(80)
+  end
+  
+  def enabled
+    @movestep = (GameMain.mode==:endless ? 3 : 2)
+  end
+  
+  def reset
+    @staffimg = 0
+    @x = 320 #�o�X�^�u�̒��S���W
+    @y = Y0
+    @dir = 1 #1:right -1:left
+    @effects = []
+  end
+
+  def shibuki
+    @effects << Shibuki.new(0,0,0)
+  end
+  
+  def act(dt,i)
+    act_move(dt,i) unless Gameover.active?
+    act_shibuki(dt)
+  end
+  
+  def act_move(dt,i)
+    if i.key.right 
+      newdir = 1
+    elsif i.key.left
+      newdir = -1
+    elsif i.keydown.button
+      newdir = -@dir
+    else
+      newdir = @dir
+    end
+    
+    if newdir != @dir
+      #Sound.play(:scratch)
+      @dir = newdir
+    end
+      
+    @staff_anim_timer.wait(dt){
+      @staffimg+=1
+      @staffimg=0 if @staffimg>=STAFF_IMGS
+    }
+    
+    @movetimer.wait(dt){
+      @x += @dir * @movestep
+      @x = 0 if @x<0
+      @x = 639 if @x>639
+    }
+  end
+  
+  def act_shibuki(dt)
+    @effects.each do |eff|
+      @shibuki_timer.wait(dt){
+          eff.step+=1
+      }
+    end
+    @effects.delete_if{|eff|
+      eff.step >= SHIBUKI_IMGS
+    }
+  end
+
+  def draw(i)
+    @effects.each{|eff| i.scr.put(@img_shibuki[eff.step], @x-55, @y-58)}
+    
+    @x = 330 if NameEntry.active?
+    
+    i.scr.put(@img_lstaff[@staffimg], @x-80, @y-14)
+    i.scr.put(@img_bath,              @x-37, @y   )
+    i.scr.put(@img_rstaff[@staffimg], @x+32, @y-14)
+  end
+
+end
+
+
+class Jumper
+  include Task
+  
+  def self.load
+    @@img = SDL::Surface.loadBMP("image/hito.bmp")
+    @@img.setColorKey(SDL::SRCCOLORKEY,[255,0,255])
+  end
+  
+  attr_accessor :x,:y
+  def init
+    case GameMain.mode
+    when :easy
+      speed = 11
+    when :normal
+      speed = 8
+    when :endless
+      speed = 7
+    end
+
+    @movetimer = Timer.new(speed)
+    @type = rand(2)
+    @missed = false
+
+    #���W�֘A
+    @t0=-20
+    @y0=260
+    @x=(@type==0 ? 0 : 640)
+    @y=0
+    @t=0
+    @vx=rand(6)+1
+  end
+  attr_accessor :missed
+
+  def act(dt,info)
+    @movetimer.wait(dt){
+      @t+=0.8
+      if @type==0
+        @x = @vx*@t
+      else # @type==1
+        @x = 640 - @vx*@t
+      end
+
+      @y = 480 - ( @y0 + 10*(@t-@t0) - 0.1*(@t-@t0)*(@t-@t0) )
+    }
+    
+    if @x<0 || @x>=640 || @y>=480
+      @alive = false
+    end
+  end
+  
+  def draw(i)
+    i.scr.put(@@img, @x - @@img.w/2, @y)
+  end
+  
+end
+
+class Jumpers
+  extend SingleTask
+  
+  def init
+    Sound.open(:zabun, "SplashA1@22.wav", 60)
+    Sound.open(:fall,  "fall.wav", 60)
+  end
+
+  def reset
+    @items = []
+    @margin = (GameMain.mode==:easy ? 80 : 25)
+  end
+  
+  def act(dt,i)
+    ret = 0 #0pts
+    
+    #����
+    if @items.size<1 && !Gameover.active?
+      @items << Jumper.new
+    end
+
+    #����
+    @items.each do |item|
+      if item.y>=330 && item.alive && !item.missed
+        #����
+        if (Bath.instance.x-item.x).abs < @margin
+          #�����ρ[��
+          item.alive = false #����
+          i.score.incr #1 pts
+          Sound.play(:zabun)
+          Bath.instance.shibuki
+          if GameMain.mode==:endless && i.score.value > 0
+            c = Combo.new
+            c.x = Bath.instance.x; c.y = Bath.instance.y; c.value = i.score.value
+          end
+        elsif item.y>=360
+          #���ׂ�
+          Sound.play(:fall)
+          item.missed = true
+          i.score.miss #1miss
+        end
+      end
+    end
+    
+    #�폜
+    @items.delete_if{|item| !item.alive}
+  end
+
+end
+

data/bathtub/game.rb

@@ -0,0 +1,120 @@
+require 'singleton'
+require 'bathtub/misc.rb'
+require 'bathtub/task.rb'
+require 'bathtub/score.rb'
+require 'bathtub/scene.rb'
+require 'bathtub/graphic.rb'
+require 'bathtub/character.rb'
+
+class NullJoystick
+  def axis(a); 0; end
+  def hat(i);  0; end
+  def numButtons; 0; end
+end
+
+class Game
+  
+  Key = Struct.new(:left,:right,:button,:other,:ctrl,:esc)
+  class Key
+    def reset
+      self.size.times{|i| self[i]=nil}
+    end
+  end
+  
+  def initialize(screen)
+    @screen = screen
+    @joy = (SDL::Joystick.num > 0) ? SDL::Joystick.open(0) : NullJoystick.new
+    
+    TaskManager.init
+    
+    Background.new
+    Gameover.disable
+    Highscore.disable
+    ModeSelect.enable
+    GameMain.disable
+    @score = Score.instance
+    Jumper.load
+    Jumpers.disable
+    Bath.disable
+    Combo.load
+    NameEntry.disable
+  end
+  
+  def run
+    TaskManager.reset
+    before = now = SDL.getTicks
+    info = Task::Info.new
+    info.scr = @screen
+    info.score = @score
+    info.key = Key.new
+    info.keydown = Key.new
+    
+    while true
+      return if check_events(info.key, info.keydown)==nil
+      
+      before=now; now=SDL.getTicks; dt=now-before
+      TaskManager.act(dt,info)
+
+      TaskManager.draw(info)
+      @screen.flip
+    end
+  end
+  
+  def check_events(key,kd)
+    key.reset
+    kd.reset
+    
+    #check keys
+    while (event=SDL::Event2.poll)
+      case event
+      when SDL::Event2::Quit
+        return nil
+      when SDL::Event2::JoyButtonDown
+        kd.button = true
+      when SDL::Event2::JoyAxis
+        if event.value < -512
+          kd.left = true
+        elsif event.value > 512
+          kd.right = true
+        end
+      when SDL::Event2::KeyDown
+        kd.other ||= []
+        kd.other << event.sym
+        case event.sym
+        when SDL::Key::ESCAPE
+          if GameMain.mode==:endless && GameMain.active?
+            kd.esc = true
+          else
+            return nil
+          end
+        when SDL::Key::RETURN, SDL::Key::SPACE
+          kd.button = true
+        when SDL::Key::LEFT, SDL::Key::UP, SDL::Key::H, SDL::Key::K
+          kd.left = true
+        when SDL::Key::RIGHT, SDL::Key::DOWN, SDL::Key::L, SDL::Key::J
+          kd.right = true
+        end
+      end
+    end
+    
+    SDL::Key.scan; SDL::Joystick.updateAll
+    key.left  = true if @joy.axis(0) < -512 || @joy.axis(1) < -512 ||
+                        @joy.hat(0) == SDL::Joystick::HAT_LEFT ||  @joy.hat(0) == SDL::Joystick::HAT_UP
+    key.right = true if @joy.axis(0) >  512 || @joy.axis(1) >  512 ||
+                        @joy.hat(0) == SDL::Joystick::HAT_RIGHT || @joy.hat(0) == SDL::Joystick::HAT_DOWN
+    @joy.numButtons.times{|i| key.button = true if @joy.button(i)}
+    [SDL::Key::RETURN, SDL::Key::SPACE].each{|k| key.button=true if SDL::Key.press?(k)}
+    [SDL::Key::LEFT, SDL::Key::UP].each{|k| key.left=true  if SDL::Key.press?(k)}
+    [SDL::Key::RIGHT, SDL::Key::DOWN].each{|k| key.right=true if SDL::Key.press?(k)}
+    unless NameEntry.active?
+      [SDL::Key::H, SDL::Key::K].each{|k| key.left=true  if SDL::Key.press?(k)} 
+      [SDL::Key::L, SDL::Key::J].each{|k| key.right=true if SDL::Key.press?(k)}
+    end
+    key.ctrl = true if SDL::Key.press?(SDL::Key::LCTRL)
+    
+    return true
+  end
+  
+end
+
+

data/bathtub/graphic.rb

@@ -0,0 +1,25 @@
+#
+# graphic.rb
+#
+
+class Background
+  include Task
+  
+  def init
+    @img_back = SDL::Surface.loadBMP("image/back.bmp")
+    @img_logo = SDL::Surface.loadBMP("image/logo.bmp")
+    @img_logo.setColorKey(SDL::SRCCOLORKEY,[0,0,255])
+    @font = SDL::TTF.open("image/curving.ttf", 20)
+  end
+  
+  def draw(i)
+    i.scr.fillRect(0,0,640,480,0)
+    i.scr.put(@img_back,0,0)
+    if GameMain.active?
+      i.scr.put(@img_logo,520,382)
+      @font.drawBlendedUTF8(i.scr, GameMain.mode.to_s.upcase, 550,455, 255,80,80)
+    end
+  end
+  
+end
+

data/bathtub/main.rb

@@ -0,0 +1,35 @@
+# main.rb
+
+require 'sdl'
+require 'bathtub/game.rb'
+
+class Main
+  
+  TITLE = "�o�X�^�u�꒼��"
+  VERSION = "0.51"
+  
+  def initialize(fullscreen=false)
+    SDL.init(SDL::INIT_VIDEO|SDL::INIT_AUDIO|SDL::INIT_JOYSTICK)
+    SDL::TTF.init
+    SDL::Mixer.open
+    
+    SDL::WM.icon = SDL::Surface.loadBMP("image/icon-16168.bmp")
+    #screen
+    if fullscreen
+      screen = SDL::setVideoMode(640,480,16,SDL::SWSURFACE|SDL::FULLSCREEN) #|SDL::DOUBLEBUF
+      SDL::Mouse.hide
+    else
+      screen = SDL::setVideoMode(640,480,16,SDL::SWSURFACE) #|SDL::DOUBLEBUF)
+    end
+    #SDL::WM.setCaption(TITLE+" "+VERSION, TITLE)
+    
+    #init game
+    @game = Game.new(screen)
+  end
+
+  def run
+    @game.run
+  end
+  
+end
+

data/bathtub/misc.rb

@@ -0,0 +1,83 @@
+#
+# misc.rb
+#
+
+class Consts
+  LIVES = 2
+end
+
+#----------------------------------------------------------------------------------
+
+class Timer
+  def reset
+    @ct=0
+  end
+
+  def initialize(waittime)
+    set_wait(waittime)
+    reset
+  end
+
+  def wait(dt)
+    @ct+=dt
+    while @ct>=@waittime do
+      @ct-=@waittime
+      yield
+      @ct=0 if @ct<@waittime
+    end
+  end
+
+  def set_wait(t)
+    raise ArgumentError,"waittime must be positive" if t<=0
+    @waittime = t
+  end
+end
+
+#----------------------------------------------------------------------------------
+module Sound
+
+  class << Sound
+    def open(sym,fname,vol=nil)
+      if fname=~/\.wav\z/
+        @@waves ||= {}
+        @@waves[sym] = [SDL::Mixer::Wave.load("sound/"+fname), @@waves.size]
+        @@waves[sym][0].setVolume(vol) if vol
+      else
+        @@bgm ||= {}
+        #@@bgm[sym] = SDL::Mixer::Music.load("sound/"+fname)
+      end
+    end
+
+    def play(sym)
+      if @@waves.key? sym
+        SDL::Mixer.playChannel(@@waves[sym][1],  #channel
+        @@waves[sym][0],  #wave
+        0)
+      else
+        #SDL::Mixer.playMusic(@@bgm[sym],-1)
+      end
+    end
+
+    def stop_music
+      SDL::Mixer.haltMusic
+    end
+  end
+
+end
+
+#------------------------------------------------------------------------------
+module Util
+  def self.cut_image(w,h,n,img, ofsx=0, ofsy=0, colkey=nil)
+    ret = []
+    n.times do |i|
+      surf = img.copyRect(i*w+ofsx,0+ofsy, w,h)
+      surf.setColorKey(SDL::SRCCOLORKEY, colkey) if colkey!=nil
+      ret << surf
+    end
+    ret
+  end
+end
+
+
+#----------------------------------------------------------------------------------
+#----------------------------------------------------------------------------------

data/bathtub/scene.rb

@@ -0,0 +1,223 @@
+#
+# scene.rb
+#
+
+class GameMain
+  extend SingleTask
+  
+  def init
+    Sound.open(:bgm, "blacksamba.it")
+    Sound.open(:bgm2, "clambient.it")
+    @mode = nil
+  end
+  attr_accessor :mode
+  
+  class << GameMain
+    def set_mode(mode);   self.instance.mode = mode;   end
+    def mode;             self.instance.mode;          end
+  end
+    
+  def enabled
+    (@mode==:endless) ? Sound.play(:bgm2) : Sound.play(:bgm)
+    Bath.enable
+    Jumpers.enable
+    TaskManager.reset
+  end
+  
+  def disabled
+    Sound.stop_music
+    Jumpers.disable
+  end
+  
+  def act(dt,i)
+    if @mode==:endless && i.keydown.esc
+      GameMain.disable
+      Gameover.enable
+    end
+  end
+  
+end
+
+class ModeSelect
+  extend SingleTask
+  
+  MODES = [:easy, :normal, :endless]
+  HEIGHT = [180,220,260]
+  LEFT = 100
+  
+  def init
+    @font=SDL::TTF.open("image/boxfont2.ttf", 40)
+    @movetimer = Timer.new(100)
+    @cur = 0
+  end
+  
+  def enabled
+    Highscore.enable
+    Highscore.instance.show = MODES[@cur]
+  end
+  
+  def act(dt,i)
+    if i.keydown.left
+      @cur-=1
+      @cur = MODES.size-1 if @cur<0
+      Highscore.instance.show = MODES[@cur]
+    elsif i.keydown.right
+      @cur+=1
+      @cur = 0 if @cur>MODES.size-1
+      Highscore.instance.show = MODES[@cur]
+    elsif i.keydown.button
+      self.disable
+      Highscore.disable
+      GameMain.set_mode(MODES[@cur])
+      GameMain.enable
+    end
+  end
+  
+  def draw(i)
+    @font.drawBlendedUTF8(i.scr, "  EASY",    LEFT,HEIGHT[0], 0,0,0)
+    @font.drawBlendedUTF8(i.scr, "  NORMAL",  LEFT,HEIGHT[1], 0,0,0)
+    @font.drawBlendedUTF8(i.scr, "  ENDLESS", LEFT,HEIGHT[2], 0,0,0)
+    @font.drawBlendedUTF8(i.scr, "*",         LEFT,HEIGHT[@cur], 0,0,0)
+  end
+  
+end
+
+class Gameover
+  extend SingleTask
+  
+  def init
+    @font = SDL::TTF.open("image/boxfont2.ttf", 48)
+    @flashtimer = Timer.new(700)
+    @draw = true
+  end
+  
+  def act(dt,i)
+    @flashtimer.wait(dt){
+      @draw = (@draw ? false : true)
+    }
+    if i.keydown.button
+      i.keydown.reset
+      self.disable
+      Bath.disable
+      newscore = (GameMain.mode==:endless ? i.score.max : i.score.value)
+      if Highscore.instance.high?(newscore)
+        NameEntry.enable
+      else
+        ModeSelect.enable
+      end
+    end
+  end
+  
+  def draw(i)
+    @font.drawBlendedUTF8(i.scr,"HIT ENTER KEY", 160,220 , 0,0,0) if @draw
+  end
+  
+end
+
+class NameEntry
+  extend SingleTask
+  
+  CHARS = []
+  26.times{|i| CHARS << ?A+i}
+  10.times{|i| CHARS << ?0+i}
+  CHARS << -1 # 'BS'
+  CHARS << -2 # 'END'
+  
+  R = 160
+  BASE = Math::PI / 2
+  RAD = Math::PI * 2 / CHARS.size
+  
+  def init
+    @font_small = SDL::TTF.open("image/curving.ttf", 10)
+    @font       = SDL::TTF.open("image/curving.ttf", 24)
+    @font_big   = SDL::TTF.open("image/curving.ttf", 30)
+    @waittimer = Timer.new(100)
+    @name = ""
+    @cur = 0
+  end
+  
+  def enabled
+    Bath.enable
+    Jumpers.disable
+  end
+  
+  def act(dt,i)
+    if i.keydown.other
+      i.keydown.other.each do |sym|
+        case sym
+        when SDL::Key::BACKSPACE, SDL::Key::DELETE
+          @name.chop!
+        when (SDL::Key::A..SDL::Key::Z)
+          if sym==SDL::Key::H && i.key.ctrl
+            @name.chop!
+          else
+            @cur = sym - SDL::Key::A
+            @name << (?A + @cur).chr
+          end
+        when (SDL::Key::K0..SDL::Key::K9)
+          @cur = sym - SDL::Key::K0
+          @name << (?0 + @cur).chr
+        when (SDL::Key::KP0..SDL::Key::KP9)
+          @cur = sym - SDL::Key::KP0
+          @name << (?0 + @cur).chr
+        end
+      end
+    end
+    
+    if i.keydown.button
+      case CHARS[@cur]
+      when -1 # BS
+        @name.chop!
+      when -2 # END
+        newscore = (GameMain.mode==:endless ? i.score.max : i.score.value)
+        Highscore.instance.add( newscore, @name.dup )
+        self.disable
+        Bath.disable
+        ModeSelect.enable
+      else
+        if i.keydown.other && i.keydown.other.include?(SDL::Key::RETURN)
+          @cur = CHARS.size-1
+        else
+          @name << CHARS[@cur].chr
+        end
+      end
+    end
+    
+    @waittimer.wait(dt){
+      if i.key.left
+        @cur -= 1
+        @cur = CHARS.size-1 if @cur<0
+      elsif i.key.right
+        @cur += 1
+        @cur = 0 if @cur>CHARS.size-1
+      end
+    }
+  end
+  
+  def draw(i)
+    CHARS.each_with_index do |c,n|
+      x = 320 + (R * Math.sin(RAD*(n-@cur)))
+      y = 200 + (R * Math.cos(RAD*(n-@cur)))
+      color = (n==@cur) ? [255,80,80] : [80,80,80]
+      
+      if c==-1 # BS
+        @font_small.drawBlendedUTF8(i.scr, "D", x,y       , *color)
+        @font_small.drawBlendedUTF8(i.scr, "E", x+5,y+5   , *color)
+        @font_small.drawBlendedUTF8(i.scr, "L", x+10,y+10 , *color)
+      elsif c==-2 # END
+        @font_small.drawBlendedUTF8(i.scr, "E", x,y       , *color)
+        @font_small.drawBlendedUTF8(i.scr, "N", x+5,y+5   , *color)
+        @font_small.drawBlendedUTF8(i.scr, "D", x+10,y+10 , *color)
+      elsif n==@cur
+        @font_big.drawBlendedUTF8(i.scr, c.chr, x,y , *color)
+      else
+        @font.drawBlendedUTF8(    i.scr, c.chr, x,y , *color)
+      end
+    end
+    
+    x = 320 - @font_big.textSize(@name).first / 2
+    @font_big.drawBlendedUTF8(i.scr, @name, x,192 , 255,80,80)
+  end
+  
+end
+

data/bathtub/score.rb

@@ -0,0 +1,121 @@
+#
+# score.rb
+#
+
+class Score
+  extend SingleTask
+  
+  def init
+    @font=SDL::TTF.open("image/boxfont2.ttf", 40)
+  end
+  
+  def reset
+    @life = Consts::LIVES
+    @score = 0
+    @max = 0
+  end
+  attr_accessor :score
+  attr_reader :max
+  
+  def value
+    @score
+  end
+  
+  def incr
+    @score+=1
+    @max = @score if @max < @score
+  end
+  
+  def miss
+    if GameMain.mode==:endless
+      @max = @score if @max < @score
+      @score = 0
+    else
+      @life -= 1
+      if @life < 0
+        GameMain.disable
+        Gameover.enable
+        @life = 0
+      end
+    end
+  end
+  
+  def draw(i)
+    if GameMain.mode==:endless
+      @font.drawBlendedUTF8(i.scr," LIFE: .. MAXCOMBO:#{'%3d' % @max}", 0,0 , 0,0,0)
+    else
+      lifemeter = '*'*@life + ' '*(Consts::LIVES-@life)
+      @font.drawBlendedUTF8(i.scr," LIFE: #{lifemeter} SCORE:#{'%3d' % @score}", 0,0 , 0,0,0)
+    end
+
+  end
+  
+end
+
+
+module Enumerable
+  def stable_sort
+    i = 0
+    self.sort_by{|v| [v, i += 1]}
+  end
+end
+
+
+class Highscore
+  extend SingleTask
+  
+  N = 5
+  FILE = "highscore.dat"
+  
+  def init
+    @font = SDL::TTF.open("image/boxfont2.ttf", 25)
+    @scores = read() || Hash.new
+    ModeSelect::MODES.each do |mode|
+      @scores[mode] ||= []
+    end
+    @show = nil
+  end
+  attr_reader :scores
+  attr_writer :show
+  
+  def high?(score)
+    p score, @scores
+    return false if score==0
+    mode = GameMain.mode
+    @scores[mode].empty? || @scores[mode].size < N || @scores[mode].last[0] < score
+  end
+  
+  def add(score,name)
+    return unless high?(score)
+    mode = GameMain.mode
+    @scores[mode] << [score, name]
+    @scores[mode] = @scores[mode].stable_sort.reverse[0,N]
+    write
+  end
+  
+  def read
+    ret = nil
+    if File.exist?(FILE)
+      open(FILE,"rb") do |f|
+        ret = Marshal.load(f)
+      end
+    end
+    ret
+  end
+  
+  def write
+    open(FILE,"wb") do |f|
+      Marshal.dump(@scores,f)
+    end
+  end
+  
+  def draw(i)
+    @font.drawBlendedUTF8(i.scr, "* HighScore *",                380,38,        0,0,255)
+    @scores[@show].each_with_index do |item,n|
+      score,name = *item
+      @font.drawBlendedUTF8(i.scr, "#{n+1}. #{score} (#{name})", 380,65+(20*n), 0,0,255)
+    end
+  end
+  
+end
+

data/bathtub/task.rb

@@ -0,0 +1,63 @@
+#
+# task.rb
+#
+
+class TaskManager
+  
+  class << TaskManager
+    def init
+      @@task = []
+    end
+
+    def add_task(t)
+      @@task << t
+    end
+
+    def reset
+      @@task.each{|t| t.reset}
+    end
+    def draw(info)
+      @@task.each{|t| t.draw(info) if t.active?}
+    end
+    def act(dt,info)
+      @@task.each{|t| t.act(dt,info) if t.active?}
+      @@task.delete_if{|t| !t.alive}
+    end
+  end
+  
+end
+
+module Task
+  Info = Struct.new(:key,:keydown,:scr,:score)
+  
+  def initialize
+    @active = true
+    @alive = true
+    TaskManager.add_task(self)
+    init
+  end
+  attr_accessor :alive
+  
+  def active?;  @active;                   end
+  def enable;   @active = true;  enabled;  end
+  def disable;  @active = false; disabled; end
+  
+  def enabled;  end
+  def disabled; end
+  
+  def init; end
+  def act(dt,info); end
+  def draw(info); end
+  def reset; end
+end
+
+module SingleTask
+  def self.extended(klass)
+    klass.__send__ :include, Singleton
+    klass.__send__ :include, Task
+  end
+  
+  def active?;  self.instance.active?;  end
+  def enable;   self.instance.enable;   end
+  def disable;  self.instance.disable;  end
+end

data/bin/bathtub

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+Dir.chdir File.expand_path("..", File.dirname(__FILE__))
+require 'bathtub/main'
+
+Main.new(ARGV[0] == "-f").run

data/readme.txt

@@ -0,0 +1,38 @@
+
+�o �X �^ �u �� �� ��
+
+ C67 �o�[�W����
+
+�y�O����z
+��N��C65�ɂ�EndEffector�́u���܂��v�Ƃ��Ď��^����Ă����o�X�^�u�꒼�����A
+�P�N�̎����o�Ă����ɕ����I�i�������悤�Ȃ����ł��Ȃ��悤�ȕ��͋C�����y���݂��������B
+
+�y�V�ѕ��z
+��������`���Ĕ��ł���l�X���A�o�X�^�u�ŃL���b�`���Ă��������B
+�R��~�X��ƃQ�[���I�[�o�[�ł��B
+
+ EASY: �ȒP�ł��B
+ NORMAL: �ӂ‚��ł��B
+ ENDLESS: �u�I��肪�Ȃ��v�Ə����ăG���h���X�ł��B�O������ESC�L�[�ŏI�����Ă��������B :-P
+
+�y����z
+���E�L�[�ňړ��B
+�������́A�X�y�[�Xor�G���^�[�L�[�ŕ����]���B
+
+�l�[���G���g���[�͍��E�ňړ��A�X�y�[�X�L�[�Ō���B�i���̓L�[�{�[�h���g���܂��j
+
+�y�ӎ��z
+�o�X�^�u�꒼����Ruby/SDL��p���Đ��삳��Aexerb��p���Ď��s�t�@�C����
+���܂����B
+- �I�u�W�F�N�g�w���X�N���v�g����Ruby: http://www.ruby-lang.org/ja/
+- SDL(Simple DirectMedia Layer): http://www.libsdl.org/
+- Ruby/SDL: http://www.kmc.gr.jp/~ohai/rubysdl.html
+- exerb: http://exerb.sourceforge.jp/
+
+�܂��o�X�^�u�ɔ�э��ތ��ʉ���WEB WAVE LIB�l�̂��̂��g�킹�Ă�����Ă܂��B
+- WEB WAVE LIB: http://www.s-t-t.com/wwl/
+
+----
+yhara�i�� �I�j/ ����}�C�R���N���u
+http://mono.kmc.gr.jp/~yhara/
+mailto: yhara@kmc.gr.jp

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification 
+name: bathtub
+version: !ruby/object:Gem::Version 
+  hash: 15
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 2
+  version: 0.5.2
+platform: ruby
+authors: 
+- Yutaka HARA
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-28 00:00:00 +09:00
+default_executable: bathtub
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rubysdl
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: An action game written with Ruby/SDL
+email: yutaka.hara/at/gmail.com
+executables: 
+- bathtub
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- SDL.dll
+- SDL_mixer.dll
+- SDL_ttf.dll
+- SGE.dll
+- VERSION
+- bathtub.exe
+- bathtub/character.rb
+- bathtub/game.rb
+- bathtub/graphic.rb
+- bathtub/main.rb
+- bathtub/misc.rb
+- bathtub/scene.rb
+- bathtub/score.rb
+- bathtub/task.rb
+- bin/bathtub
+- highscore.dat
+- image/back.bmp
+- image/bath.bmp
+- image/boxfont2.ttf
+- image/curving.ttf
+- image/hito.bmp
+- image/icon-16164.bmp
+- image/icon-16168.bmp
+- image/icon.bmp
+- image/logo.bmp
+- image/shibuki.bmp
+- image/staff.bmp
+- msvcr71.dll
+- readme.txt
+- sound/BB_Scratch_19.wav
+- sound/SplashA1@22.wav
+- sound/Stabs110.wav
+- sound/Stabs63.wav
+- sound/blacksamba.it
+- sound/bom08.wav
+- sound/clambient.it
+- sound/fall.wav
+- sound/get.wav
+has_rdoc: true
+homepage: http://github.com/yhara/bathtub
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: An action game written with Ruby/SDL
+test_files: []
+