Nyaaori/rockbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
rockbox/apps/plugins/chessbox/chessbox_pgn.c
Solomon Peachy 5572904887 chessbox: Fixes and enhancements 
- Unfinished game is now saved along with current position.
- All savings are automatically done on shutdown.
- Implemented facility to view played games.
- Fixed bug that prevented program from the very first move.

Patch by Igor Poretsky

Change-Id: I997b97752e4362ed953309bea985d071f9db229b
2019-07-28 18:39:41 -04:00

942 lines
35 KiB
C
Raw Blame History

/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2007 Mauricio Peccorini
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "plugin.h"
#include "chessbox_pgn.h"
#define LOG_FILE PLUGIN_GAMES_DATA_DIR "/chessbox.log"
int loghandler;
const char *pgn_file = PLUGIN_GAMES_DATA_DIR "/chessbox.pgn";
short kn_offs[8][2] = {{2,1},{2,-1},{-2,1},{-2,-1},{1,2},{1,-2},{-1,2},{-1,-2}};
short rk_offs[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};
short bp_offs[4][2] = {{1,1},{-1,1},{1,-1},{-1,-1}};
/* global vars for pl_malloc() */
void *bufptr = NULL;
size_t bufleft;
/* simple function to "allocate" memory in pluginbuffer.
* (borrowed from dict.c)
*/
static void *pl_malloc(size_t size)
{
void *ptr;
ptr = bufptr;
if (bufleft < size)
{
return NULL;
}
else
{
bufptr = (char*)(bufptr) + size;
bufleft -= size;
return ptr;
}
}
/* init function for pl_malloc() */
static void pl_malloc_init(void)
{
bufptr = rb->plugin_get_buffer(&bufleft);
}
static void process_tag(struct pgn_game_node* game, char* buffer){
char tag_type[20];
char tag_value[255];
short pos=0, pos2=0;
while (buffer[pos+1] != ' '){
tag_type[pos] = buffer[pos+1];
pos++;
}
tag_type[pos] = '\0';
pos+=3;
while (buffer[pos] != '"'){
tag_value[pos2] = buffer[pos];
pos++; pos2++;
}
/* truncate tag values that are too large */
if (pos2 > 19){
pos2 = 19;
}
tag_value[pos2] = '\0';
if (rb->strcmp(tag_type,"White") == 0){
rb->strcpy(game->white_player, tag_value);
}
if (rb->strcmp(tag_type,"Black") == 0){
rb->strcpy(game->black_player, tag_value);
}
if (rb->strcmp(tag_type,"Result") == 0){
rb->strcpy(game->result, tag_value);
}
if (rb->strcmp(tag_type,"Date") == 0){
rb->strcpy(game->game_date, tag_value);
}
}
static unsigned short get_next_token(const char* line_buffer, unsigned short initial_pos,
char* token_buffer){
unsigned short pos, token_pos=0;
for (pos = initial_pos;line_buffer[pos] == ' ' || line_buffer[pos] == '.';pos++);
do {
token_buffer[token_pos] = line_buffer[pos];
pos++; token_pos++;
} while (line_buffer[pos] != ' ' && line_buffer[pos] != '.'
&& line_buffer[pos] != '\0');
/* ignore annotations */
while (token_buffer[token_pos-1] == '!' || token_buffer[token_pos-1] == '?'){
token_pos--;
}
token_buffer[token_pos] = '\0';
return pos;
}
static unsigned short piece_from_pgn(char pgn_piece){
switch (pgn_piece){
case 'R':
return rook;
case 'N':
return knight;
case 'B':
return bishop;
case 'Q':
return queen;
case 'K':
return king;
}
return no_piece;
}
static char pgn_from_piece(unsigned short piece, unsigned short color){
char pgn_piece = ' ';
switch (piece){
case pawn:
pgn_piece = 'P';
break;
case rook:
pgn_piece = 'R';
break;
case knight:
pgn_piece = 'N';
break;
case bishop:
pgn_piece = 'B';
break;
case queen:
pgn_piece = 'Q';
break;
case king:
pgn_piece = 'K';
break;
case no_piece:
pgn_piece = ' ';
break;
}
if (color == black && pgn_piece != ' '){
pgn_piece += 32;
}
return pgn_piece;
}
static bool pgn_to_coords(struct pgn_ply_node* ply){
bool success = true;
unsigned short str_length = rb->strlen(ply->pgn_text);
char str[9];
rb->strcpy(str,ply->pgn_text);
ply->column_from = 0xFF;
ply->row_from = 0xFF;
ply->column_to = 0xFF;
ply->row_to = 0xFF;
ply->taken_piece = no_piece;
ply->promotion_piece = no_piece;
ply->enpassant = false;
ply->castle = false;
ply->promotion = false;
unsigned short i, j, piece;
bool found = false;
if (str_length >= 3 && (str[0] == 'O' || str[0] == '0') && str[1] == '-'
&& (str[2] == 'O' || str[2] == '0')) {
/* castling */
ply->castle = true;
if (str_length >= 5 && str[3] == '-' && (str[4] == 'O' || str[4] == '0')){
/* castle queenside */
if (ply->player == white){
ply->row_from = 0; ply->column_from = 4;
ply->row_to = 0; ply->column_to = 2;
/* update the rook's position, the king's position will be updated later */
board[locn[0][3]] = rook; color[locn[0][3]] = white;
board[locn[0][0]] = no_piece; color[locn[0][0]] = neutral;
} else {
ply->row_from = 7; ply->column_from = 4;
ply->row_to = 7; ply->column_to = 2;
board[locn[7][3]] = rook; color[locn[7][3]] = black;
board[locn[7][0]] = no_piece; color[locn[7][0]] = neutral;
}
} else {
/* castle kingside */
if (ply->player == white){
ply->row_from = 0; ply->column_from = 4;
ply->row_to = 0; ply->column_to = 6;
board[locn[0][5]] = rook; color[locn[0][5]] = white;
board[locn[0][7]] = no_piece; color[locn[0][7]] = neutral;
} else {
ply->row_from = 7; ply->column_from = 4;
ply->row_to = 7; ply->column_to = 6;
board[locn[7][5]] = rook; color[locn[7][5]] = black;
board[locn[7][7]] = no_piece; color[locn[7][7]] = neutral;
}
}
} else if (str[0] >= 'a' && str[0] <= 'h'){
/* pawns */
ply->column_from = str[0] - 'a';
if (str[1] == 'x'){
ply->row_from = str[3] - '1' + ((ply->player==white)?-1:1);
ply->row_to = str[3] - '1';
ply->column_to = str[2] - 'a';
if (board[locn[ply->row_to][ply->column_to]] == no_piece){
/* en-passant, remove the pawn */
ply->enpassant = true;
board[locn[ply->row_from][ply->column_to]] = no_piece;
color[locn[ply->row_from][ply->column_to]] = neutral;
ply->taken_piece = pawn;
} else {
ply->taken_piece = board[locn[ply->row_to][ply->column_to]];
}
} else {
ply->column_to = ply->column_from;
ply->row_from = str[1] - '1' + ((ply->player==white)?-1:1);
ply->row_to = str[1] - '1';
}
if (board[locn[ply->row_from][ply->column_from]] == no_piece){
/* the pawn moved two squares */
ply->row_from += ((ply->player==white)?-1:1);
}
if (ply->row_to == 7 || ply->row_to == 0){
/* promotion */
if (str[2] == '='){
ply->promotion_piece = piece_from_pgn(str[3]);
} else {
ply->promotion_piece = piece_from_pgn(str[5]);
}
/* change the piece in the original position and wait
* for the code at the end to move it
*/
board[locn[ply->row_from][ply->column_from]] = ply->promotion_piece;
}
} else {
/* the other pieces */
piece = piece_from_pgn(str[0]);
if (str[2] == 'x'){
/* taken a piece and move was ambiguous */
ply->column_to = str[3] - 'a';
ply->row_to = str[4] - '1';
ply->taken_piece = board[locn[ply->row_to][ply->column_to]];
if (str[1] >= 'a' && str[1] <= 'h') {
ply->column_from = str[1] - 'a';
} else {
ply->row_from = str[1] - '1';
}
} else if (str[1] == 'x') {
/* taken a piece */
ply->column_to = str[2] - 'a';
ply->row_to = str[3] - '1';
ply->taken_piece = board[locn[ply->row_to][ply->column_to]];
} else if (str_length >= 4 && str[3] >= '0' && str[3] <= '9'){
/* no piece taken and move was ambiguous */
ply->column_to = str[2] - 'a';
ply->row_to = str[3] - '1';
if (str[1] >= 'a' && str[1] <= 'h') {
ply->column_from = str[1] - 'a';
} else {
ply->row_from = str[1] - '1';
}
} else {
/* regular move */
ply->column_to = str[1] - 'a';
ply->row_to = str[2] - '1';
}
if (piece == knight) {
for (i=0;i<8;i++){
if (ply->row_to + kn_offs[i][0] >= 0 && ply->row_to + kn_offs[i][0] <= 7
&& ply->column_to + kn_offs[i][1] >= 0 && ply->column_to + kn_offs[i][1] <= 7
&& board[locn[ply->row_to + kn_offs[i][0]][ply->column_to + kn_offs[i][1]]] == knight
&& color[locn[ply->row_to + kn_offs[i][0]][ply->column_to + kn_offs[i][1]]] == ply->player
&& (ply->row_from == 0xFF || ply->row_from == ply->row_to + kn_offs[i][0])
&& (ply->column_from == 0xFF || ply->column_from == ply->column_to + kn_offs[i][1])) {
ply->row_from = ply->row_to + kn_offs[i][0];
ply->column_from = ply->column_to + kn_offs[i][1];
}
}
}
if (piece == rook || piece == queen || piece == king){
for (i=0;i<4;i++){
j = 1;
found = false;
while (ply->row_to+(j*rk_offs[i][0]) >= 0 && ply->row_to+(j*rk_offs[i][0]) <= 7 &&
ply->column_to+(j*rk_offs[i][1]) >= 0 && ply->column_to+(j*rk_offs[i][1]) <= 7){
if (board[locn[ply->row_to+(j*rk_offs[i][0])][ply->column_to+(j*rk_offs[i][1])]] != no_piece) {
if (board[locn[ply->row_to+(j*rk_offs[i][0])][ply->column_to+(j*rk_offs[i][1])]] == piece &&
color[locn[ply->row_to+(j*rk_offs[i][0])][ply->column_to+(j*rk_offs[i][1])]] == ply->player &&
(ply->row_from == 0xFF || ply->row_from == ply->row_to+(j*rk_offs[i][0])) &&
(ply->column_from == 0xFF || ply->column_from == ply->column_to+(j*rk_offs[i][1]))) {
ply->row_from = ply->row_to+(j*rk_offs[i][0]);
ply->column_from = ply->column_to+(j*rk_offs[i][1]);
found = true;
}
break;
}
j++;
}
if (found) {
break;
}
}
}
if (piece == bishop || ((piece == queen || piece == king) && !found)){
for (i=0;i<4;i++){
j = 1;
found = false;
while (ply->row_to+(j*bp_offs[i][0]) >= 0 && ply->row_to+(j*bp_offs[i][0]) <= 7 &&
ply->column_to+(j*bp_offs[i][1]) >= 0 && ply->column_to+(j*bp_offs[i][1]) <= 7){
if (board[locn[ply->row_to+(j*bp_offs[i][0])][ply->column_to+(j*bp_offs[i][1])]] != no_piece) {
if (board[locn[ply->row_to+(j*bp_offs[i][0])][ply->column_to+(j*bp_offs[i][1])]] == piece &&
color[locn[ply->row_to+(j*bp_offs[i][0])][ply->column_to+(j*bp_offs[i][1])]] == ply->player &&
(ply->row_from == 0xFF || ply->row_from == ply->row_to+(j*bp_offs[i][0])) &&
(ply->column_from == 0xFF || ply->column_from == ply->column_to+(j*bp_offs[i][1]))) {
ply->row_from = ply->row_to+(j*bp_offs[i][0]);
ply->column_from = ply->column_to+(j*bp_offs[i][1]);
found = true;
}
break;
}
j++;
}
if (found) {
break;
}
}
}
}
/* leave a very complete log of the parsing of the game while it gets stable */
for (i=0;i<8;i++){
for (j=0;j<8;j++) {
rb->fdprintf(loghandler,"%c",pgn_from_piece(board[locn[7-i][j]],color[locn[7-i][j]]));
}
rb->fdprintf(loghandler,"\n");
}
/* check bounds of row and columns should be 0-7 bad .pgn returns 0xFF */
if ((ply->row_to | ply->column_to | ply->row_from | ply->column_from) < 8)
{
/* update the board */
board[locn[ply->row_to][ply->column_to]] =
board[locn[ply->row_from][ply->column_from]];
color[locn[ply->row_to][ply->column_to]] =
color[locn[ply->row_from][ply->column_from]];
board[locn[ply->row_from][ply->column_from]] = no_piece;
color[locn[ply->row_from][ply->column_from]] = neutral;
}
else
success = false; /*ERROR*/
return success;
}
static void coords_to_pgn(struct pgn_ply_node* ply){
int pos = 0,i,j;
unsigned short moving_piece = board[locn[ply->row_from][ply->column_from]];
char unambiguous_position;
bool found = false;
char alg_move[5];
char move_buffer[10];
short move;
if (moving_piece == king){
/* check castling */
if (ply->column_from == 4 && ply->column_to == 6){
/* castling kingside */
rb->strcpy(ply->pgn_text,"O-O");
ply->castle = true;
} else if (ply->column_from == 4 && ply->column_to == 2){
/* castling queenside */
rb->strcpy(ply->pgn_text,"O-O-O");
} else {
if (board[locn[ply->row_to][ply->column_to]] != no_piece){
rb->snprintf(ply->pgn_text,10,"Kx%c%c",'a'+ply->column_to,
'1'+ply->row_to);
} else {
rb->snprintf(ply->pgn_text,10,"K%c%c",'a'+ply->column_to,
'1'+ply->row_to);
}
}
} else if (moving_piece == pawn){
if (ply->column_from != ply->column_to){
/* check enpassant */
if (board[locn[ply->row_to][ply->column_to]] == no_piece){
ply->enpassant = true;
}
/* check promotions when taking a piece */
if (ply->row_to == 0 || ply->row_to == 7) {
ply->promotion = true;
ply->promotion_piece = queen;
rb->snprintf(ply->pgn_text,10,"%cx%c%c=D", 'a'+ply->column_from,
'a'+ply->column_to,'1'+ply->row_to);
} else {
rb->snprintf(ply->pgn_text,10,"%cx%c%c", 'a'+ply->column_from,
'a'+ply->column_to,'1'+ply->row_to);
}
} else {
/* check promotions when not taking a piece */
if (ply->row_to == 0 || ply->row_to == 7) {
ply->promotion = true;
ply->promotion_piece = queen;
rb->snprintf(ply->pgn_text,10,"%c%c=D", 'a'+ply->column_to,
'1'+ply->row_to);
} else {
rb->snprintf(ply->pgn_text,10,"%c%c", 'a'+ply->column_to,
'1'+ply->row_to);
}
}
} else {
/* verify ambiguous moves for the different kinds of pieces */
unambiguous_position = '\0';
if (moving_piece == knight){
for (i=0;i<8;i++){
if (ply->row_to + kn_offs[i][0] >= 0 && ply->row_to + kn_offs[i][0] <= 7
&& ply->column_to + kn_offs[i][1] >= 0 && ply->column_to + kn_offs[i][1] <= 7
&& board[locn[ply->row_to + kn_offs[i][0]][ply->column_to + kn_offs[i][1]]] == knight
&& color[locn[ply->row_to + kn_offs[i][0]][ply->column_to + kn_offs[i][1]]] == ply->player
&& (ply->row_to + kn_offs[i][0] != ply->row_from
|| ply->column_to + kn_offs[i][1] != ply->column_from)){
if (ply->row_to + kn_offs[i][0] != ply->row_from){
unambiguous_position = '1' + ply->row_from;
} else {
unambiguous_position = 'a' + ply->column_from;
}
break;
}
}
}
if (moving_piece == rook || moving_piece == queen){
found = false;
for (i=0;i<4;i++){
j=1;
while (ply->row_to+(j*rk_offs[i][0]) >= 0 && ply->row_to+(j*rk_offs[i][0]) <= 7 &&
ply->column_to+(j*rk_offs[i][1]) >= 0 && ply->column_to+(j*rk_offs[i][1]) <= 7){
if (board[locn[ply->row_to+(j*rk_offs[i][0])][ply->column_to+(j*rk_offs[i][1])]] != no_piece) {
if (board[locn[ply->row_to+(j*rk_offs[i][0])][ply->column_to+(j*rk_offs[i][1])]] == moving_piece &&
color[locn[ply->row_to+(j*rk_offs[i][0])][ply->column_to+(j*rk_offs[i][1])]] == ply->player &&
(ply->row_to+(j*rk_offs[i][0]) != ply->row_from
|| ply->column_to+(j*rk_offs[i][1]) != ply->column_from)) {
if (ply->row_to+(j*rk_offs[i][0]) != ply->row_from){
unambiguous_position = '1' + ply->row_from;
} else {
unambiguous_position = 'a' + ply->column_from;
}
found = true;
}
break;
}
j++;
}
if (found) {
break;
}
}
}
if (moving_piece == bishop || (moving_piece == queen && !found)){
for (i=0;i<4;i++){
j=1;
while (ply->row_to+(j*bp_offs[i][0]) >= 0 && ply->row_to+(j*bp_offs[i][0]) <= 7 &&
ply->column_to+(j*bp_offs[i][1]) >= 0 && ply->column_to+(j*bp_offs[i][1]) <= 7){
if (board[locn[ply->row_to+(j*bp_offs[i][0])][ply->column_to+(j*bp_offs[i][1])]] != no_piece) {
if (board[locn[ply->row_to+(j*bp_offs[i][0])][ply->column_to+(j*bp_offs[i][1])]] == moving_piece &&
color[locn[ply->row_to+(j*bp_offs[i][0])][ply->column_to+(j*bp_offs[i][1])]] == ply->player &&
(ply->row_to+(j*bp_offs[i][0]) != ply->row_from
|| ply->column_to+(j*bp_offs[i][1]) != ply->column_from)) {
if (ply->row_to+(j*bp_offs[i][0]) != ply->row_from){
unambiguous_position = '1' + ply->row_from;
} else {
unambiguous_position = 'a' + ply->column_from;
}
found = true;
}
break;
}
j++;
}
if (found) {
break;
}
}
}
/* generate the first portion of the PGN text
* always as white so all uppercase, black/white considerations
* will be useful for FEN notation but not in this case
*/
if (unambiguous_position == '\0'){
if (board[locn[ply->row_to][ply->column_to]] != no_piece){
rb->snprintf(ply->pgn_text,10,"%cx%c%c",
pgn_from_piece(moving_piece,white) ,
'a'+ply->column_to, '1'+ply->row_to);
} else {
rb->snprintf(ply->pgn_text,10,"%c%c%c",
pgn_from_piece(moving_piece,white) ,
'a'+ply->column_to, '1'+ply->row_to);
}
} else {
if (board[locn[ply->row_to][ply->column_to]] != no_piece){
rb->snprintf(ply->pgn_text,10,"%c%cx%c%c",
pgn_from_piece(moving_piece,white) ,
unambiguous_position, 'a'+ply->column_to,
'1'+ply->row_to);
} else {
rb->snprintf(ply->pgn_text,10,"%c%c%c%c",
pgn_from_piece(moving_piece,white) ,
unambiguous_position, 'a'+ply->column_to,
'1'+ply->row_to);
}
}
}
/* update the board */
rb->snprintf(alg_move,5,"%c%c%c%c",'a' + ply->column_from, '1' + ply->row_from,
'a' + ply->column_to, '1' + ply->row_to);
/* The function returns false if the move is invalid, but since we're
* replaying the game, that should not be posible
*/
VerifyMove (ply->player, alg_move , 0 , &move, move_buffer );
/* add check/mate indicators */
for (pos=0;ply->pgn_text[pos] != '\0';pos++);
if (ply->checkmate) {
ply->pgn_text[pos] = '#'; pos++;
ply->pgn_text[pos] = '\0'; pos++;
} else if (move_buffer[4] == '+'){
ply->pgn_text[pos] = '+'; pos++;
ply->pgn_text[pos] = '\0'; pos++;
}
}
static struct pgn_game_node *get_game_info(int selected_item, void *data){
int i;
struct pgn_game_node *temp_node = (struct pgn_game_node *)data;
for (i=0;i<selected_item && temp_node != NULL;i++){
temp_node = temp_node->next_node;
}
return temp_node;
}
static const char* get_game_text(int selected_item, void *data,
char *buffer, size_t buffer_len){
struct pgn_game_node *temp_node = get_game_info(selected_item, data);
if (temp_node == NULL){
return NULL;
}
rb->snprintf(buffer, buffer_len,"%s vs. %s (%s)", temp_node->white_player,
temp_node->black_player, temp_node->game_date);
return buffer;
}
static void say_player(const char *name, bool enqueue) {
if (!rb->strcasecmp(name, "player"))
rb->talk_id(VOICE_PLAYER, enqueue);
else if (!rb->strcasecmp(name, "gnuchess"))
rb->talk_id(VOICE_GNUCHESS, enqueue);
else
rb->talk_spell(name, enqueue);
}
static int speak_game_selection(int selected_item, void *data){
struct pgn_game_node *temp_node = get_game_info(selected_item, data);
if (temp_node != NULL){
say_player(temp_node->white_player, false);
say_player(temp_node->black_player, true);
if (temp_node->game_date[0] != '?') {
char buf[12];
rb->strcpy(buf, temp_node->game_date);
buf[4] = 0;
buf[7] = 0;
rb->talk_id(LANG_MONTH_JANUARY + rb->atoi(&(buf[5])) - 1, true);
rb->talk_number(rb->atoi(&(buf[8])), true);
rb->talk_number(rb->atoi(buf), true);
}
}
return 0;
}
static void write_pgn_token(int fhandler, char *buffer, size_t *line_length){
if (*line_length + rb->strlen(buffer) + 1 > 80){
rb->fdprintf(fhandler,"\n");
*line_length = 0;
}
rb->fdprintf(fhandler,"%s ",buffer);
*line_length += (rb->strlen(buffer) + 1);
}
/* ---- api functions ---- */
struct pgn_game_node* pgn_list_games(const char* filename){
int fhandler;
char line_buffer[128];
struct pgn_game_node size_node, *first_game = NULL;
struct pgn_game_node *curr_node = NULL, *temp_node;
unsigned short game_count = 1;
int line_count = 0;
bool header_start = true, game_start = false;
if ( (fhandler = rb->open(filename, O_RDONLY)) < 0 ) return NULL;
if (bufptr == NULL){
pl_malloc_init();
}
while (rb->read_line(fhandler, line_buffer, sizeof line_buffer) > 0){
line_count++;
/* looking for a game header */
if (header_start) {
/* a new game header is found */
if (line_buffer[0] == '['){
temp_node = (struct pgn_game_node *)pl_malloc(sizeof size_node);
temp_node->next_node = NULL;
if (curr_node == NULL) {
first_game = curr_node = temp_node;
} else {
curr_node->next_node = temp_node;
curr_node = temp_node;
}
process_tag(curr_node, line_buffer);
curr_node->game_number = game_count;
curr_node->pgn_line = 0;
game_count++;
header_start = false;
game_start = true;
}
} else {
if (line_buffer[0] == '['){
process_tag(curr_node, line_buffer);
} else if (line_buffer[0] == '\r'
|| line_buffer[0] == '\n'
|| line_buffer[0] == '\0'){
if (game_start) {
game_start = false;
} else {
header_start = true;
}
} else {
if (curr_node->pgn_line == 0) {
curr_node->pgn_line = line_count;
}
}
}
}
rb->close(fhandler);
return first_game;
}
struct pgn_game_node* pgn_show_game_list(struct pgn_game_node* first_game){
int curr_selection = 0;
int button;
struct gui_synclist games_list;
int i;
struct pgn_game_node *temp_node = first_game;
for (i=0;temp_node != NULL;i++){
temp_node = temp_node->next_node;
}
rb->gui_synclist_init(&games_list, &get_game_text, first_game, false, 1, NULL);
rb->gui_synclist_set_title(&games_list, rb->str(LANG_CHESSBOX_GAMES), NOICON);
rb->gui_synclist_set_icon_callback(&games_list, NULL);
if (rb->global_settings->talk_menu)
rb->gui_synclist_set_voice_callback(&games_list, speak_game_selection);
rb->gui_synclist_set_nb_items(&games_list, i);
rb->gui_synclist_limit_scroll(&games_list, true);
rb->gui_synclist_select_item(&games_list, 0);
rb->gui_synclist_draw(&games_list);
rb->gui_synclist_speak_item(&games_list);
while (true) {
curr_selection = rb->gui_synclist_get_sel_pos(&games_list);
button = rb->get_action(CONTEXT_LIST,TIMEOUT_BLOCK);
if (rb->gui_synclist_do_button(&games_list,&button,LIST_WRAP_OFF)){
continue;
}
switch (button) {
case ACTION_STD_OK:
return get_game_info(curr_selection, first_game);
break;
case ACTION_STD_CANCEL:
return NULL;
break;
}
}
}
void pgn_parse_game(const char* filename,
struct pgn_game_node* selected_game){
struct pgn_ply_node size_ply, *first_ply = NULL;
struct pgn_ply_node *temp_ply = NULL, *curr_node = NULL;
bool success = true;
int fhandler, i;
char line_buffer[128];
char token_buffer[9];
unsigned short pos;
unsigned short curr_player = white;
fhandler = rb->open(filename, O_RDONLY);
/* seek the line where the pgn of the selected game starts */
for (i=1;i<selected_game->pgn_line;i++){
rb->read_line(fhandler, line_buffer, sizeof line_buffer);
}
loghandler = rb->open(LOG_FILE, O_WRONLY | O_CREAT, 0666);
GNUChess_Initialize();
while (rb->read_line(fhandler, line_buffer, sizeof line_buffer) > 0){
if (line_buffer[0] == '\r' || line_buffer[0] == '\n' || line_buffer[0] == '\0'){
break;
}
pos = 0;
while (pos < rb->strlen(line_buffer)){
pos = get_next_token(line_buffer, pos, token_buffer);
if ((token_buffer[0] >= 'A' && token_buffer[0] <= 'Z')
|| (token_buffer[0] >= 'a' && token_buffer[0] <= 'z')
|| (token_buffer[0] == '0' && token_buffer[2] != '1')){
temp_ply = (struct pgn_ply_node *)pl_malloc(sizeof size_ply);
/* Null pointer can be returned from pl_malloc check for this */
if (temp_ply)
{
temp_ply->player = curr_player;
curr_player = (curr_player==white)?black:white;
rb->strcpy(temp_ply->pgn_text, token_buffer);
success = pgn_to_coords(temp_ply);
temp_ply->prev_node = NULL;
temp_ply->next_node = NULL;
if (first_ply == NULL && success) {
first_ply = curr_node = temp_ply;
} else if (success){
curr_node->next_node = temp_ply;
temp_ply->prev_node = curr_node;
curr_node = temp_ply;
} else{
/* bad .pgn break loop and notify user */
first_ply = NULL;
break;
}
rb->fdprintf(loghandler,
"player: %u; pgn: %s; from: %u,%u; to: %u,%u; taken: %u.\n",
temp_ply->player, temp_ply->pgn_text, temp_ply->row_from,
temp_ply->column_from, temp_ply->row_to,
temp_ply->column_to, temp_ply->taken_piece);
}
else
first_ply = NULL;
}
}
}
rb->close(loghandler);
/* additional dummy ply to represent end of file without
*loosing the previous node's pointer
*/
if (first_ply != NULL){
temp_ply = (struct pgn_ply_node *)pl_malloc(sizeof size_ply);
temp_ply->player = neutral;
temp_ply->prev_node = curr_node;
curr_node->next_node = temp_ply;
}
selected_game->first_ply = first_ply;
rb->close(fhandler);
}
struct pgn_game_node* pgn_init_game(void){
struct pgn_game_node game_size, *game;
struct pgn_ply_node ply_size, *ply;
struct tm *current_time;
if (bufptr == NULL){
pl_malloc_init();
}
/* create an "end of game" dummy ply and assign defaults */
ply = (struct pgn_ply_node *)pl_malloc(sizeof ply_size);
ply->player = neutral;
ply->pgn_text[0] = '\0';
ply->prev_node = NULL;
ply->next_node = NULL;
/* create the game and assign defaults */
game = (struct pgn_game_node *)pl_malloc(sizeof game_size);
game->game_number = 0;
rb->strcpy(game->white_player,"Player");
rb->strcpy(game->black_player,"GnuChess");
current_time = rb->get_time();
if (current_time->tm_year < 100){
rb->snprintf(game->game_date,11,"????.??.??");
} else {
rb->snprintf(game->game_date,11,"%4u.%2u.%2u",current_time->tm_year + 1900,
current_time->tm_mon + 1, current_time->tm_mday);
}
rb->strcpy(game->result,"*");
game->pgn_line = 0;
game->first_ply = ply;
game->next_node = NULL;
return game;
}
void pgn_append_ply(struct pgn_game_node* game,
unsigned short ply_player, char *move_buffer, bool is_mate){
struct pgn_ply_node ply_size, *ply, *temp;
ply = (struct pgn_ply_node *)pl_malloc(sizeof ply_size);
ply->player = ply_player;
ply->column_from = move_buffer[0] - 'a';
ply->row_from = move_buffer[1] - '1';
ply->column_to = move_buffer[2] - 'a';
ply->row_to = move_buffer[3] - '1';
ply->castle = false;
ply->promotion = false;
ply->enpassant = false;
ply->promotion_piece = no_piece;
ply->taken_piece = no_piece;
ply->draw = false;
ply->checkmate = is_mate;
/* move the pointer to the "end of game" marker ply */
for (temp=game->first_ply;temp->next_node!=NULL;temp=temp->next_node);
/* arrange the pointers to insert the ply before the marker */
ply->next_node = temp;
ply->prev_node = temp->prev_node;
if (temp->prev_node == NULL){
game->first_ply = ply;
} else {
temp->prev_node->next_node = ply;
}
temp->prev_node = ply;
}
void pgn_set_result(struct pgn_game_node* game,
bool is_mate){
struct pgn_ply_node *ply;
for(ply=game->first_ply;ply->next_node != NULL;ply=ply->next_node);
if (is_mate){
ply->prev_node->checkmate = true;
} else {
ply->prev_node->draw = true;
}
}
void pgn_store_game(struct pgn_game_node* game){
int fhandler;
struct pgn_ply_node *ply;
unsigned ply_count;
size_t line_length=0;
char buffer[10];
GNUChess_Initialize();
ply_count=0;
ply=game->first_ply;
while (ply->next_node!=NULL){
coords_to_pgn(ply);
if (ply->checkmate){
if (ply->player == white){
rb->strcpy(game->result,"1-0");
} else {
rb->strcpy(game->result,"0-1");
}
}
if (ply->draw){
rb->strcpy(game->result,"1/2-1/2");
}
ply=ply->next_node;
ply_count++;
}
fhandler = rb->open(pgn_file, O_WRONLY|O_CREAT|O_APPEND, 0666);
/* the first 7 tags are mandatory according to the PGN specification so we
* have to include them even if the values don't make much sense
*/
rb->fdprintf(fhandler,"[Event \"Casual Game\"]\n");
rb->fdprintf(fhandler,"[Site \"?\"]\n");
rb->fdprintf(fhandler,"[Date \"%s\"]\n",game->game_date);
rb->fdprintf(fhandler,"[Round \"?\"]\n");
rb->fdprintf(fhandler,"[White \"%s\"]\n",game->white_player);
rb->fdprintf(fhandler,"[Black \"%s\"]\n",game->black_player);
rb->fdprintf(fhandler,"[Result \"%s\"]\n",game->result);
rb->fdprintf(fhandler,"[PlyCount \"%u\"]\n",ply_count);
/* leave a blank line between the tag section and the game section */
rb->fdprintf(fhandler,"\n");
/* write the plies in several lines of up to 80 characters */
for (ply_count=0, ply=game->first_ply;ply->next_node!=NULL;
ply=ply->next_node,ply_count++){
/* write the move number */
if (ply->player == white){
rb->snprintf(buffer,10,"%u.",(ply_count/2)+1);
write_pgn_token(fhandler, buffer, &line_length);
}
/* write the actual move */
write_pgn_token(fhandler,ply->pgn_text,&line_length);
/* write the result of the game at the end */
if (ply->checkmate){
if (ply->player == white){
write_pgn_token(fhandler,"1-0",&line_length);
} else {
write_pgn_token(fhandler,"0-1",&line_length);
}
break;
} else if (ply->draw){
write_pgn_token(fhandler,"1/2-1/2",&line_length);
break;
} else if (ply->next_node->player == neutral) {
/* unknown end of the game */
write_pgn_token(fhandler,"*",&line_length);
break;
}
}
/* leave a blank line between the tag section and the game section */
rb->fdprintf(fhandler,"\n\n");
rb->close(fhandler);
}
Reference in a new issue View git blame Copy permalink