mail_chess 0.1.0 → 0.2.0

data/lib/mail_chess/board.rb

@@ -34,10 +34,13 @@ module MailChess
       @db_entry = @db[:boards].filter(:id => board_id).first
 
       @id = @db_entry[:id].to_i
+      
       @pieces = {}
       @db[:pieces].filter(:board_id => @id).all.each do |p|
         Piece::Piece.load! db, p[:id], self
       end
+      
+      generate_pieces_moves
     end
 
     # Checks if needed to create tables.
@@ -105,13 +108,16 @@ module MailChess
     
     # Delete game -- +save!+ won't fix it!
     def delete!
-      pieces.values.each do |p|
-        p.delete!
-      end
+      @db[:pieces].filter(:board_id => @id).delete
       
       # board deleted in Game class
     end
 
+    # Generates the available hits and moves for every pieces.
+    def generate_pieces_moves
+      @pieces.values.each { |p| p.generate_moves }
+    end
+    
     # Add a new piece to board.
     #
     # Arguments:
@@ -219,4 +225,8 @@ module MailChess
       return result
     end
   end
+
+  # Error for invalid moves.
+  class MoveError < StandardError
+  end
 end

data/lib/mail_chess/game.rb

@@ -21,12 +21,16 @@ module MailChess
     # Current player's color.
     attr_accessor :current
 
+    # Who tries to move.
+    attr_reader :initiator
+
     # Create a new Game object.
     #
     # Arguments:
     #   db: Sequel database object
     #   game_id: (Integer)
-    def initialize db, game_id
+    #   initiator: (Symbol) :white or :black
+    def initialize db, game_id, initiator
       @db = db
 
       Game.create_tables(@db) if Game.need_to_create_tables?(@db)
@@ -43,6 +47,7 @@ module MailChess
         @players[p[:color].to_sym] = Player.load!(@db, :id, p[:player_id].to_i)
       end
 
+      @initiator = initiator
     end
 
     # Checks if needed to create tables.
@@ -103,7 +108,7 @@ module MailChess
                         :game_id => id,
                         :color => 'black')
 
-      return Game.new db, id
+      return Game.new db, id, :white
     end
     
     # Load game from database.
@@ -112,15 +117,16 @@ module MailChess
     #   db: Sequel database object
     #   filter: (Symbol) :id or :reference
     #   value: filters value
+    #   initiator: (Symbol) :white or :black
     #
     # Returns: (Game)
-    def self.load! db, filter, value
+    def self.load! db, filter, value, initiator
       raise ArgumentError unless [:id, :reference].index(filter)
       dataset = db[:games].filter(filter => value)
       return nil unless dataset.all.size == 1
       id = dataset.first[:id]
 
-      return Game.new db, id
+      return Game.new db, id, initiator
     end
 
     # Save game -- update the +current+ field.
@@ -135,5 +141,43 @@ module MailChess
       @db[:games].filter(:id => @id).delete
       @db[:boards].filter(:id => @board.id).delete
     end
+
+    # Perform the move.
+    #
+    # Arguments:
+    #   move: (String) eg.: e2e4
+    #
+    # Exceptions:
+    #   (MoveError) if move is invalid
+    #   (TurnError) if this is not the requester's turn
+    def perform! move
+      from, to = move[0] + move[1], move[2] + move[3]
+      p = @board.pieces[from]
+      k = nil
+
+      @board.pieces.values.each do |piece|
+        k = piece if piece.type == 'king' and piece.color == @current
+      end
+
+      raise TurnError.new('not your turn') if @initiator != @current
+      raise MoveError.new('piece not exists') if p == nil
+      raise MoveError.new('not your piece') if p.color != @current
+      raise MoveError.new('invalid move') if !p.can_move?(to) & !p.can_hit?(to)
+
+      old_p = @board.pieces[to]
+      p.move to
+
+      raise MoveError.new('checkmate') if k.in_checkmate?
+      raise MoveError.new('king in check') if k.in_check?
+
+      old_p.delete! if old_p
+      @current = (@current == :white ? :black : :white)
+      @board.save!
+      save!
+    end
+  end
+  
+  # Error for invalid turns.
+  class TurnError < StandardError
   end
 end

data/lib/mail_chess/pieces/base.rb

@@ -21,7 +21,13 @@ module MailChess
 
       # HTML tag of this piece.
       attr_reader :html
-      
+
+      # Available moves.
+      attr_reader :moves
+
+      # Available hits.
+      attr_reader :hits
+
       # Create a new Piece object.
       #
       # Arguments:
@@ -39,6 +45,8 @@ module MailChess
         @color = @db_entry[:color].to_sym
         @board = board
         @board.add @db_entry[:position], self
+
+        @possibilities_generated = false
       end
 
       # Checks if needed to create tables.
@@ -70,6 +78,15 @@ module MailChess
         return @board.pieces.key(self)
       end
 
+      # Moves the piece.
+      #
+      # Arguments:
+      #   to: (String) destination field
+      def move to
+        @board.pieces[to] = @board.pieces.delete(position)
+        @board.pieces[to].generate_moves
+      end
+
       # ABSTRACT Create a new piece and add to a table.
       #
       # Arguments:
@@ -108,11 +125,36 @@ module MailChess
       def save!
         @db[:pieces].filter(:id => @id).update(:position => position)
       end
-      
-      # Delete piece -- +save!+ won't fix it!
+
+      # Delete piece
       def delete!
         @db[:pieces].filter(:id => @id).delete
       end
+
+      # Decide if piece can move to +field+.
+      #
+      # Arguments:
+      #   field: (String)
+      #
+      # Returns: (Boolean)
+      def can_move? field
+        return @moves.index(field) != nil
+      end
+
+      # Decide if piece can hit piece on +field+.
+      #
+      # Arguments:
+      #   field: (String)
+      #
+      # Returns: (Boolean)
+      def can_hit? field
+        return @hits.index(field) != nil
+      end
+
+      # Generate the possible moves.
+      def generate_moves
+        @hits, @moves = [], []
+      end
     end
   end
 end

data/lib/mail_chess/pieces/bishop.rb

@@ -25,6 +25,36 @@ module MailChess
 
         return Bishop.new db, id, board
       end
+
+      # Generate the possible moves.
+      def generate_moves
+        super
+        
+        r, c = ROWS.index(position[1]), COLS.index(position[0])
+        f = {:ul => false, :ur => false, :bl => false, :br => false}
+        
+        (1..7).each do |i|
+          pos = []
+          pos << [:ul, COLS[c - i] + ROWS[r - i]] if 
+            c - i >= 0 and r - i >= 0 and !f[:ul]
+          pos << [:ur, COLS[c - i] + ROWS[r + i]] if 
+            c - i >= 0 and r + i <= 7 and !f[:ur]
+          pos << [:bl, COLS[c + i] + ROWS[r - i]] if 
+            c + i <= 7 and r - i >= 0 and !f[:bl]
+          pos << [:br, COLS[c + i] + ROWS[r + i]] if 
+            c + i <= 7 and r + i <= 7 and !f[:br]
+          
+          break if pos.empty?
+          pos.each do |s, p|
+            if @board.pieces[p]
+              @hits << p if @board.pieces[p].color != @color
+              f[s] = true
+            else
+              @moves << p
+            end
+          end
+        end
+      end
     end
   end
 end

data/lib/mail_chess/pieces/king.rb

@@ -25,6 +25,65 @@ module MailChess
 
         return King.new db, id, board
       end
+   
+      # Generate the possible moves.
+      def generate_moves
+        super
+        
+        r, c = ROWS.index(position[1]), COLS.index(position[0])
+        (r - 1..r + 1).each do |y|
+          (c - 1..c + 1).each do |x|
+            if x >= 0 and x <= 7 and y >= 0 and y <= 7
+              f = COLS[x] + ROWS[y]
+              if @board.pieces[f] # is there a piece
+                @hits << f
+              else
+                @moves << f
+              end
+            end
+          end
+        end
+        
+        @hits.delete(position)
+      end
+
+      # Decide wether this king is in check.
+      #
+      # Returns: (Boolean)
+      def in_check?
+        @board.pieces.values.each do |p|
+          if p.color != @color # if opponent's piece
+            return true if p.can_hit?(position)
+          end
+        end
+        
+        return false
+      end
+
+      # Decide wether this king is in checkmate. (dumb method, FIXME)
+      #
+      # Returns: (Boolean)
+      def in_checkmate?
+        return false if not in_check? # if not in even check
+        
+        original = @board.pieces
+        
+        @board.pieces.values.each do |p|
+          if p.color == @color # if player's piece
+            original_moves_hits = p.moves + p.hits
+            original_moves_hits.each do |m|
+              p.move m
+              @board.generate_pieces_moves
+              if not in_check?
+                @board.pieces = original
+                return false
+              end
+              @board.pieces = original
+            end
+          end
+        end
+        return true
+      end
     end
   end
 end

data/lib/mail_chess/pieces/knight.rb

@@ -25,7 +25,31 @@ module MailChess
 
         return Knight.new db, id, board
       end
+      
+      # Generate the possible moves.
+      def generate_moves
+        super
+        
+        r, c = ROWS.index(position[1]), COLS.index(position[0])
+        
+        pos = []
+        pos << COLS[c - 1] + ROWS[r - 2] if c > 0 and r > 1
+        pos << COLS[c + 1] + ROWS[r - 2] if c < 7 and r > 1
+        pos << COLS[c - 2] + ROWS[r - 1] if c > 1 and r > 0
+        pos << COLS[c + 2] + ROWS[r - 1] if c < 6 and r > 0
+        pos << COLS[c - 2] + ROWS[r + 1] if c > 1 and r < 7
+        pos << COLS[c + 2] + ROWS[r + 1] if c < 6 and r < 7
+        pos << COLS[c - 1] + ROWS[r + 2] if c > 0 and r < 6
+        pos << COLS[c + 1] + ROWS[r + 2] if c < 7 and r < 6
+        
+        pos.each do |p|
+          if @board.pieces[p]
+            @hits << p
+          else
+            @moves << p
+          end
+        end
+      end
     end
   end
 end
-

data/lib/mail_chess/pieces/pawn.rb

@@ -25,6 +25,41 @@ module MailChess
                                 
         return Pawn.new db, id, board
       end
+      
+      # Generate the possible moves.
+      def generate_moves
+        super
+        
+        r, c = ROWS.index(position[1]), COLS.index(position[0])
+        dir = @color == :white ? -1 : 1
+        first_step = 
+          ((@color == :white and position[1] == 2.to_s) or
+           (@color == :black and position[1] == 7.to_s) ? true : false)
+        
+        # moves
+        if (r + dir >= 0 and @color == :white) or (r + dir <= 7 and 
+                                                   @color == :black)
+          f = COLS[c] + ROWS[r + dir]
+          @moves << f unless @board.pieces[f]
+        end
+        
+        if (r + dir * 2 >= 0 and @color == :white) or (r + dir * 2 <= 7 and
+                                                       @color == :black)
+          f = COLS[c] + ROWS[r + dir * 2]
+          @moves << f if !@board.pieces[f] and first_step
+        end
+        
+        # hits
+        [-1, 1].each do |x|
+          if c + x >= 0 and c + x <= 7
+            if (r - 1 >= 0 and @color == :white) or (r + 1 <= 7 and
+                                                     @color == :black)
+              f = COLS[c + x] + ROWS[r + dir]
+              @hits << f if @board.pieces[f]
+            end
+          end
+        end
+      end
     end
   end
 end

data/lib/mail_chess/pieces/queen.rb

@@ -25,7 +25,40 @@ module MailChess
 
         return Queen.new db, id, board
       end
+      
+      # Generate the possible moves.
+      def generate_moves
+        super
+        
+        r, c = ROWS.index(position[1]), COLS.index(position[0])
+        f = {:ul => false, :uc => false, :ur => false,
+          :ml => false, :mc => true,  :mr => false,
+          :bl => false, :bc => false, :br => false}
+        
+        (1..7).each do |i|
+          pos = [] 
+          {'u' => -1, 'm' => 0, 'b' => 1}.each do |y, v|
+            {'l' => -1, 'c' => 0, 'r' => 1}.each do |x, w|
+              s, cc, rr = (y + x).to_sym, c + w * i, r + v * i
+              if cc >= 0 and cc <= 7 and rr >= 0 and rr <= 7
+                pos << [s, COLS[cc] + ROWS[rr]] if !f[s]
+              else
+                f[s] = true
+              end
+            end
+          end
+          
+          break if pos.empty?
+          pos.each do |s, p|
+            if @board.pieces[p]
+              @hits << p if @board.pieces[p].color != @color
+              f[s] = true
+            else
+              @moves << p
+            end
+          end
+        end
+      end
     end
   end
 end
-

data/lib/mail_chess/pieces/rook.rb

@@ -25,7 +25,32 @@ module MailChess
 
         return Rook.new db, id, board
       end
+   
+      # Generate the possible moves.
+      def generate_moves
+        super
+        
+        r, c = ROWS.index(position[1]), COLS.index(position[0])
+        f = {:u => false, :l => false, :r => false, :d => false}
+        
+        (1..7).each do |i|
+          pos = []
+          pos << [:u, COLS[c] + ROWS[r - i]] if r - i >= 0 and !f[:u]
+          pos << [:l, COLS[c - i] + ROWS[r]] if c - i >= 0 and !f[:l]
+          pos << [:r, COLS[c + i] + ROWS[r]] if c + i <= 7 and !f[:r]
+          pos << [:d, COLS[c] + ROWS[r + i]] if r + i <= 7 and !f[:d]
+          
+          break if pos.empty?
+          pos.each do |s, p|
+            if @board.pieces[p]
+              @hits << p if @board.pieces[p].color != @color
+              f[s] = true
+            else
+              @moves << p
+            end
+          end
+        end
+      end
     end
   end
 end
-

data/lib/mail_chess/player.rb

@@ -72,10 +72,14 @@ module MailChess
     #   value: filters value
     #
     # Returns: (Player)
+    #
+    # Exceptions:
+    #   (ArgumentError) if filter is invalid
+    #   (PlayerError) if player not exists
     def self.load! db, filter, value
       raise ArgumentError unless [:id, :email].index(filter)
       dataset = db[:players].filter(filter => value)
-      raise ArgumentError unless dataset.all.size == 1
+      raise PlayerError('player not exists') unless dataset.all.size == 1
 
       id = dataset.first[:id]
 
@@ -88,8 +92,19 @@ module MailChess
     #   reference: (String) game reference string
     #
     # Returns: (Game) or nil
+    #
+    # Exceptions:
+    #   (PlayerError) if initiator is invalid
     def game reference
-      return Game.load! @db, :reference, reference
+      d = @db[:pairs]
+        .join(:games, :id => :game_id)
+        .filter(:reference => reference, :player_id => self.id)
+
+      if d.all.empty?
+        raise PlayerError('invalid initiator')
+      else
+        Game.load! @db, :reference, reference, d.first[:color].to_sym
+      end
     end
 
     # Save player -- name only
@@ -97,4 +112,8 @@ module MailChess
       @db[:players].filter(:id => @id).update(:name => @name)
     end
   end
+
+  # Error for players.
+  class PlayerError < StandardError
+  end
 end

data/test/check_mate_test.rb

@@ -0,0 +1,95 @@
+require 'test/unit'
+require 'mail_chess'
+require 'sequel'
+
+class CheckMateTest < Test::Unit::TestCase
+  def setup
+    @db = Sequel.connect 'sqlite:/'
+    @p1 = MailChess::Player.new!(@db, 'john@doe.net')
+    @p2 = MailChess::Player.new!(@db, 'jane@doe.net')
+  end
+
+  def test_no_check_no_checkmate
+    g = MailChess::Game.new!(@db, @p1, @p2, 'test@mail')
+    b = g.board
+
+    k = MailChess::Piece::King.new!(@db, b, 'f2', :white)
+    MailChess::Piece::Queen.new!(@db, b, 'b5', :oblack)
+    
+    b.generate_pieces_moves
+
+    assert !k.in_check?
+    assert !k.in_checkmate?
+
+    g.delete!
+  end
+
+  def test_check_with_king_can_hit
+    g = MailChess::Game.new!(@db, @p1, @p2, 'test@mail')
+    b = g.board
+
+    k = MailChess::Piece::King.new!(@db, b, 'f2', :white)
+    MailChess::Piece::Queen.new!(@db, b, 'g3', :black)
+    MailChess::Piece::Rook.new!(@db, b, 'e4', :black)
+    MailChess::Piece::Rook.new!(@db, b, 'a1', :black)
+    
+    b.generate_pieces_moves
+
+    assert k.in_check?
+    assert !k.in_checkmate?
+
+    g.delete!
+  end
+
+  def test_check_with_king_can_move
+    g = MailChess::Game.new!(@db, @p1, @p2, 'test@mail')
+    b = g.board
+
+    k = MailChess::Piece::King.new!(@db, b, 'f2', :white)
+    MailChess::Piece::Rook.new!(@db, b, 'f8', :black)
+
+    b.generate_pieces_moves
+    
+    assert k.in_check?
+    assert !k.in_checkmate?
+
+    g.delete!
+  end
+
+  def test_check_with_other_piece_can_move
+    g = MailChess::Game.new!(@db, @p1, @p2, 'test@mail')
+    b = g.board
+
+    k = MailChess::Piece::King.new!(@db, b, 'f2', :white)
+    MailChess::Piece::Bishop.new!(@db, b, 'd3', :white)
+    MailChess::Piece::Rook.new!(@db, b, 'e8', :black)
+    MailChess::Piece::Queen.new!(@db, b, 'f8', :black)
+    MailChess::Piece::Rook.new!(@db, b, 'g8', :black)
+
+    b.generate_pieces_moves
+        
+    assert k.in_check?
+    assert !k.in_checkmate?
+
+    g.delete!
+  end
+
+  def test_checkmate
+    g = MailChess::Game.new!(@db, @p1, @p2, 'test@mail')
+    b = g.board
+
+    MailChess::Piece::Queen.new!(@db, b, 'a1', :black)
+    k = MailChess::Piece::King.new!(@db, b, 'h2', :white)
+    MailChess::Piece::Rook.new!(@db, b, 'c3', :black)
+    MailChess::Piece::Pawn.new!(@db, b, 'g3', :black)
+    MailChess::Piece::Knight.new!(@db, b, 'g5', :black)
+    MailChess::Piece::Bishop.new!(@db, b, 'b7', :black)
+
+    b.generate_pieces_moves
+    
+    assert k.in_check?
+    assert k.in_checkmate?
+
+    g.delete!
+  end
+end

data/test/db_operations_test.rb

@@ -1,5 +1,6 @@
-require 'mail_chess'
 require 'test/unit'
+require 'mail_chess'
+require 'sequel'
 
 class DatabaseOperationsTest < Test::Unit::TestCase
   def setup

data/test/perform_move_test.rb

@@ -0,0 +1,49 @@
+require 'test/unit'
+require 'mail_chess'
+require 'sequel'
+
+class PerformMoveTest < Test::Unit::TestCase
+  def setup
+    @db = Sequel.connect 'sqlite:/'
+
+    p1 = MailChess::Player.new!(@db, 'john@doe.net')
+    p2 = MailChess::Player.new!(@db, 'jane@doe.net')
+
+    g = MailChess::Game.new!(@db, p1, p2, 'abcd@mail')
+    g.current = :white
+    g.save!
+
+    MailChess::Piece::Queen.new!(@db, g.board, 'a1', :black)
+    MailChess::Piece::King.new!(@db, g.board, 'h2', :white)
+    MailChess::Piece::Rook.new!(@db, g.board, 'c3', :black)
+    MailChess::Piece::Knight.new!(@db, g.board, 'f4', :black)
+    MailChess::Piece::Pawn.new!(@db, g.board, 'g4', :black)
+    MailChess::Piece::Knight.new!(@db, g.board, 'a5', :black)
+    MailChess::Piece::Pawn.new!(@db, g.board, 'b6', :white)
+    MailChess::Piece::Bishop.new!(@db, g.board, 'c6', :black)
+    MailChess::Piece::King.new!(@db, g.board, 'h8', :black)
+
+    g.board.generate_pieces_moves
+    File.open('table.htm', 'w') { |f| f.write(g.board.to_html) }
+  end
+
+  def test_play
+    # Jane tries to move but it's not her turn
+    g = MailChess::Player.load!(@db, :email, 'jane@doe.net').game('abcd@mail')
+    assert_raise(MailChess::TurnError) { g.perform! 'g4g3' }
+
+    # Joe tries to move with a not existing piece, than finds the right move
+    g = MailChess::Player.load!(@db, :email, 'john@doe.net').game('abcd@mail')
+    assert_raise(MailChess::MoveError) { g.perform! 'a6a7' }
+    g.perform! 'b6b7'
+
+    # Jane's turn
+    g = MailChess::Player.load!(@db, :email, 'jane@doe.net').game('abcd@mail')
+    assert_raise(MailChess::MoveError) { g.perform! 'c8c7' }
+    assert_raise(MailChess::MoveError) { g.perform! 'b6c5' }
+    assert_raise(MailChess::MoveError) { g.perform! 'c6c5' }
+    g.perform! 'g4g3'
+
+    # the end.
+  end
+end

data/test/piece_moves_test.rb

@@ -0,0 +1,266 @@
+require 'test/unit'
+require 'mail_chess'
+require 'sequel'
+
+class PieceMovesTest < Test::Unit::TestCase
+  def setup
+    @db = Sequel.connect 'sqlite:/'
+    @p1 = MailChess::Player.new!(@db, 'john@doe.net')
+    @p2 = MailChess::Player.new!(@db, 'jane@doe.net')
+  end
+
+  def check_moves hits, moves, piece
+    all = MailChess::ROWS.product(MailChess::COLS).map! do |a| a.join end
+    all -= hits + moves
+    name = piece.position + " " + piece.type
+  
+    all.each do |f|
+      assert !piece.can_move?(f), name + " shouldn't move to " + f
+      assert !piece.can_hit?(f), name + " shouldn't hit " + f
+    end
+
+    moves.each do |f|
+      assert piece.can_move?(f), name + " should move to " + f
+      assert !piece.can_hit?(f), name + " shouldn't hit " + f
+    end
+
+    hits.each do |f|
+      assert !piece.can_move?(f), name + " shouldn't move to " + f
+      assert piece.can_hit?(f), name + " should hit " + f
+    end
+  end
+
+  def test_bishop
+    g = MailChess::Game.new!(@db, @p1, @p2, 'test@mail')
+    b = g.board
+
+    MailChess::Piece::Bishop.new!(@db, b, 'c2', :black)
+    MailChess::Piece::Pawn.new!(@db, b, 'd3', :white)
+    MailChess::Piece::Bishop.new!(@db, b, 'g3', :black)
+    MailChess::Piece::Rook.new!(@db, b, 'a4', :white)
+    MailChess::Piece::Bishop.new!(@db, b, 'e4', :white)
+    MailChess::Piece::Knight.new!(@db, b, 'f4', :white)
+    MailChess::Piece::Pawn.new!(@db, b, 'h4', :black)
+    MailChess::Piece::Bishop.new!(@db, b, 'a8', :white)
+
+    b.generate_pieces_moves
+    
+    # c2
+    hits = %w[d3 a4]
+    moves = %w[b1 d1 b3]
+    check_moves hits, moves, b.pieces['c2']
+
+    # g3
+    hits = %w[f4]
+    moves = %w[e1 f2 h2]
+    check_moves hits, moves, b.pieces['g3']
+
+    # e4
+    hits = %w[]
+    moves = %w[h1 g2 f3 d5 f5 c6 g6 b7 h7]
+    check_moves hits, moves, b.pieces['e4']
+
+    # a8
+    hits = %w[]
+    moves = %w[d5 c6 b7]
+    check_moves hits, moves, b.pieces['a8']
+
+    g.delete!
+  end
+
+  def test_king
+    g = MailChess::Game.new!(@db, @p1, @p2, 'test@mail')
+    b = g.board
+
+    MailChess::Piece::King.new!(@db, b, 'a1', :white)
+    MailChess::Piece::Pawn.new!(@db, b, 'a2', :black)
+    MailChess::Piece::Bishop.new!(@db, b, 'd2', :black)
+    MailChess::Piece::King.new!(@db, b, 'e2', :black)
+    MailChess::Piece::Knight.new!(@db, b, 'f3', :white)
+
+    b.generate_pieces_moves
+    
+    # a1
+    hits = %w[a2]
+    moves = %w[b1 b2]
+    check_moves hits, moves, b.pieces['a1']
+
+    # e2
+    hits = %w[f3]
+    moves = %w[d1 e1 f1 f2 d3 e3]
+    check_moves hits, moves, b.pieces['e2']
+
+    g.delete!
+  end
+
+  def test_knight
+    g = MailChess::Game.new!(@db, @p1, @p2, 'test@mail')
+    b = g.board
+
+    MailChess::Piece::Knight.new!(@db, b, 'a2', :white)
+    MailChess::Piece::Pawn.new!(@db, b, 'c3', :white)
+    MailChess::Piece::Knight.new!(@db, b, 'f3', :black)
+    MailChess::Piece::Pawn.new!(@db, b, 'b4', :black)
+    MailChess::Piece::Knight.new!(@db, b, 'd4', :white)
+    MailChess::Piece::Pawn.new!(@db, b, 'h4', :black)
+    MailChess::Piece::Pawn.new!(@db, b, 'e6', :white)
+    MailChess::Piece::Knight.new!(@db, b, 'g7', :black)
+
+    b.generate_pieces_moves
+    
+    # a2
+    hits = %w[b4]
+    moves = %w[c1]
+    check_moves hits, moves, b.pieces['a2']
+
+    # f3
+    hits = %w[d4]
+    moves = %w[e1 g1 d2 h2 e5 g5]
+    check_moves hits, moves, b.pieces['f3']
+
+    # d4
+    hits = %w[f3]
+    moves = %w[c2 e2 b3 b5 f5 c6]
+    check_moves hits, moves, b.pieces['d4']
+
+    # g7
+    hits = %w[e6]
+    moves = %w[f5 h5 e8]
+    check_moves hits, moves, b.pieces['g7']
+
+    g.delete!
+  end  
+
+  def test_pawn
+    g = MailChess::Game.new!(@db, @p1, @p2, 'test@mail')
+    b = g.board
+
+    MailChess::Piece::Pawn.new!(@db, b, 'a1', :black)
+    MailChess::Piece::Pawn.new!(@db, b, 'c2', :white)
+    MailChess::Piece::Pawn.new!(@db, b, 'g2', :white)
+    MailChess::Piece::Rook.new!(@db, b, 'g4', :black)
+    MailChess::Piece::Pawn.new!(@db, b, 'a5', :white)
+    MailChess::Piece::Pawn.new!(@db, b, 'e5', :black)
+    MailChess::Piece::Pawn.new!(@db, b, 'f5', :white)
+    MailChess::Piece::Bishop.new!(@db, b, 'b6', :black)
+    MailChess::Piece::Pawn.new!(@db, b, 'f6', :black)
+    MailChess::Piece::Pawn.new!(@db, b, 'g6', :white)
+    MailChess::Piece::Pawn.new!(@db, b, 'h7', :black)
+    MailChess::Piece::Pawn.new!(@db, b, 'd8', :white)
+
+    b.generate_pieces_moves
+    
+    # a1
+    hits = %w[]
+    moves = %w[]
+    check_moves hits, moves, b.pieces['a1']
+
+    # c2
+    hits = %w[]
+    moves = %w[c3 c4]
+    check_moves hits, moves, b.pieces['c2']
+
+    # g2
+    hits = %w[]
+    moves = %w[g3]
+    check_moves hits, moves, b.pieces['g2']
+
+    # a5
+    hits = %w[b6]
+    moves = %w[a6]
+    check_moves hits, moves, b.pieces['a5']
+
+    # e5
+    hits = %w[]
+    moves = %w[e4]
+    check_moves hits, moves, b.pieces['e5']
+
+    # f5
+    hits = %w[]
+    moves = %w[]
+    check_moves hits, moves, b.pieces['f5']
+
+    # f6
+    hits = %w[]
+    moves = %w[]
+    check_moves hits, moves, b.pieces['f6']
+
+    # g6
+    hits = %w[h7]
+    moves = %w[g7]
+    check_moves hits, moves, b.pieces['g6']
+
+    # h7
+    hits = %w[g6]
+    moves = %w[h6 h5]
+    check_moves hits, moves, b.pieces['h7']
+
+    # d8
+    hits = %w[]
+    moves = %w[]
+    check_moves hits, moves, b.pieces['d8']
+
+    g.delete!
+  end
+
+  def test_queen
+    g = MailChess::Game.new!(@db, @p1, @p2, 'test@mail')
+    b = g.board
+
+    MailChess::Piece::Bishop.new!(@db, b, 'g1', :white)
+    MailChess::Piece::Knight.new!(@db, b, 'b3', :white)
+    MailChess::Piece::Queen.new!(@db, b, 'e3', :black)
+    MailChess::Piece::Pawn.new!(@db, b, 'e5', :black)
+    MailChess::Piece::Knight.new!(@db, b, 'd6', :black)
+    MailChess::Piece::Rook.new!(@db, b, 'h6', :white)
+    MailChess::Piece::Queen.new!(@db, b, 'a7', :white)
+    MailChess::Piece::Pawn.new!(@db, b, 'f7', :white)
+    MailChess::Piece::Pawn.new!(@db, b, 'g7', :black)
+    
+    b.generate_pieces_moves
+
+    # e3
+    hits = %w[g1 b3 h6 a7]
+    moves = %w[c1 e1 d2 e2 f2 c3 d3 f3 g3 h3 d4 e4 f4 c5 g5 b6]
+    check_moves hits, moves, b.pieces['e3']
+
+    # a7
+    hits = %w[e3]
+    moves = %w[a1 a2 a3 a4 d4 a5 c5 a6 b6 b7 c7 d7 e7 a8 b8]
+    check_moves hits, moves, b.pieces['a7']
+  end
+
+  def test_rook
+    g = MailChess::Game.new!(@db, @p1, @p2, 'test@mail')
+    b = g.board
+
+    MailChess::Piece::Rook.new!(@db, b, 'a3', :white)
+    MailChess::Piece::Knight.new!(@db, b, 'c3', :black)
+    MailChess::Piece::Rook.new!(@db, b, 'f4', :white)
+    MailChess::Piece::Pawn.new!(@db, b, 'h4', :black)
+    MailChess::Piece::Rook.new!(@db, b, 'c8', :black)
+    MailChess::Piece::Rook.new!(@db, b, 'f8', :black)
+
+    b.generate_pieces_moves
+    
+    # a3
+    hits = %w[c3]
+    moves = %w[a1 a2 b3 a4 a5 a6 a7 a8]
+    check_moves hits, moves, b.pieces['a3']
+
+    # f4
+    hits = %w[f8 h4]
+    moves = %w[f1 f2 f3 a4 b4 c4 d4 e4 g4 f5 f6 f7]
+    check_moves hits, moves, b.pieces['f4']
+
+    # c8
+    hits = %w[]
+    moves = %w[c4 c5 c6 c7 a8 b8 d8 e8]
+    check_moves hits, moves, b.pieces['c8']
+
+    # f8
+    hits = %w[f4]
+    moves = %w[f5 f6 f7 d8 e8 g8 h8]
+    check_moves hits, moves, b.pieces['f8']
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mail_chess
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-07 00:00:00.000000000 Z
+date: 2012-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.37.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.37.0
 description: Play chess with your friends in email!
 email: karaszandris@gmail.com
 executables: []
@@ -46,7 +46,10 @@ files:
 - lib/mail_chess.rb
 - Rakefile
 - README
+- test/check_mate_test.rb
 - test/db_operations_test.rb
+- test/piece_moves_test.rb
+- test/perform_move_test.rb
 homepage: http://rubygems.org/gems/mail_chess
 licenses: []
 post_install_message: