Chess::CGame

[n] Link

Returns the n-th Board of the Game or nil if the n-th Board does not exist.

Source: show

VALUE
game_boards (VALUE self, VALUE index)
{
  Game *g;
  Data_Get_Struct (self, Game, g);
  int n = FIX2INT (index);
  Board *board = get_board (g, n);
  if (board)
    return Data_Wrap_Struct (board_klass, 0, 0, board);
  return Qnil;
}

board() Link

Alias for: current

coord_moves Link

Returns the array with all moves done in coordinate chess notation (es: b1c3).

Source: show

VALUE
game_coord_moves (VALUE self)
{
  Game *g;
  Data_Get_Struct (self, Game, g);
  int i;
  VALUE moves = rb_ary_new ();
  for (i = 0; i < g->current; i++)
    rb_ary_push (moves, rb_str_new2 (g->coord_moves[i]));
  return moves;
}

current Link

Returns the current Board of the Game (the current chess position of the game).

Also aliased as: board

Source: show

VALUE
game_current_board (VALUE self)
{
  Game *g;
  Data_Get_Struct (self, Game, g);
  return game_boards (self, INT2FIX (g->current-1));
}

draw Link

The game result is set to draw.

Source: show

VALUE
game_draw (VALUE self)
{
  Game *g;
  Data_Get_Struct (self, Game, g);
  g->result = DRAW;
  return Qnil;
}

each { |board, move, full_move, index| block } Link

Calls block once for each board in self, passing that board, move, full_move and index as parameters. Return self. If no block is given, the array of game moves is returned instead.

Source: show

VALUE
game_each (VALUE self)
{
  if (!rb_block_given_p ())
    return game_moves(self);
  int i;
  Game *g;
  Data_Get_Struct (self, Game, g);
  for (i = 0; i < g->current; i++)
    rb_yield_values (4, Data_Wrap_Struct (board_klass, 0, 0, get_board (g, i)),
                     rb_str_new2 (g->moves[i]), rb_str_new2 (g->coord_moves[i]),
                     INT2FIX (i));
  return self;
}

full_moves() Link

Source: show

VALUE
game_full_moves (VALUE self)
{
  printf ("DEPRECATION WARNING: `full_moves` is deprecated and will be removed, please use `coord_moves` to get the array with all moves done in coordinate chess notation.\n");
  return game_coord_moves (self);
}

move(piece, disambiguating, to_coord, promote_in) Link

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

Parameters are:

piece

the character of the moving piece ('P', 'R', 'N', 'B', 'Q', 'K').

disambiguating

when two (or more) identical pieces can move to the same square, the moving piece is uniquely identified by specifying the piece's letter, followed by (in descending order of preference):

the file of departure (if they differ); or
the rank of departure (if the files are the same but the ranks differ); or
both the rank and file (if neither alone is sufficient to identify the piece—which occurs only in rare cases where one or more pawns have promoted, resulting in a player having three or more identical pieces able to reach the same square).

Keep blank if no needed.

to_coord

the square where the moving piece will ('a1', 'a2', … , 'h7', 'h8').

promote_in

the character of promotion piece ('R', 'N', 'B', 'Q'). If no promotion occured, this param will be ignored. If no value is passed, 'Q' is the default.

This method returns a string that represents the short algebraic chess notation of the move or raise an IllegalMoveError if the move is illegal.

Source: show

VALUE
game_move (VALUE self, VALUE rb_piece, VALUE rb_disambiguating, VALUE rb_to_coord, VALUE rb_promote_in)
{
  Game *g;
  Data_Get_Struct (self, Game, g);
  Board *board = current_board (g);
  char piece = StringValuePtr (rb_piece)[0];
  char *disambiguating = StringValuePtr (rb_disambiguating);
  char *to_coord = StringValuePtr (rb_to_coord);
  char promote_in = StringValuePtr (rb_promote_in)[0];
  int from, to;
  get_coord (board, piece, disambiguating, to_coord, promote_in, &from, &to);
  // printf ("From: %d, To: %d, Promo: %c\n", from , to , promote_in);
  if (pseudo_legal_move (board, from, to) && apply_move (g, from, to, promote_in))
    return rb_str_new2 (current_move (g));
  else
    rb_raise (illegal_move_error, "Illegal move");
}

move2(from, to, promote_in) Link

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

Parameters are:

from: the 2 character string representing the starting square of the moving piece ('a1', 'a2', … , 'h7', 'h8').
to: the 2 character string representing the ending square of the moving piece ('a1', 'a2', … , 'h7', 'h8').
promote_in: the character of promotion piece ('R', 'N', 'B', 'Q'). If no promotion occured, this param will be ignored. If no value is passed, 'Q' is the default.

This method returns a string that represents the short algebraic chess notation of the move or raise an IllegalMoveError if the move is illegal.

Source: show

VALUE
game_move2 (VALUE self, VALUE rb_from, VALUE rb_to, VALUE rb_promote_in)
{
  Game *g;
  Data_Get_Struct (self, Game, g);
  Board *board = current_board (g);
  int from = coord_to_square (StringValuePtr (rb_from));
  int to = coord_to_square (StringValuePtr (rb_to));
  char promote_in = StringValuePtr (rb_promote_in)[0];
  if (pseudo_legal_move (board, from, to) && apply_move (g, from, to, promote_in))
    return rb_str_new2 (current_move (g));
  else
    rb_raise (illegal_move_error, "Illegal move");
}

move3(from, to, promote_in) Link

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

Each square on the chessboard is represented by an integer according to the following scheme:

8 | 56 57 58 59 60 61 62 63
7 | 48 49 50 51 52 53 54 55
6 | 40 41 42 43 44 45 46 47
5 | 32 33 34 35 36 37 38 39
4 | 24 25 26 27 28 29 30 31
3 | 16 17 18 19 20 21 22 23
2 |  8  9 10 11 12 13 14 15
1 |  0  1  2  3  4  5  6  7
  +-------------------------
     a  b  c  d  e  f  g  h

Parameters are:

from: the integer representing the starting square of the moving piece.
to: the integer representing the ending square of the moving piece.
promote_in: the character of promotion piece ('R', 'N', 'B', 'Q'). If no promotion occured, this param will be ignored. If no value is passed, 'Q' is the default.

This method returns a string that represents the short algebraic chess notation of the move or raise an IllegalMoveError if the move is illegal.

Source: show

VALUE
game_move3 (VALUE self, VALUE rb_from, VALUE rb_to, VALUE rb_promote_in)
{
  Game *g;
  Data_Get_Struct (self, Game, g);
  Board *board = current_board (g);
  int from = FIX2INT (rb_from);
  int to = FIX2INT (rb_to);
  char promote_in = StringValuePtr (rb_promote_in)[0];
  if (pseudo_legal_move (board, from, to) && apply_move (g, from, to, promote_in))
    return rb_str_new2 (current_move (g));
  else
    rb_raise (illegal_move_error, "Illegal move");
}

moves Link

Returns the array with all moves done (es: Nc3).

Source: show

VALUE
game_moves (VALUE self)
{
  Game *g;
  Data_Get_Struct (self, Game, g);
  int i;
  VALUE moves = rb_ary_new ();
  for (i = 0; i < g->current; i++)
    rb_ary_push (moves, rb_str_new2 (g->moves[i]));
  return moves;
}

resign(color) Link

The game result is set to '1-0' if color is “black”, otherwise is set to '0-1' if color is “white”.

Parameters are:

color: the color of the player who resigns the game; it can be :white or :black.

Source: show

VALUE
game_resign (VALUE self, VALUE color)
{
  Game *g;
  Data_Get_Struct (self, Game, g);
  const char *c;
  if (TYPE (color) == T_SYMBOL)
    c = rb_id2name (SYM2ID (color));
  else
    c = StringValuePtr (color);
  if (strcmp (c, "black") == 0)
    g->result = WHITE_WON;
  else if (strcmp (c, "white") == 0)
    g->result = BLACK_WON;
  return Qnil;
}

result Link

Returns the result of the game:

*: game in progress;
1-0: white won;
0-1: black won;
1/2-1/2: draw

Source: show

VALUE
game_result (VALUE self)
{
  Game *g;
  Data_Get_Struct (self, Game, g);
  char *result = result_to_s (g->result);
  VALUE rb_result = rb_str_new2 (result);
  free (result);
  return rb_result;
}

rollback! Link

Rollback last move.

Source: show

VALUE
game_rollback (VALUE self)
{
  Game *g;
  Data_Get_Struct (self, Game, g);
  rollback (g);
  return self;
}

set_fen!(fen) Link

Set the game position with a FEN string.

Parameters are:

fen: the FEN (Forsyth–Edwards Notation) string notation used to set the game position.

Source: show

VALUE
game_set_fen (VALUE self, VALUE fen)
{
  Game *g;
  Data_Get_Struct (self, Game, g);
  set_fen (g, StringValuePtr (fen));
  return self;
}

size Link

Returns the number of moves done.

Source: show

VALUE
game_size (VALUE self)
{
  Game *g;
  Data_Get_Struct (self, Game, g);
  return INT2FIX (g->current);
}

threefold_repetition? Link

Returns true if a player can claim draw by the threefold repetition rule, false otherwise.

Source: show

VALUE
game_threefold_repetition (VALUE self)
{
  Game *g;
  Data_Get_Struct (self, Game, g);
  if (threefold_repetition (g))
    return Qtrue;
  else
    return Qfalse;
}

to_s Link

Current board to string.

Source: show

VALUE
game_to_s (VALUE self)
{
  Game *g;
  Data_Get_Struct (self, Game, g);
  Board *b = get_board (g, g->current-1);
  char *s = print_board (b);
  VALUE rb_s = rb_str_new2 (s);
  free (s);
  return rb_s;
}

Class Chess::CGame < Object