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_moves ⇒ Array<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;
}

#current ⇒ Board 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));
}

#draw ⇒ nil

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_moves ⇒ Object

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

#moves ⇒ Array<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;
}

#result ⇒ String

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

#size ⇒ Integer

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

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