bangkok 0.1.1 → 0.1.2

data/ChangeLog

@@ -1,5 +1,30 @@
+2005-03-26  Jim Menard  <jimm@io.com>
+
+	* lib/bangkok/gamelistener.rb (GameListener::end_game): call
+	Track#sort, not Track#recalc_delta_from_times, because we now
+	generate events out of order.
+	(GameListener::move): generate data differently. Call new
+	generate_* methods. Generate multiple volume and pan values based
+	on distance traveled.
+	(GameListener::interpolate): created.
+	(GameListener::generate_notes): created.
+	(GameListener::file_to_pan): created.
+	(GameListener::rank_to_volume): created.
+	(GameListener::generate_volume): created.
+	(GameListener::generate_pan): created.
+	(GameListener::generate_portamento): created.
+
+	* lib/bangkok/square.rb (Square::distance_to): created.
+	(Square::at): created.
+
+	* lib/bangkok/piece.rb: use new Square.at method where appropriate.
+
+	* lib/bangkok/board.rb: use new Square.at method where appropriate.
+
 2005-03-25  Jim Menard  <jimm@io.com>
 
+	* Version 0.1.1 released.
+
 	* lib/bangkok/chessgame.rb: removed shebang line.
 
 	* lib/bangkok/gamelistener.rb (GameListener::initialize): added

data/README

@@ -15,6 +15,24 @@ version of bangkok may be downloaded. Bangkok is also available as a RubyGem.
 
 === Recent Changes
 
+==== 0.1.2
+
+* GameListener#move outputs two notes for a move and sets CC_PORTAMENTO_TIME
+  so there is a glide from the first note to the second. The total length of
+  the two ntoes is proportional to the distance the piece travels. The first
+  note is short (a 32nd note), and the second takes up the rest of the time,
+  thus allowing the portamento to have its effect.
+
+* GameListener#move also outputs multiple volume and pan values, moving
+  smoothly from the original to the new value for the duration of the move's
+  notes.
+
+* New Square.at method returns a ready-made Square. Since they're immutable,
+  this reduces the number of objects that need to be created.
+
+* More tests.
+
+
 ==== 0.1.1
 
 * Fixed bugs in the bin/bangkok script.

data/Rakefile

@@ -1,5 +1,6 @@
 require 'rubygems'
 require_gem 'rake'
+require 'rake/clean'
 require 'rake/rdoctask'
 require 'rake/gempackagetask'
 require 'rake/contrib/rubyforgepublisher'
@@ -15,6 +16,7 @@ PKG_FILES = FileList[ 'ChangeLog', 'Credits', 'README', 'Rakefile', 'TODO',
                      'install.rb',
                      'lib/**/*.rb',
                      'test/**/*.rb']
+CLEAN.include('game.mid', 'game.txt')
 
 task :default => [:package]
 

data/TODO

@@ -1,20 +1,13 @@
 == Bugs
 
-- Pawn#could_perform_move does not check for en passant.
+- Pawn#could_perform_move does not check for en passant. Might need a new ivar
+  @moved_two_spaces_on_first_move.
 
 - Move#initialize does not handle "e.p." or "ep" in move text.
 
 == To Do
 
-- better way to specify configs/program numbers; file must not live in same
-  directory as source code
-
-- write "-c" code in bin/bangkok and examples
-
-- test bankgok -c examples/program_changes.rb examples/game.pgn
-
-- implement check for en passant in Pawn#could_perform_move. Might need a new
-  ivar @moved_two_spaces_on_first_move.
+- Use Square.at(file, rank) where appropriate
 
 - glide between squares
 

data/lib/bangkok/board.rb

@@ -7,12 +7,12 @@ class Board
     @listener = listener
     @pieces = []
     [:R, :N, :B, :Q, :K, :B, :N, :R].each_with_index { | sym, file |
-      @pieces << Piece.create(self, listener, :white, sym, Square.new(file, 0))
-      @pieces << Piece.create(self, listener, :black, sym, Square.new(file, 7))
+      @pieces << Piece.create(self, listener, :white, sym, Square.at(file, 0))
+      @pieces << Piece.create(self, listener, :black, sym, Square.at(file, 7))
     }
     8.times { | file |
-      @pieces << Piece.create(self, listener, :white, :P, Square.new(file, 1))
-      @pieces << Piece.create(self, listener, :black, :P, Square.new(file, 6))
+      @pieces << Piece.create(self, listener, :white, :P, Square.at(file, 1))
+      @pieces << Piece.create(self, listener, :black, :P, Square.at(file, 6))
     }
   end
 
@@ -46,25 +46,25 @@ class Board
   def apply_castle(move)
     new_king_file = nil
     new_rook_file = nil
-    king = @pieces.detect{ | p | p.piece == :K && p.color == move.color }
+    king = @pieces.detect { | p | p.piece == :K && p.color == move.color }
     rook = nil
 
     if move.queenside_castle?
       new_king_file = king.square.square.file - 2
-      rook = @pieces.detect{ | p |
+      rook = @pieces.detect { | p |
         p.piece == :R && p.color == move.color && p.square.file == 0
       }
       new_rook_file = rook.square.file + 3
     else # kingside castle
       new_king_file = king.square.file + 2
-      rook = @pieces.detect{ | p |
+      rook = @pieces.detect { | p |
         p.piece == :R && p.color == move.color && p.square.file == 7
       }
       new_rook_file = rook.square.file - 2
     end
 
-    king.move_to(Square.new(new_king_file, king.square.rank))
-    rook.move_to(Square.new(new_rook_file, rook.square.rank))
+    king.move_to(Square.at(new_king_file, king.square.rank))
+    rook.move_to(Square.at(new_rook_file, rook.square.rank))
   end
 
   def remove_from_board(piece)

data/lib/bangkok/gamelistener.rb

@@ -24,15 +24,6 @@ class GameListener
   RANK_TO_NOTE[:white] = [64, 66, 68, 69, 71, 73, 75, 76]
   RANK_TO_NOTE[:black] = RANK_TO_NOTE[:white].reverse
 
-  # Build array that maps file number to pan value
-  FILE_TO_PAN = []
-  8.times { | i | FILE_TO_PAN << ((127.0/7.0) * i).to_i }
-
-  # Build array that maps rank number to volume value
-  RANK_TO_VOL = []
-  4.times { | i | RANK_TO_VOL << 10 + ((117.0 / 3.0) * i).to_i }
-  4.times { | i | RANK_TO_VOL << 127 - (((117.0 / 3.0) * i).to_i) }
-
   PIECE_MIDI_INFO = {}
   PIECE_MIDI_INFO[:white] = {}
   PIECE_MIDI_INFO[:black] = {}
@@ -99,7 +90,10 @@ class GameListener
     track.name = "Tempo track"
     @seq.tracks << track
 
-    @cached_quarter_delta = @seq.note_to_delta('quarter')
+    @first_note_delta = @seq.note_to_delta('32nd')
+    @portamento_start = @seq.note_to_delta('64th')
+    @max_delta =
+	@seq.length_to_delta(Square.at(0, 0).distance_to(Square.at(7, 7)))
 
     create_tracks()
     @time_from_start = 0
@@ -107,20 +101,47 @@ class GameListener
 
   def end_game
     # When we created events, we set their start times, not their delta times.
-    # Now is the time to fix that.
-    @seq.tracks.each { | t | t.recalc_delta_from_times }
+    # Now is the time to fix that. Sort sorts by start times then calls
+    # recalc_delta_from_times.
+    @seq.tracks.each { | t | t.sort }
     @seq.write(@io)
   end
 
+  # Move +piece+ +from+ one space +to+ another. Generate two notes and sets
+  # CC_PORTAMENTO_TIME so there is a glide from the first note to the second.
+  # Also output multiple volume and pan values, moving smoothly from the
+  # original to the new value.
   def move(piece, from, to)
-    if to.on_board?
-      midi_for_position(piece, from)
-      midi_for_position(piece, Square.new((from.file.to_f + to.file.to_f) / 2,
-                                          (from.rank.to_f + to.rank.to_f) / 2))
-      midi_for_position(piece, to)
-    end
+    raise "from #{from} may not be off the board" unless from.on_board?
+
     # Do nothing if the piece moves off the board, because either capture()
     # or pawn_to_queen() will be called.
+    return unless to.on_board?
+
+    track = track_of(piece)
+    channel = channel_of(piece)
+
+    dist = from.distance_to(to)
+    total_delta = @seq.length_to_delta(dist) # quarter note per space
+
+    generate_notes(track, channel, total_delta, piece, from, to)
+    generate_portamento(track, channel, total_delta)
+
+    steps = interpolate(16, 64, 0, @max_delta, total_delta).to_i
+    delta = (total_delta / steps).to_i
+    start = @time_from_start
+
+    steps.times { | step |
+      val = rank_to_volume(interpolate(from.rank, to.rank, 0, steps-1, step))
+      generate_volume(track, channel, start, val)
+      
+      val = file_to_pan(interpolate(from.file, to.file, 0, steps-1, step))
+      generate_pan(track, channel, start, val)
+
+      start += delta
+    }
+
+    @time_from_start += total_delta
   end
 
   def capture(attacker, loser)
@@ -157,31 +178,84 @@ class GameListener
     }
   end
 
-  def midi_for_position(piece, square)
-    track = track_of(piece)
-    channel = channel_of(piece)
+  # Returns a value between range_min and range_max inclusive that is
+  # proportional to +value+'s place between value_min and value_max. The
+  # returned value may be floating point. If range_min and range_max or
+  # value_min and value_max are out of order, they are swapped.
+  def interpolate(range_min, range_max, value_min, value_max, value)
+    range_min, range_max = range_max, range_min if range_min > range_max
+    value_min, value_max = value_max, value_min if value_min > value_max
+    return range_min if value == value_min
+    frac = (value_max.to_f - value_min.to_f) / (value.to_f - value_min.to_f)
+    return range_min + (range_max.to_f - range_min.to_f) / frac
+  end
 
-    # pan
-    e = Controller.new(channel, CC_PAN, FILE_TO_PAN[square.file])
+  # Generate two notes, one at the current start time that is only a 32nd note
+  # long. The next follows immediately, and is for the +to+ square. Its length
+  # is the remaining time.
+  def generate_notes(track, channel, total_delta, piece, from, to)
+    # First note is quickly followed by the second note
+    note = RANK_TO_NOTE[piece.color][from.rank]
+    e = NoteOnEvent.new(channel, note, 127)
     e.time_from_start = @time_from_start
     track.events << e
 
-    # volume
-    e = Controller.new(channel, CC_VOLUME, RANK_TO_VOL[square.rank])
-    e.time_from_start = @time_from_start
+    e = NoteOffEvent.new(channel, note, 127)
+    e.time_from_start = @time_from_start + @first_note_delta - 1
     track.events << e
 
-    # note on and off
-    note = RANK_TO_NOTE[piece.color][square.rank]
+    # Second note
+    note = RANK_TO_NOTE[piece.color][to.rank]
     e = NoteOnEvent.new(channel, note, 127)
-    e.time_from_start = @time_from_start
+    e.time_from_start = @time_from_start + @first_note_delta
     track.events << e
 
     e = NoteOffEvent.new(channel, note, 127)
-    e.time_from_start = @time_from_start + @cached_quarter_delta
+    e.time_from_start = @time_from_start + total_delta - 1
     track.events << e
+  end
+
+  # Translates a (possibly fractional) +file+ into an integer CC_PAN value.
+  def file_to_pan(file)
+    return interpolate(0, 127, 0, 7, file).to_i
+  end
 
-    @time_from_start = e.time_from_start
+  # Translates a (possibly fractional) +rank+ into an integer CC_VOLUME value.
+  def rank_to_volume(rank)
+    rank = 3.5 - (3.5 - rank).abs
+    return interpolate(10, 127, 0, 3.5, rank).to_i
+  end
+
+  # Generates a single volume event. #move_to calls this multiple times,
+  # passing in new +delta+ and +value+ values.
+  def generate_volume(track, channel, delta, value)
+    raise "volume: bogus value #{value}" unless value >= 0 && value <= 127
+    e = Controller.new(channel, CC_VOLUME, value)
+    e.time_from_start = @time_from_start + delta
+    track.events << e
+  end
+
+  # Generates a single pan event. #move_to calls this multiple times, passing
+  # in new +delta+ and +value+ values.
+  def generate_pan(track, channel, delta, value)
+    raise "pan: bogus value #{value}" unless value >= 0 && value <= 127
+    e = Controller.new(channel, CC_PAN, value)
+    e.time_from_start = @time_from_start + delta
+    track.events << e
+  end
+
+  # Generates a single portamento event.
+  def generate_portamento(track, channel, total_delta)
+    e = Controller.new(channel, CC_PORTAMENTO_TIME, 0)
+    e.time_from_start = @time_from_start
+    track.events << e
+
+    value = interpolate(32, 100, 0, @max_delta, total_delta).to_i
+    raise "portamento: bogus value #{value}" unless value >= 0 && value <= 127
+    e = Controller.new(channel, CC_PORTAMENTO_TIME, value)
+		       
+    e.time_from_start = @time_from_start + @portamento_start
+    track.events << e
   end
 
 end

data/lib/bangkok/info.rb

@@ -1,6 +1,6 @@
 VERSION_MAJOR = 0
 VERSION_MINOR = 1
-VERSION_TWEAK = 1
+VERSION_TWEAK = 2
 
 Version = "#{VERSION_MAJOR}.#{VERSION_MINOR}.#{VERSION_TWEAK}"
 Copyright = 'Copyright (c) 2005 by Jim Menard <jimm@io.com>'

data/lib/bangkok/piece.rb

@@ -65,7 +65,7 @@ class Piece
     end
 
     while curr_file != end_file || curr_rank != end_rank
-      return false unless @board.empty_at?(Square.new(curr_file, curr_rank))
+      return false unless @board.empty_at?(Square.at(curr_file, curr_rank))
       curr_file += file_delta
       curr_rank += rank_delta
     end
@@ -194,7 +194,7 @@ class Pawn < Piece
       elsif !@moved && square.file == @square.file &&
                        square.rank == @square.rank + 2
         # first move: 2 squares forward
-        return @board.empty_at?(Square.new(@square.file, @square.rank + 1)) &&
+        return @board.empty_at?(Square.at(@square.file, @square.rank + 1)) &&
           @board.empty_at?(square)
 
 # TODO Implement en passant checking. The following code was wrong. 
@@ -223,7 +223,7 @@ class Pawn < Piece
       elsif !@moved && square.file == @square.file &&
                        square.rank == @square.rank - 2
         # first move: 2 spaces forward
-        return @board.empty_at?(Square.new(@square.file, @square.rank - 1)) &&
+        return @board.empty_at?(Square.at(@square.file, @square.rank - 1)) &&
           @board.empty_at?(square)
 
 # TODO Implement en passant checking. The following code was wrong. 

data/lib/bangkok/square.rb

@@ -3,6 +3,10 @@ class Square
   attr_reader :file, :rank      # Always 0-7
   attr_reader :color            # :white or :black
 
+  def Square.at(file, rank)
+    SQUARES[file][rank]
+  end
+
   def initialize(*args)
     @file = @rank = @color = nil
     case args[0]
@@ -38,10 +42,25 @@ class Square
     return @file && @rank
   end
 
+  # Return the distance between this square and the other. Returns nil of
+  # eithr square is off the board.
+  def distance_to(square)
+    return nil unless on_board? && square.on_board?
+    d_file = square.file - @file
+    d_rank = square.rank - @rank
+    return Math.sqrt(d_file * d_file + d_rank * d_rank)
+  end
+
   def to_s
     return "<off-board>" if @file.nil? || @rank.nil?
     return "#{@file ? (?a + file).chr : ''}#{@rank + 1}"
   end
 
+  SQUARES = []
+  8.times { | file |
+    SQUARES[file] = []
+    8.times { | rank | SQUARES[file][rank] = Square.new(file, rank) }
+  }
+
   OFF_BOARD = Square.new
 end

data/test/mock_game_listener.rb

@@ -1,22 +1,37 @@
 class MockGameListener
-  def start_game
+  def initialize
+    @called = []
+  end
+
+  def start_game(io)
+    @called << :start_game
   end
 
   def end_game
+    @called << :end_game
   end
 
   def move(piece, from, to)
+    @called << :move
   end
 
   def capture(attacker, loser)
+    @called << :capture
   end
 
   def check
+    @called << :check
   end
 
   def checkmate
+    @called << :checkmate
   end
 
   def pawn_to_queen(pawn)
+    @called << :pawn_to_queen
+  end
+
+  def called(sym)
+    @called.include?(sym)
   end
 end

data/test/test_board.rb

@@ -0,0 +1,62 @@
+require 'test/unit'
+require 'stringio'
+$LOAD_PATH[0, 0] = File.dirname(__FILE__)
+$LOAD_PATH[0, 0] = File.join(File.dirname(__FILE__), '..', 'lib')
+require 'bangkok/piece'
+require 'bangkok/square'
+require 'bangkok/move'
+require 'bangkok/board'
+require 'bangkok/chessgame'
+require 'mock_game_listener'
+
+class BoardTest < Test::Unit::TestCase
+
+  def setup
+    @listener = MockGameListener.new
+    @board = Board.new(@listener)
+  end
+
+  def test_setup
+    8.times { | i |
+      assert_instance_of(Pawn, @board.at(Square.at(i, 1)))
+      assert_instance_of(Pawn, @board.at(Square.at(i, 6)))
+    }
+    [:R, :N, :B, :Q, :K, :B, :N, :R].each_with_index { | sym, file |
+      assert_equal(sym, @board.at(Square.at(file, 0)).piece)
+      assert_equal(sym, @board.at(Square.at(file, 7)).piece)
+    }
+    8.times { | file |
+      4.times { | rank |
+	assert_nil(@board.at(Square.at(file, rank + 2)))
+      }
+    }
+  end
+
+  def test_listener_calls
+    game = ChessGame.new(@listener)
+    game_text = <<EOS
+[Event "?"]
+1. f4 Nf6 2. Nf3 c5 3. e3 d5 4. d4 Bf5 5. c3 e6 6. Bd3 Bxd3 7. Qxd3 Nc6 
+EOS
+    game.read_moves(StringIO.new(game_text))
+
+    out = StringIO.new
+    game.play(out)
+    assert(@listener.called(:start_game))
+    assert(@listener.called(:end_game))
+    assert(@listener.called(:move))
+  end
+
+  def test_midi_output
+    game = ChessGame.new	# default GameListener created
+    game_text = <<EOS
+[Event "?"]
+1. f4 Nf6 2. Nf3 c5 3. e3 d5 4. d4 Bf5 5. c3 e6 6. Bd3 Bxd3 7. Qxd3 Nc6 
+EOS
+    game.read_moves(StringIO.new(game_text))
+
+    out = StringIO.new
+    game.play(out)
+    assert(out.string.length > 0)
+  end
+end

data/test/test_gamelistener.rb

@@ -0,0 +1,32 @@
+require 'test/unit'
+$LOAD_PATH[0, 0] = File.dirname(__FILE__)
+$LOAD_PATH[0, 0] = File.join(File.dirname(__FILE__), '..', 'lib')
+require 'bangkok/gamelistener'
+
+class GameListenerTest < Test::Unit::TestCase
+
+  def setup
+    @listener = GameListener.new
+  end
+
+  def test_interp
+    assert_equal(0, @listener.interpolate(0, 100, 0, 100, 0))
+    assert_equal(100, @listener.interpolate(0, 100, 0, 100, 100))
+    assert_equal(50, @listener.interpolate(0, 100, 0, 100, 50))
+
+    assert_equal(50, @listener.interpolate(0, 100, 0, 500, 250))
+    assert_equal(127, @listener.interpolate(0, 127, 0, 100, 100))
+  end
+
+  def test_file_to_pan
+    assert_equal(0, @listener.file_to_pan(0))
+    assert_equal(127, @listener.file_to_pan(7))
+    assert_equal(63, @listener.file_to_pan(3.5))
+  end
+
+  def test_rank_to_pan
+    assert_equal(10, @listener.rank_to_volume(0)) # 10 is minimum volume
+    assert_equal(10, @listener.rank_to_volume(7))
+    assert_equal(127, @listener.rank_to_volume(3.5))
+  end
+end

data/test/test_piece.rb

@@ -73,6 +73,7 @@ class PieceTest < Test::Unit::TestCase
   end
 
   def test_pawn_en_passant
+    # TODO
     # Warning: en passant is not handled yet by the code
   end
 
@@ -92,9 +93,23 @@ class PieceTest < Test::Unit::TestCase
   end
 
   def test_knight_could_move_to
+    knight = @board.at(Square.new('b1')) # white knight
+    assert_equal(:N, knight.piece)
+    assert(knight.could_perform_move(Move.new(:white, 'Nc3')))
+    assert(knight.could_perform_move(Move.new(:white, 'Na3')))
+    assert(!knight.could_perform_move(Move.new(:white, 'Nb3')))
+
+    knight = @board.at(Square.new('b8')) # black knight
+    knight.move_to(Square.new('d4'))
+    assert_not_nil(@board.at(Square.new('c2')))
+    assert_not_nil(@board.at(Square.new('e2')))
+    %w(c2 e2 c6 e6 b3 b5 f3 f5).each { | sq |
+      assert(knight.could_perform_move(Move.new(:black, 'N' + sq)))
+    }
   end
 
   def test_bishop_could_move_to
+    bishop = @board.at(Square.new('c1'))
   end
 
   def test_queen_could_move_to

data/test/test_square.rb

@@ -9,12 +9,12 @@ class SquareTest < Test::Unit::TestCase
   end
 
   def test_equals
-    s1 = Square.new(3, 4)
+    s1 = Square.at(3, 4)
     s2 = Square.new('d5')
     assert_equal(s1, s2)
     assert(s1 == s2)
 
-    s3 = Square.new(0, 0)
+    s3 = Square.at(0, 0)
     assert(s1 != s3)
   end
 
@@ -29,7 +29,7 @@ class SquareTest < Test::Unit::TestCase
     assert_nil(s.rank)
     assert_nil(s.color)
 
-    s = Square.new(1, 3)
+    s = Square.at(1, 3)
     assert_equal(1, s.file)
     assert_equal(3, s.rank)
     assert_equal('b4', s.to_s)  # Just making sure I know what color should be
@@ -66,11 +66,15 @@ class SquareTest < Test::Unit::TestCase
     end
   end
 
+  def test_at
+    assert_equal(Square.at(3, 3), Square.new('d4'))
+  end
+
   def test_on_board
     s = Square.new
     assert(!s.on_board?)
 
-    s = Square.new(1, 3)
+    s = Square.at(1, 3)
     assert(s.on_board?)
 
     s1 = Square.new(s)
@@ -90,7 +94,7 @@ class SquareTest < Test::Unit::TestCase
     s = Square.new
     assert_equal("<off-board>", s.to_s)
 
-    s = Square.new(1, 3)
+    s = Square.at(1, 3)
     assert_equal("b4", s.to_s)
 
     s1 = Square.new(s)
@@ -106,4 +110,15 @@ class SquareTest < Test::Unit::TestCase
     assert_equal("<off-board>", s.to_s)
   end
 
+  def test_distance_to
+    assert_nil(Square.new.distance_to(Square.new))
+    assert_nil(Square.new.distance_to(Square.new('a4')))
+    assert_nil(Square.new('a4').distance_to(Square.new))
+    s = Square.new('b3')
+    assert_equal(1, s.distance_to(Square.new('b4')))
+    assert_equal(Math.sqrt(2), s.distance_to(Square.new('c4')))
+    assert_equal(4, s.distance_to(Square.new('f3')))
+    assert_equal(4, s.distance_to(Square.new('b7')))
+  end
+
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.8
 specification_version: 1
 name: bangkok
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
-date: 2005-03-25
+  version: 0.1.2
+date: 2005-03-26
 summary: Chess game file reader and player; can turn games into MIDI files
 require_paths: 
   - lib
@@ -48,6 +48,8 @@ files:
   - lib/bangkok/piece.rb
   - lib/bangkok/square.rb
   - test/mock_game_listener.rb
+  - test/test_board.rb
+  - test/test_gamelistener.rb
   - test/test_piece.rb
   - test/test_square.rb
 test_files: []