bangkok 0.1.0

data/examples/game.pgn

@@ -0,0 +1,15 @@
+[Event "?"]
+[Site "Reykjavik open"]
+[Date "1994.??.??"]
+[Round "4"]
+[White "Stefan Briem"]
+[Black "Olafur Thorsson"]
+[Result "0-1"]
+[ECO "A02"]
+
+1. f4 Nf6 2. Nf3 c5 3. e3 d5 4. d4 Bf5 5. c3 e6 6. Bd3 Bxd3 7. Qxd3 Nc6 
+8. O-O Be7 9. Nbd2 O-O 10. b3 Qc7 11. Ne5 a6 12. a4 Rab8 13. Nxc6 Qxc6 
+14. Ba3 b5 15. axb5 axb5 16. c4 Rfe8 17. Rfc1 cxd4 18. Bxe7 Rxe7 
+19. exd4 bxc4 20. bxc4 dxc4 21. Rxc4 Qd6 22. g3 Rc7 23. Ra5 g6 24. Rxc7 
+Qxc7 25. Rc5 Qa7 26. Qc3 Nd5 27. Qc1 Qa4 28. Rc4 Qa6 29. Nf3 Rb3 30. Nd2
+Rd3 31. Ne4 Ne3 32. Rc8+ Kg7 33. Nf2 Ra3 34. Rb8 Ra1 35. Rb1 Qb7 0-1

data/examples/program_changes.rb

@@ -0,0 +1,17 @@
+# This file is used to configure the MIDI output for a chess match.
+
+# color :piece, program_number
+
+black :K, 0
+black :Q, 8
+black :R, 16
+black :B, 24
+black :N, 32
+black :P, 4
+
+white :K, 4
+white :Q, 12
+white :R, 20
+white :B, 28
+white :N, 36
+white :P, 44

data/install.rb

@@ -0,0 +1,95 @@
+require 'rbconfig'
+require 'find'
+require 'ftools'
+
+include Config
+
+$ruby = CONFIG['ruby_install_name']
+
+##
+# Install a binary file. We patch in on the way through to
+# insert a #! line. If this is a Unix install, we name
+# the command (for example) 'bangkok' and let the shebang line
+# handle running it. Under windows, we add a '.rb' extension
+# and let file associations to their stuff
+#
+
+def installBIN(from, opfile)
+
+  tmp_dir = nil
+  for t in [".", "/tmp", "c:/temp", $bindir]
+    stat = File.stat(t) rescue next
+    if stat.directory? and stat.writable?
+      tmp_dir = t
+      break
+    end
+  end
+
+  fail "Cannot find a temporary directory" unless tmp_dir
+  tmp_file = File.join(tmp_dir, "_tmp")
+    
+  File.open(from) do |ip|
+    File.open(tmp_file, "w") do |op|
+      ruby = File.join($realbindir, $ruby)
+      op.puts "#!#{ruby} -w"
+      op.write ip.read
+    end
+  end
+
+  if CONFIG["target_os"] =~ /mswin/i
+    opfile_path = File.join($bindir, opfile)
+    File::install(tmp_file, opfile_path, 0755, true)
+    File.open(File.join($bindir, opfile + '.cmd'), 'w') { | f |
+      f.puts "@ruby \"#{opfile_path}\" %*"
+    }
+  else
+    File::install(tmp_file, File.join($bindir, opfile), 0755, true)
+  end
+  File::unlink(tmp_file)
+end
+
+$sitedir = CONFIG["sitelibdir"]
+unless $sitedir
+  version = CONFIG["MAJOR"]+"."+CONFIG["MINOR"]
+  $libdir = File.join(CONFIG["libdir"], "ruby", version)
+  $sitedir = $:.find {|x| x =~ /site_ruby/}
+  if !$sitedir
+    $sitedir = File.join($libdir, "site_ruby")
+  elsif $sitedir !~ Regexp.quote(version)
+    $sitedir = File.join($sitedir, version)
+  end
+end
+
+$bindir =  CONFIG["bindir"]
+
+$realbindir = $bindir
+
+bindir = CONFIG["bindir"]
+if (destdir = ENV['DESTDIR'])
+  $bindir  = destdir + $bindir
+  $sitedir = destdir + $sitedir
+  
+  File::makedirs($bindir)
+  File::makedirs($sitedir)
+end
+
+bangkok_dest = File.join($sitedir, "bangkok")
+File::makedirs(bangkok_dest, true)
+File::chmod(0755, bangkok_dest)
+
+# The library files
+
+files = Dir.chdir('lib') { Dir['**/*.rb'] }
+
+for fn in files
+  fn_dir = File.dirname(fn)
+  target_dir = File.join($sitedir, fn_dir)
+  if ! File.exist?(target_dir)
+    File.makedirs(target_dir)
+  end
+  File::install(File.join('lib', fn), File.join($sitedir, fn), 0644, true)
+end
+
+# and the executable
+
+installBIN("bin/bangkok", "bangkok")

data/lib/bangkok.rb

@@ -0,0 +1,2 @@
+# See the README file.
+require 'bangkok/chessgame'

data/lib/bangkok/board.rb

@@ -0,0 +1,110 @@
+require 'bangkok/square'
+require 'bangkok/piece'
+
+class Board
+
+  def initialize(listener)
+    @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))
+    }
+    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))
+    }
+  end
+
+  def apply(move)
+    if move.castle?
+      apply_castle(move)
+    else
+      piece = find_piece(move)
+      other_piece = at(move.square) unless move.castle?
+      piece.move_to(move.square)
+      if other_piece              # capture
+        unless move.capture?
+          raise "error: piece found at target (#{other_piece}) but move" +
+            " #{move} is not a capture"
+        end
+        @listener.capture(piece, other_piece)
+        remove_from_board(other_piece)
+      end
+
+      if move.pawn_promotion?
+        raise "error: trying to promote a non-pawn" unless piece.piece == :P
+
+        @listener.pawn_to_queen(piece)
+        color = piece.color
+        remove_from_board(piece) # will also trigger the listener
+        @pieces << Piece.create(self, color, :Q, move.square)
+      end
+    end
+  end
+
+  def apply_castle(move)
+    new_king_file = nil
+    new_rook_file = nil
+    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 |
+        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 |
+        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))
+  end
+
+  def remove_from_board(piece)
+    @pieces.delete(piece)
+    piece.move_off_board()
+  end
+
+  def empty_at?(square)
+    return at(square).nil?
+  end
+
+  def at(square)
+    return @pieces.detect { | p | p.square == square }
+  end
+
+  def find_piece(move)
+    candidates = @pieces.find_all { | p | p.could_perform_move(move) }
+    case candidates.length
+    when 0
+      raise "error: no pieces found for move #{move}"
+    when 1
+      return candidates[0]
+    else                        # Disambiguate using move's orig. rank or file
+      if move.from_rank_or_file.rank.nil? # file is non-nil
+        candidates = candidates.find_all { | p |
+          p.square.file == move.from_rank_or_file.file
+        }
+      else
+        candidates = candidates.find_all { | p |
+          p.square.rank == move.from_rank_or_file.rank
+        }
+      end
+      case candidates.length
+      when 0
+        raise "error: disambiguation found no pieces for #{move}"
+      when 1
+        return candidates[0]
+      else
+        raise "error: too many pieces match #{move}"
+      end
+    end
+  end
+end

data/lib/bangkok/chessgame.rb

@@ -0,0 +1,50 @@
+#! /usr/bin/env ruby
+
+require 'bangkok/gamelistener'
+require 'bangkok/board'
+require 'bangkok/move'
+
+# A ChessGame can read a chess play file and write a MIDI file created from
+# the moves in the file.
+class ChessGame
+
+  def initialize(listener = GameListener.new)
+    @listener = listener
+  end
+
+  # Read the chess game and turn it into Moves.
+  def read_moves(io)
+    game_text = read(io)
+    @moves = []
+    game_text.scan(/\d+\.\s+(\S+)\s+(\S+)/).each { | white, black |
+      @moves << Move.new(:white, white)
+      @moves << Move.new(:black, black) unless black == '1-0' || black == '0-1'
+    }
+  end
+
+  # Read the chess game. Set player names and return a string containing the
+  # chess moves ("1. f4 Nf6 2. Nf3 c5...").
+  def read(io)
+    game_text = ''
+    io.each { | line |
+      line.chomp!
+      case line
+      when /\[(.*)\]/           # New games starting (if multi-game file)
+      when /^\s*$/
+      else
+        game_text << ' '
+        game_text << line
+      end
+    }
+    game_text
+  end
+
+  # Writes a MIDI file.
+  def play(io)
+    @listener.start_game(io)
+    board = Board.new(@listener)
+    @moves.each { | move | board.apply(move) }
+    @listener.end_game
+  end
+
+end

data/lib/bangkok/gamelistener.rb

@@ -0,0 +1,181 @@
+begin
+  require 'midilib'
+rescue LoadError
+  require 'rubygems'
+  require_gem 'midilib'
+end
+include MIDI
+
+# The pieces and board call methods on an instance of GameListener, which
+# turns those events into MIDI events.
+class GameListener
+  PIECE_MIDI_INFO = {}
+  PIECE_MIDI_INFO[:white] = {}
+  PIECE_MIDI_INFO[:black] = {}
+end
+
+def white(piece_sym, program_change)
+  GameListener::PIECE_MIDI_INFO[:white][piece_sym] = program_change
+end
+def black(piece_sym, program_change)
+  GameListener::PIECE_MIDI_INFO[:black][piece_sym] = program_change
+end
+
+
+# Fill in some default values, in case the user does not specify any new ones.
+black :K, 0
+black :Q, 8
+black :R, 16
+black :B, 24
+black :N, 32
+black :P, 4
+white :K, 4
+white :Q, 12
+white :R, 20
+white :B, 28
+white :N, 36
+white :P, 44
+
+class GameListener
+
+  attr_reader :seq              # MIDI::Sequence
+
+  # TODO remove this and specify it some other way
+  begin
+    require 'chess_config'        # Fills in PIECE_MIDI_INFO
+  rescue LoadError
+  end
+
+  PIECE_NAMES = {
+    :P => "Pawn",
+    :R => "Rook",
+    :N => "Night",
+    :B => "Bishop",
+    :Q => "Queen",
+    :K => "King"
+  }
+
+  # Build notes to play for ranks
+  RANK_TO_NOTE = {}
+  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) }
+
+  def track_of(piece)
+    i = [:white, :black].index(piece.color) * 6 +
+      [:P, :R, :N, :B, :Q, :K].index(piece.piece)
+    @seq.tracks[i + 1]          # 0'th track is temp track
+  end
+
+  def channel_of(piece)
+    [:white, :black].index(piece.color) * 8 +
+      [:P, :R, :N, :B, :Q, :K].index(piece.piece)
+  end
+
+  # --
+  # ================================================================
+  # Listener interface
+  # ================================================================
+  # ++
+
+  def start_game(io)
+    @io = io
+    @seq = Sequence.new
+    track = Track.new(@seq)     # Tempo track
+    track.name = "Tempo track"
+    @seq.tracks << track
+
+    @cached_quarter_delta = @seq.note_to_delta('quarter')
+
+    create_tracks()
+    @time_from_start = 0
+  end
+
+  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 }
+    @seq.write(io)
+  end
+
+  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
+    # Do nothing if the piece moves off the board, because either capture()
+    # or pawn_to_queen() will be called.
+  end
+
+  def capture(attacker, loser)
+  end
+
+  def check
+  end
+
+  def checkmate
+  end
+
+  def pawn_to_queen(pawn)
+  end
+
+  # --
+  # ================================================================
+  # End of listener interface
+  # ================================================================
+  # ++
+
+  def create_tracks
+    [:white, :black].each_with_index { | color, chan_base_offset |
+      [:P, :R, :N, :B, :Q, :K].each_with_index { | piece_sym, chan_offset |
+        track = Track.new(@seq)
+        @seq.tracks << track
+
+        track.name = "#{color.to_s.capitalize} #{PIECE_NAMES[piece_sym]}"
+
+        program_num = PIECE_MIDI_INFO[color][piece_sym]
+        track.instrument = GM_PATCH_NAMES[program_num]
+        track.events << ProgramChange.new(chan_base_offset * 8 + chan_offset,
+                                          program_num)
+      }
+    }
+  end
+
+  def midi_for_position(piece, square)
+    track = track_of(piece)
+    channel = channel_of(piece)
+
+    # pan
+    e = Controller.new(channel, CC_PAN, FILE_TO_PAN[square.file])
+    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
+    track.events << e
+
+    # note on and off
+    note = RANK_TO_NOTE[piece.color][square.rank]
+    e = NoteOnEvent.new(channel, note, 127)
+    e.time_from_start = @time_from_start
+    track.events << e
+
+    e = NoteOffEvent.new(channel, note, 127)
+    e.time_from_start = @time_from_start + @cached_quarter_delta
+    track.events << e
+
+    @time_from_start = e.time_from_start
+  end
+
+end