rubysdl 1.3.0

data/sample/joy2.rb

@@ -0,0 +1,81 @@
+#
+# Usage:
+#    ruby joy2.rb [n]
+#      n: if given, use n'th joystick
+#           if not given, show all connected joystick
+# 
+require 'sdl'
+
+White = [255,255,255]
+
+def print_joystick_info
+  for i in 0..SDL::Joystick.num-1
+    print i,":",SDL::Joystick.indexName(0),"\n"
+  end
+end
+
+def display_button_state ( screen, joy )
+  for i in 0..joy.numButtons-1
+    if joy.button(i) then
+      screen.fillRect( i*30+30, 50, 10, 10, [0,0,128] )
+    else
+      screen.fillRect( i*30+30, 50, 10, 10, White )
+    end
+  end
+end
+
+def display_hat_state ( screen, joy )
+  # display the state of only first hat  
+  if joy.numHats > 0 then
+    x = y = 0
+    x = 1 if  ( joy.hat(0) & SDL::Joystick::HAT_RIGHT ) != 0
+    x = -1 if ( joy.hat(0) & SDL::Joystick::HAT_LEFT ) != 0
+    y = 1 if ( joy.hat(0) & SDL::Joystick::HAT_DOWN ) != 0
+    y = -1 if ( joy.hat(0) & SDL::Joystick::HAT_UP ) != 0
+    screen.fillRect( 450 + x*40, 200 + y*40, 10, 10, White )
+  end
+end
+
+def display_axis_state ( screen, joy )
+  for i in 0..joy.numAxes-1
+    screen.fillRect( i*30+130, joy.axis(i)*100/32768+200, 20, 20, White )
+  end
+end
+
+SDL.init( SDL::INIT_VIDEO|SDL::INIT_JOYSTICK )
+screen = SDL::setVideoMode(640, 480, 16, SDL::SWSURFACE)
+
+if SDL::Joystick.num == 0 then
+  print "No joystick available\n"
+  exit
+end
+
+if ARGV.size == 0 then
+  print_joystick_info
+  exit
+end
+
+joynum = ARGV[0].to_i
+
+if SDL::Joystick.num < joynum then
+  print "Joystick No.#{joynum} is not available\n"
+  exit
+end
+
+joy=SDL::Joystick.open(joynum)
+
+while true
+
+  while event = SDL::Event2.poll
+    case event
+    when SDL::Event2::KeyDown, SDL::Event2::Quit
+      exit
+    end
+  end
+  SDL::Joystick.updateAll
+  screen.fillRect(0,0,640,480,0)
+  display_button_state screen, joy
+  display_hat_state screen, joy
+  display_axis_state screen, joy
+  screen.updateRect(0, 0, 0, 0)
+end

data/sample/kanji.rb

@@ -0,0 +1,36 @@
+#!/usr/local/bin/ruby -Ke
+#
+# This sample needs following two bdf files
+#   8x16.bdf     : alphabets
+#   jiskan16.bdf : chinese characters and kana
+# 
+require 'sdl'
+
+SDL.init( SDL::INIT_VIDEO )
+screen = SDL::setVideoMode(640,480,16,SDL::SWSURFACE)
+
+font = SDL::Kanji.open("8x16.bdf",16)
+font.add("jiskan16.bdf")
+font.setCodingSystem(SDL::Kanji::EUC)
+
+y = 0
+x = 0
+
+while true
+  while event = SDL::Event2.poll
+    case event
+    when SDL::Event2::KeyDown, SDL::Event2::Quit
+      exit
+    end
+  end
+  screen.fillRect(0,0,640,480,0)
+
+  y = (y + 1) % 480
+  x = (x + 1) % 640
+  
+  font.put(screen,"SDL Kanji�Υƥ�����",40,y,128,128,0)
+  font.putTate(screen,"�Ľ񤭤�Ǥ��ޤ���",x,60,128,128,0)
+               
+  screen.updateRect(0,0,0,0)
+  sleep 0.005
+end

data/sample/movesp.rb

@@ -0,0 +1,93 @@
+require 'sdl'
+
+SDL.init( SDL::INIT_VIDEO )
+
+screen = SDL::setVideoMode(640,480,16,SDL::SWSURFACE)
+
+image = SDL::Surface.loadBMP("icon.bmp")
+image.setColorKey( SDL::SRCCOLORKEY || SDL::RLEACCEL ,0)
+$image = image.displayFormat
+
+
+class Sprite
+  def initialize
+    @x=rand(640)
+    @y=rand(480)
+    @dx=rand(11)-5
+    @dy=rand(11)-5
+  end
+  
+  def move
+    @x += @dx
+    if @x >= 640 then
+      @dx *= -1
+      @x = 639
+    end
+    if @x < 0 then
+      @dx *= -1
+      @x = 0
+    end
+    @y += @dy
+    if @y >= 480 then
+      @dy *= -1
+      @y = 479
+    end
+    @y += @dy
+    if @y < 0 then
+      @dy *= -1
+      @y = 0
+    end
+  end
+  
+  def draw(screen)
+    SDL.blitSurface($image,0,0,32,32,screen,@x,@y)
+  end
+  
+end
+
+sprites = []
+for i in 1..5
+  sprites << Sprite.new
+end
+
+class MovableSp
+  def initialize()
+    @ud=@lr=0;
+  end
+  
+  def move()
+    @ud=@lr=0;
+    @lr=-1 if SDL::Key.press?(SDL::Key::H) or SDL::Key.press?(SDL::Key::LEFT)
+    @lr=1  if SDL::Key.press?(SDL::Key::L) or SDL::Key.press?(SDL::Key::RIGHT)
+    @ud=1  if SDL::Key.press?(SDL::Key::J) or SDL::Key.press?(SDL::Key::DOWN)
+    @ud=-1 if SDL::Key.press?(SDL::Key::K) or SDL::Key.press?(SDL::Key::UP)
+  end
+  
+  def draw(screen)
+    SDL.blitSurface($image,0,0,32,32,screen,300+@lr*50,200+@ud*50)
+  end
+end
+
+sprites << MovableSp.new
+
+while true
+  while event = SDL::Event2.poll
+    case event
+    when SDL::Event2::Quit
+      exit
+    when SDL::Event2::KeyDown
+      exit if event.sym == SDL::Key::ESCAPE
+    end
+  end
+  
+  screen.fillRect(0,0,640,480,0)
+  SDL::Key.scan
+  
+  sprites.each {|i|
+    i.move
+    i.draw(screen)
+  }
+  screen.updateRect(0,0,0,0)
+end
+
+

data/sample/playmod.rb

@@ -0,0 +1,14 @@
+# This sample needs a mod file `sample.it'.
+#
+require 'sdl'
+SDL::init(SDL::INIT_AUDIO)
+
+SDL::Mixer.open(22050)
+SDL::Mixer::playMusic?
+music = SDL::Mixer::Music.load("sample.it")
+
+SDL::Mixer.playMusic(music,0)
+
+while SDL::Mixer::playMusic?
+  sleep 1
+end

data/sample/plaympeg.rb

@@ -0,0 +1,48 @@
+# This sample needs a MPEG file `sample.mpg'.
+require 'sdl'
+
+SDL.init( SDL::INIT_VIDEO|SDL::INIT_AUDIO )
+SDL::Mixer.open
+
+screen = SDL.setVideoMode( 320, 240, 16, SDL::SWSURFACE )
+
+mpeg = SDL::MPEG.load( 'sample.mpg' )
+
+info = mpeg.info
+
+p(info)
+
+mpeg.enableAudio true
+mpeg.enableVideo true
+
+mpeg.setDisplay(screen)
+mpeg.setDisplayRegion( 0, 0, screen.w, screen.h )
+mpeg.play
+
+loop do
+
+  case event = SDL::Event2.poll
+  when SDL::Event2::Quit
+    mpeg.stop
+    exit
+  when SDL::Event2::KeyDown
+    case event.sym
+    when SDL::Key::S
+      mpeg.stop
+    when SDL::Key::P
+      mpeg.play
+    when SDL::Key::R
+      mpeg.rewind
+    when SDL::Key::ESCAPE
+      exit      
+    end
+  end
+
+  if mpeg.status != SDL::MPEG::PLAYING then
+    mpeg.stop
+    exit
+  end
+      
+  sleep 0.1
+  
+end

data/sample/playwave.rb

@@ -0,0 +1,16 @@
+# This sample needs a wave file `sample.wav', please prepare.
+require 'sdl'
+
+SDL::init(SDL::INIT_AUDIO|SDL::INIT_VIDEO)
+SDL.setVideoMode(640,480,16,SDL::SWSURFACE)
+
+SDL::Mixer.open
+wave=SDL::Mixer::Wave.load("sample.wav")
+
+SDL::Mixer.playChannel(0,wave,0)
+
+while SDL::Mixer::play?(0)
+  sleep 1
+end
+
+

data/sample/randrect.rb

@@ -0,0 +1,40 @@
+# SDL random rect sample
+# original code by adas@geocities.co.jp written by C
+# auther TAMURA Kenichi <sgs02516@nifty.com>
+#
+require 'sdl'
+
+src_w = 640
+src_h = 480
+src_d = 16
+
+dst_w = 0
+dst_h = 0
+
+MAX = 1000
+RECTSIZE = 400
+
+SDL.init SDL::INIT_VIDEO
+screen = SDL::setVideoMode src_w,src_h,src_d, SDL::SWSURFACE|SDL::ANYFORMAT
+
+srand
+
+(1 .. MAX).each do |i|
+  color = screen.mapRGB rand(256),rand(256),rand(256)
+  dst_w = rand(RECTSIZE) + 1
+  dst_h = rand(RECTSIZE) + 1
+  screen.fillRect rand(src_w-dst_w), rand(src_h-dst_h), dst_w, dst_h, color
+  screen.updateRect 0,0,0,0
+
+  while event = SDL::Event2.poll
+    case event
+    when SDL::Event2::Quit
+      exit
+    when SDL::Event2::KeyDown
+      exit if event.sym == SDL::Key::ESCAPE
+    end
+  end
+
+  SDL::Key.scan
+end
+

data/sample/sdlskk.rb

@@ -0,0 +1,70 @@
+#
+# SDLSKK from Ruby/SDL
+#
+# This sample needs three files.
+#   jisyo       : SKK's dictionary
+#   rule_table  : SDLSKK's
+#   nihongo.ttf : True Type Font file that has Japanese characters
+#
+# Usage:
+#   ruby sdlskk.rb [-m]
+#   
+#     -m  Use minibuffer
+#
+require 'sdl'
+
+use_minibuffer = (ARGV[0]=='-m')
+  
+SDL.init( SDL::INIT_VIDEO )
+SDL::TTF.init
+SDL::Event2.enableUNICODE
+
+font = SDL::TTF.open( 'nihongo.ttf', 14 )
+
+dict = SDL::SKK::Dictionary.new
+dict.load( 'jisyo', false )
+table = SDL::SKK::RomKanaRuleTable.new( 'rule_table' )
+bind = SDL::SKK::Keybind.new
+bind.set_default_key
+
+context = SDL::SKK::Context.new( dict, table, bind, use_minibuffer )
+
+screen = SDL::setVideoMode( 640, 480, 16, SDL::SWSURFACE )
+SDL::WM.setCaption( $0, $0 )
+
+BLACK = screen.mapRGB( 0, 0, 0 )
+loop do
+
+  while event = SDL::Event2.poll do
+    case event
+    when SDL::Event2::Quit
+      exit
+    when SDL::Event2::KeyDown
+      if event.sym == SDL::Key::ESCAPE then
+	exit
+      end
+      if event.sym == SDL::Key::F1
+	dict.save("test_user_dict")
+      end
+      
+      context.input( event )      
+    end
+  end
+
+  text_surface = context.render_str( font, 255, 0, 255 )
+
+  screen.fillRect( 0, 0, 640, 480, BLACK )
+  SDL.blitSurface( text_surface, 0, 0, 0, 0, screen, 0, 0 )
+
+  if use_minibuffer then
+    minibuffer_surface = context.render_minibuffer_str( font, 255, 0, 255 )
+    if minibuffer_surface then
+      SDL.blitSurface( minibuffer_surface, 0, 0, 0, 0, screen, 0, 40 )
+    end
+  end
+  
+  screen.updateRect( 0, 0, 0, 0 )
+
+  sleep 0.05
+  
+end

data/sample/sgetest.rb

@@ -0,0 +1,31 @@
+require 'sdl'
+
+SDL.init( SDL::INIT_VIDEO )
+screen = SDL::setVideoMode(640,480,16,SDL::SWSURFACE)
+SDL::WM::setCaption $0, $0
+
+# draw red pixel at (200,200)
+screen[200,200]= screen.format.mapRGB(255,0,0)
+# draw green pixel at (250,200)
+screen[250,200]= screen.format.mapRGB(0,255,0)
+# draw blue pixel at (200,200)
+screen[300,200]= screen.format.mapRGB(0,0,255)
+
+Red=screen.format.mapRGB(255,0,0)
+screen.drawLine(20,20,300,200,Red)
+screen.drawRect(49,59,80,80,Red)
+screen.drawCircle(100,100,50,[87,87,87])
+screen.drawFilledCircle(300,300,30,Red)
+
+screen.flip
+
+while true
+  while event = SDL::Event2.poll
+    case event
+    when SDL::Event2::KeyDown, SDL::Event2::Quit
+      exit
+    end
+  end
+
+  sleep 0.2
+end

data/sample/stetris.rb

@@ -0,0 +1,275 @@
+# This sample need ruby 1.8 or 1.6 with shim
+# Thanks to Simon Strandgaard
+require 'sdl'
+if RUBY_VERSION < "1.7" then
+  require 'features/ruby18'
+end
+
+class Object
+  def deep_clone
+    Marshal::load(Marshal.dump(self))
+  end
+end
+
+class Array
+  def random
+    at(Kernel.rand(size))
+  end
+end
+
+class Pattern
+  def initialize(x, y, *data)
+    @x = x
+    @y = y
+    @data = data
+  end
+  attr_reader :data, :x, :y
+  alias width x
+  def rotate
+    @data = @data.reverse.transpose
+    @x, @y = @y, @x
+  end
+  PAT1 = Pattern.new(4, 1, [1, 1, 1, 1])
+  PAT2 = Pattern.new(3, 2, [1, 1, 1], [0, 1, 0])
+  PAT3 = Pattern.new(3, 2, [1, 1, 1], [1, 0, 0])
+  PAT4 = Pattern.new(3, 2, [1, 1, 1], [0, 0, 1])
+  PAT5 = Pattern.new(2, 2, [1, 1], [1, 1])
+  PAT6 = Pattern.new(3, 2, [1, 1, 0], [0, 1, 1])
+  PAT7 = Pattern.new(3, 2, [0, 1, 1], [1, 1, 0])
+  def Pattern::patterns
+    [PAT1, PAT2, PAT3, PAT4, PAT5, PAT6, PAT7]
+  end
+end
+
+class Level
+  def initialize(width=10, height=15)
+    @height = height
+    @width = width
+    @data = Array.new(height) { Array.new(width, 0) }
+    backup_background
+  end
+  attr_reader :width, :height
+  def test
+    @data[0][0] = 1
+    @data[0][@width-1] = 1
+    @data[@height-1][0] = 1
+    @data[@height-1][@width-1] = 1
+  end
+  def bg_is_collision(offset_x, offset_y, pattern)
+    return true if pattern.x + offset_x > @width
+    return true if pattern.y + offset_y > @height
+    y = offset_y
+    pattern.data.each do |row|
+      x = offset_x
+      row.each do |cell|
+	if (cell != 0) and (@bg[y][x] != 0)
+	  return true
+	end
+	x += 1
+      end
+      y += 1
+    end
+    return false
+  end
+  def restore_background
+    @data = @bg
+  end
+  def backup_background
+    @bg = @data.deep_clone
+  end
+  def or_pattern(offset_x, offset_y, pattern)
+    backup_background
+    y = offset_y
+    pattern.data.each do |row|
+      x = offset_x
+      row.each do |cell|
+	@data[y][x] = cell if cell != 0
+	x += 1
+      end
+      y += 1
+    end
+  end
+  def find_filled_rows 
+    res = []
+    @data.each_index do |y|
+      ok = true
+      @data[y].each do |cell|
+	if cell == 0
+	  ok = false 
+	  break
+	end
+      end
+      res << y if ok
+    end
+    res
+  end
+  def remove_rows(*rows)
+    rows.uniq!
+    rows.each do |y|
+      @bg[y] = nil
+    end
+    @bg.compact!
+    extra = Array.new(rows.size) { Array.new(@width, 0) }
+    @bg = extra + @bg
+    raise "integrity error" if @bg.size != @height
+  end
+end
+
+class Level
+  def load_render_data
+    @image = SDL::Surface.loadBMP("icon.bmp")
+    @image.setColorKey( SDL::SRCCOLORKEY ,0)
+    @image = @image.displayFormat
+    @step_x = 32  # todo: image width
+    @step_y = 32  # todo: image height
+    # todo: raise exception is level does not fit to screen!
+    @offset_x = 100
+    @offset_y = 20
+    
+    @fill_removal_dir = false
+  end
+  def render
+    y = @offset_y
+    @data.each do |row|
+      render_line(y, row)
+      y += @step_y
+    end
+  end
+  def render_line(y, cells)
+    x = @offset_x
+    cells.each do |cell|
+      i = (cell == 0) ? 63 : 255
+      @image.setAlpha(SDL::SRCALPHA,i)
+      $screen.put(@image,x,y)
+      x += @step_x
+    end
+  end
+  FILL = (20 * 256*256) + (0 * 256) + 10
+  def render_removal(rows)
+    $screen.fillRect(0,0,640,512,0)
+    render
+    rows.reverse_each do |row|
+      y = (row * @step_y) + @offset_y
+      
+      if @fill_removal_dir
+	i = 0
+	x = @offset_x
+	while i < @width
+	  $screen.fillRect(x,y,@step_x,@step_y,FILL)
+	  $screen.flip
+	  i += 1
+	  x += @step_x
+	end
+	@fill_removal_dir = false
+      else
+	i = 0
+	x = @offset_x + ((@width-1)*@step_x)
+	while i < @width
+	  $screen.fillRect(x,y,@step_x,@step_y,FILL)
+	  $screen.flip
+	  i += 1
+	  x -= @step_x
+	end
+	@fill_removal_dir = true
+      end
+    end
+  end
+end
+
+SDL.init( SDL::INIT_VIDEO )
+$screen = SDL::setVideoMode(640,512,24,SDL::SWSURFACE)
+level = Level.new
+level.test
+level.load_render_data
+pat = Pattern::PAT3.clone
+pat_x = 5
+pat_y = 0
+time_step = 0.5
+time = Time.now
+launch_new_pattern = true
+loop do
+  if launch_new_pattern
+    launch_new_pattern = false
+    time_step = 0.5
+    time = Time.now
+    pat = Pattern::patterns.random.clone
+    pat_x = 5
+    pat_y = 0
+    level.backup_background
+    if level.bg_is_collision(pat_x, pat_y, pat)
+      puts "Sorry you are game over"
+      sleep 3
+      raise "game over"
+    end
+    level.or_pattern(pat_x, pat_y, pat)
+  end
+  
+  # timer events
+  while Time.now > time + time_step
+    pat_y += 1
+    if level.bg_is_collision(pat_x, pat_y, pat)
+      launch_new_pattern = true
+      rows = level.find_filled_rows
+      if rows.size > 0
+	puts "rows filled"
+	p rows
+	level.render_removal(rows)
+	
+	level.backup_background
+	level.remove_rows(*rows)
+	level.restore_background
+      end
+    else
+      level.restore_background
+      level.or_pattern(pat_x, pat_y, pat)
+    end
+    time += time_step
+  end
+  
+  old_pat_x = pat_x
+  old_pat_y = pat_y
+  rotate = false
+  
+  # handle keystrokes
+  while event = SDL::Event2.poll
+    case event
+    when SDL::Event2::Quit then exit
+    when SDL::Event2::KeyDown
+      case event.sym
+      when SDL::Key::ESCAPE then exit 
+      when SDL::Key::UP     then rotate = true
+      when SDL::Key::DOWN   then time_step = 0.1
+      when SDL::Key::LEFT
+	pat_x -= 1 if pat_x > 0
+      when SDL::Key::RIGHT
+	pat_x += 1 if pat_x < (level.width - pat.width)
+      end
+    end
+  end
+  SDL::Key.scan
+  
+  # move pattern & do collition tests
+  if (pat_x <=> old_pat_x) or (pat_y <=> old_pat_y) or (rotate == true)
+    
+    old_pat = pat.clone
+    pat.rotate if rotate
+    
+    # if collision then restore last working-state
+    if level.bg_is_collision(pat_x, pat_y, pat)
+      pat_x = old_pat_x
+      pat_y = old_pat_y
+      pat = old_pat
+    else
+      # collision avoided.. therefore don't launch new pattern
+      launch_new_pattern = false
+      level.restore_background
+      level.or_pattern(pat_x, pat_y, pat)
+    end
+  end
+  
+  # repaint screen
+  $screen.fillRect(0,0,640,512,0)
+  level.render
+  GC.start # release memory.. otherwise it would grow steady
+  $screen.flip
+end