Class: Chess::Game

Inherits:
CGame
  • Object
show all
Defined in:
lib/chess/game.rb

Overview

This class rappresents a chess game.

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from CGame

#[], #coord_moves, #current, #draw, #each, #full_moves, #move2, #move3, #moves, #resign, #result, #rollback!, #set_fen!, #size, #threefold_repetition?, #to_s

Constructor Details

#initialize(moves = []) ⇒ Game

Create a new game. If an array of moves is provided, the moves will be performed.

May be raise an IllegalMoveError or BadNotationError.



11
12
13
 
# File 'lib/chess/game.rb', line 11

def initialize(moves = [])
  moves.each { |m| move(m) }
end

Class Method Details

.load_fen(fen) ⇒ Object

Creates a new game from a FEN string.

May be raise an InvalidFenFormatError.

Warning: this game do not have history before the FEN placement.



43
44
45
46
47
48
49
50
51
 
# File 'lib/chess/game.rb', line 43

def self.load_fen(fen)
  if fen =~ /^((?:[PRNBQKprnbqk1-8]{1,8}\/){7}[RNBQKPrnbqkp1-8]{1,8})\s(w|b)\s(K?Q?k?q?|-)\s([a-h][1-8]|-)\s(\d+)\s(\d+)$/
    game = Chess::Game.new
    game.set_fen!(fen)
    return game
  else
    raise InvalidFenFormatError.new(fen)
  end
end

.load_pgn(file) ⇒ Object

Creates a new game from a file in PGN format.

May be raise an InvalidPgnFormatError or IllegalMoveError or BadNotationError.



18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
# File 'lib/chess/game.rb', line 18

def self.load_pgn(file)
  pgn = Chess::Pgn.new(file)
  game = Chess::Game.new
  pgn.moves.each { |m| game.move(m) }
  if !game.over?
    case pgn.result
    when '1-0'
      game.resign(:black)
    when '0-1'
      game.resign(:white)
    when '1/2-1/2'
      if game.board.insufficient_material? || game.board.stalemate? ||
        game.threefold_repetition? || game.board.fifty_rule_move?
        game.draw
      end
    end
  end
  return game
end

Instance Method Details

#active_player ⇒ Object

Returns :white if the active player is the white player, :black otherwise.



87
88
89
 
# File 'lib/chess/game.rb', line 87

def active_player
  self.board.active_color ? :black : :white
end

#inactive_player ⇒ Object

Returns :white if the inactive player is the white player, :black otherwise.



92
93
94
 
# File 'lib/chess/game.rb', line 92

def inactive_player
  self.board.active_color ? :white : :black
end

#move(m) ⇒ Object Also known as: move=, <<

Make a move. This add a new Board in the Storyboard.

Parameters are:

m

represents the short algebraic chess notation string of the move. m can be from_square plus to_square (‘e2e4’, …, ‘b1c3’) (coordinate chess notation).

This method returns a string that represents the short algebraic chess notation of the move.

Raise an IllegalMoveError if the move is illegal. Raise an BadNotationError if the short algebraic chess notation is malformed.



66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/chess/game.rb', line 66

def move(m)
  begin
    expand = expand_move(m)
    if expand[:from]
      move2(expand[:from], expand[:to], expand[:promotion])
    else
      super(expand[:name], expand[:dis], expand[:to], expand[:promotion])
    end
  rescue IllegalMoveError => e
    raise IllegalMoveError.new("Illegal move '#{m}'\n#{self.active_player} turn\n#{self.to_s}")
  end
end

#moves=(moves) ⇒ Object

Make the array of moves.



82
83
84
 
# File 'lib/chess/game.rb', line 82

def moves=(moves)
  moves.each { |m| move(m) }
end

#over? ⇒ Boolean

Returns true if the game is over

Returns:

  • (Boolean) 


140
141
142
 
# File 'lib/chess/game.rb', line 140

def over?
  return self.result != '*'
end

#pgn ⇒ Object

Returns the PGN rappresenting the game.



145
146
147
148
149
150
 
# File 'lib/chess/game.rb', line 145

def pgn
  pgn = Chess::Pgn.new
  pgn.moves = self.moves
  pgn.result = self.result
  return pgn
end

#status ⇒ Object

Returns the status of the game.

Possible states are:

  • in_progress

    the game is in progress.

  • white_won

    white player has won with a checkmate.

  • black_won

    black player has won with a checkmate.

  • white_won_resign

    white player has won for resign.

  • black_won_resign

    black player has won for resign.

  • stalemate

    draw for stalemate.

  • insufficient_material

    draw for insufficient material to checkmate.

  • fifty_rule_move

    draw for fifty rule move.

  • threefold_repetition

    draw for threefold_repetition.

  • unknown

    something went wrong.



109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/chess/game.rb', line 109

def status
  case self.result
  when '*'
    return :in_progress
  when '1-0'
    if self.board.checkmate?
      return :white_won
    else
      return :white_won_resign
    end
  when '0-1'
    if self.board.checkmate?
      return :black_won
    else
      return :black_won_resign
    end
  when '1/2-1/2'
    if self.board.stalemate?
      return :stalemate
    elsif self.board.insufficient_material?
      return :insufficient_material
    elsif self.board.fifty_rule_move?
      return :fifty_rule_move
    elsif self.threefold_repetition?
      return :threefold_repetition
    end
  end
  return :unknown
end