Class: Chess::CGame

Inherits:
Object
  • Object
show all
Defined in:
ext/chess/chess.c,
ext/chess/chess.c

Overview

This class rappresents a collection of boards of a single chess game.

Direct Known Subclasses

Game

Instance Method Summary collapse

Instance Method Details

#[](n) ⇒ Board

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

Returns:



210
211
212
213
214
215
216
217
218
219
220
# File 'ext/chess/chess.c', line 210

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;
}

#coord_movesArray<String>

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

Returns:

  • (Array<String>)


258
259
260
261
262
263
264
265
266
267
# File 'ext/chess/chess.c', line 258

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

#currentBoard Also known as: board

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

Returns:



228
229
230
231
232
233
234
# File 'ext/chess/chess.c', line 228

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

#drawnil

The game result is set to draw.

Returns:

  • (nil)


195
196
197
198
199
200
201
202
# File 'ext/chess/chess.c', line 195

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

#each {|board, move, coord_move, index| ... } ⇒ Game, Array<String>

Cycle the Game.

Yields:

  • (board, move, coord_move, index)

    Calls block once for each Board in self, passing that board, move, coord_move and index as parameters.

Returns:

  • (Game)

    Returns self if a block is given.

  • (Array<String>)

    Returns the array of game moves if no block is given.



339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
# File 'ext/chess/chess.c', line 339

VALUE
game_each (VALUE self)
{
  if (!rb_block_given_p ())
    return game_moves(self);
  Game *g;
  Data_Get_Struct (self, Game, g);
  for (int 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_movesObject

Deprecated.

Use #coord_moves instead.



273
274
275
276
277
278
# File 'ext/chess/chess.c', line 273

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) ⇒ String

Note:

This add a new Board in the Game.

Make a move.

Parameters:

  • piece (String)

    The character of the moving piece (‘P’, ‘R’, ‘N’, ‘B’, ‘Q’, ‘K’).

  • disambiguating (String)

    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);

    • the rank of departure (if the files are the same but the ranks differ);

    • 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 nil if no needed.

  • to_coord (String)

    The square where the moving piece will (‘a1’, ‘a2’, … , ‘h7’, ‘h8’).

  • promote_in (String)

    The character of promotion piece (‘R’, ‘N’, ‘B’, ‘Q’). If not nil and no promotion occured raise an IllegalMoveError. If nil, ‘Q’ is the default.

Returns:

  • (String)

    Returns a string that represents the short algebraic chess notation of the move.

Raises:



71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
# File 'ext/chess/chess.c', line 71

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 = rb_disambiguating == Qnil ? NULL : StringValuePtr (rb_disambiguating);
  char *to_coord = StringValuePtr (rb_to_coord);
  char promote_in = rb_promote_in == Qnil ? '\0' : StringValuePtr (rb_promote_in)[0];
  int from, to;
  if (
    get_coord (board, piece, disambiguating, to_coord, promote_in, &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) ⇒ String

Note:

This add a new Board in the Game.

Make a move.

Parameters:

  • from (String)

    The 2 character string representing the starting square of the moving piece (‘a1’, ‘a2’, … , ‘h7’, ‘h8’).

  • to (String)

    The 2 character string representing the ending square of the moving piece (‘a1’, ‘a2’, … , ‘h7’, ‘h8’).

  • promote_in (String)

    The character of promotion piece (‘R’, ‘N’, ‘B’, ‘Q’). If not nil and no promotion occured raise an IllegalMoveError. If nil, ‘Q’ is the default.

Returns:

  • (String)

    Returns a string that represents the short algebraic chess notation of the move.

Raises:



106
107
108
109
110
111
112
113
114
115
116
117
118
119
# File 'ext/chess/chess.c', line 106

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 = rb_promote_in == Qnil ? '\0' : 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) ⇒ String

Note:

This add a new Board in the Game.

Make a move. 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:

  • from (Integer)

    The integer representing the starting square of the moving piece.

  • to (Integer)

    The integer representing the ending square of the moving piece.

  • promote_in (String)

    The character of promotion piece (‘R’, ‘N’, ‘B’, ‘Q’). If not nil and no promotion occured raise an IllegalMoveError. If nil, ‘Q’ is the default.

Returns:

  • (String)

    Returns a string that represents the short algebraic chess notation of the move.

Raises:



150
151
152
153
154
155
156
157
158
159
160
161
162
163
# File 'ext/chess/chess.c', line 150

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 = rb_promote_in == Qnil ? '\0' : 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");
}

#movesArray<String>

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

Returns:

  • (Array<String>)


241
242
243
244
245
246
247
248
249
250
# File 'ext/chess/chess.c', line 241

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

#resign(color) ⇒ nil

The game result is set to ‘1-0’ if color is black, otherwise is set to ‘0-1’ if color is white.

Parameters:

  • color (String, Symbol)

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

Returns:

  • (nil)


173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
# File 'ext/chess/chess.c', line 173

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;
}

#resultString

Returns the result of the game.

Returns:

  • (String)

    Returns the result of the game:

    • *: game in progress;

    • 1-0: white won;

    • 0-1: black won;

    • 1/2-1/2: draw.



306
307
308
309
310
311
312
313
314
315
# File 'ext/chess/chess.c', line 306

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!Game

Rollback last move.

Returns:

  • (Game)

    Returns self with last move cancelled.



360
361
362
363
364
365
366
367
# File 'ext/chess/chess.c', line 360

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

#set_fen!(fen) ⇒ Game

Set the game position by FEN string.

Parameters:

  • fen (String)

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

Returns:

  • (Game)

    Returns self with position of the pieces corresponding to the FEN string.



36
37
38
39
40
41
42
43
# File 'ext/chess/chess.c', line 36

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

#sizeInteger

Returns the number of moves done.

Returns:

  • (Integer)


322
323
324
325
326
327
328
# File 'ext/chess/chess.c', line 322

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

#threefold_repetition?Boolean

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

Returns:

  • (Boolean)


285
286
287
288
289
290
291
292
293
294
# File 'ext/chess/chess.c', line 285

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

#to_sString

Current Board to string.

Returns:

  • (String)


374
375
376
377
378
379
380
381
382
383
384
# File 'ext/chess/chess.c', line 374

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;
}