Class: Chess::CGame

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

Direct Known Subclasses

Game

Instance Method Summary collapse

Instance Method Details

#[] ⇒ Object

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



215
216
217
218
219
220
221
222
223
224
225
 
# File 'ext/chess.c', line 215

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

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



263
264
265
266
267
268
269
270
271
272
273
 
# File 'ext/chess.c', line 263

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 ⇒ Object Also known as: board

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



233
234
235
236
237
238
239
 
# File 'ext/chess.c', line 233

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

#draw ⇒ Object

The game result is set to draw.



200
201
202
203
204
205
206
207
 
# File 'ext/chess.c', line 200

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

#each {|board, move, full_move, index| ... } ⇒ Object

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.

Yields:



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

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



275
276
277
278
279
280
 
# File 'ext/chess.c', line 275

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

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.



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

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

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.



110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
# File 'ext/chess.c', line 110

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

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.



153
154
155
156
157
158
159
160
161
162
163
164
165
166
 
# File 'ext/chess.c', line 153

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

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



246
247
248
249
250
251
252
253
254
255
256
 
# File 'ext/chess.c', line 246

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

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.



178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
 
# File 'ext/chess.c', line 178

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

Returns the result of the game:

*

game in progress;

1-0

white won;

0-1

black won;

1/2-1/2

draw



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

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

Rollback last move.



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

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

#set_fen!(fen) ⇒ Object

Set the game position with a FEN string.

Parameters are:

fen

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



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

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

#size ⇒ Object

Returns the number of moves done.



324
325
326
327
328
329
330
 
# File 'ext/chess.c', line 324

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) 


288
289
290
291
292
293
294
295
296
297
 
# File 'ext/chess.c', line 288

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

Current board to string.



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

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