chess

main.c (6168B)

 #include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #define TB_IMPL
 #define TB_OPT_TRUECOLOR
 
 #include <cii/except.h>
 #include <cii/mem.h>
 #include <pane/menu.h>
 #include <pane/pane.h>
 #include <pane/utils.h>
 #include <pane/widgets.h>
 
 #include "anki.h"
 #include "board.h"
 #include "display.h"
 
 /* static char *profile = NULL; */
 
 void set_selectDeck(void);
 void set_selectProfile(void);
 void profile_selected(char *name, int ignore);
 void deck_selected(char *name, int ignore);
 
 void start(void);
 void stop(void);
 
 struct widget_T error_widget = {
     .pane = NULL,
     .callback = widgetCenter_print,
     .title = "Error",
 };
 
 struct menuInfo_T  mainMenuInfo;
 struct menuStyle_T mainMenuStyle = {
     .separator = "<------------->",
     .padding = 2,
     .spacing = 1,
 };
 struct widget_T mainMenu_widget = {
     .pane = NULL,
     .callback = pane_menu,
     .title = "Main Menu",
     .style = &mainMenuStyle,
     .info = &mainMenuInfo,
 };
 
 menu_T anki_to_menu(const char **(*getter)(size_t *), menuItem_select_f select,
                     menu_back_f back) {
   size_t       i, size;
   const char **profiles = getter(&size);
 
   menu_T menu = menu_new(size, back);
   for (i = 0; i < size; i++) {
     menu->items[i].select_f = select;
     menu->items[i].name = profiles[i];
   }
 
   return menu;
 }
 
 struct boardInfo_T  boardInfo;
 struct boardStyle_T boardStyle = {
     .square_dark = TB_GREEN,
     .square_light = TB_WHITE,
     .piece = TB_BLACK,
     .pass = TB_BLUE,
     .fail = TB_RED,
     .border = 0,
     .annotation = 3,
 };
 struct widget_T board_widget = {
     .pane = NULL,
     .callback = board_display,
     .title = "Board",
     .style = &boardStyle,
     .info = &boardInfo,
 };
 
 #define MOVE_PADDING 8
 
 struct movesInfo_T  movesInfo;
 struct movesStyle_T movesStyle = {
     .move_padding = MOVE_PADDING,
     .num_padding = 4,
     .foreground = TB_WHITE,
     .background = 0,
     .active = TB_BLUE,
 };
 struct widget_T moves_widget = {
     .pane = NULL,
     .callback = moves_display,
     .title = "Moves",
     .style = &movesStyle,
     .info = &movesInfo,
 };
 
 void title_callback(widget_T widget) {
   game_T       game = (game_T)widget->data->payload;
   titleInfo_T  info = (titleInfo_T)widget->info;
   titleStyle_T style = (titleStyle_T)widget->style;
 
   data_T data = data_new(card_name(game->card), NULL);
   widget_setData(info->subwidget, data);
   info->subwidget->pane = widget->pane;
   info->subwidget->callback(info->subwidget);
 
   UNUSED(style);
 }
 
 struct widget_T center_widget = {
     .pane = NULL,
     .callback = widgetCenter_print,
     .title = "Title",
 };
 
 struct titleInfo_T titleInfo = {
     .subwidget = &center_widget,
 };
 
 struct titleStyle_T titleStyle;
 
 struct widget_T title_widget = {
     .pane = NULL,
     .callback = title_callback,
     .title = "Title",
     .style = &titleStyle,
     .info = &titleInfo,
 };
 
 void done_review(void) {
   char message[] =
       "You have finished all of the reviews for this deck.  Please "
       "check back later!";
   struct tb_event ev;
   data_T          data = data_new(message, NULL);
   widget_setData(&error_widget, data);
   widget_activate(&error_widget, MAIN);
   error_widget.callback(&error_widget);
   tb_poll_event(&ev);
   if (ev.ch == 'q' || ev.key == TB_KEY_ESC)
     stop();
 }
 
 void review_finished(void) {
 
   pane_unsplit(MAIN);
   pane_clear(MAIN, 0);
 
   done_review();
   set_selectDeck();
   widget_activate(&mainMenu_widget, MAIN);
 }
 
 int review_card(void) {
   char  *fen;
   size_t moves_num, i;
 
   card_T card = anki_current_card();
 
   if (card == NULL) {
     review_finished();
     return 0;
   }
 
   char **moves = Move_list(card_pgn(card), &moves_num);
   game_T game = game_new(moves_num);
 
   int white = 1;
   game->boards[0] = (fen = card_fen(card)) ? Board_from_FEN(fen) : Board_new();
   for (i = 1; i <= moves_num; i++, white = !white)
     game->boards[i] = Board_play(game->boards[i - 1], moves[i], white);
 
   game->card = card;
   game->review_next = review_card;
   game->move_start = game->move_current = game->display_current =
       atoi(card_start(card));
   game->moves = moves;
 
   data_T data = data_new(game, game_handleInput);
   widget_setData(&board_widget, data);
   widget_setData(&moves_widget, data);
   widget_setData(&title_widget, data);
 
   return 1;
 }
 
 void deck_selected(char *name, int ignore) {
   UNUSED(ignore);
   Pane_T *children1, *children2;
 
   anki_load_deck(name);
 
   if (anki_current_card()) {
     pane_clear(MAIN, 1);
     children1 = pane_vsplit(MAIN, 2, -5, 1);
     children2 = pane_split(children1[1], 2, -(MOVE_PADDING * 3 + 4), 2);
 
     review_card();
 
     widget_activate(&title_widget, children1[0]);
     widget_activate(&moves_widget, children2[0]);
     widget_activate(&board_widget, children2[1]);
   } else {
     done_review();
     set_selectDeck();
     widget_activate(&mainMenu_widget, MAIN);
   }
 }
 
 void profile_selected(char *name, int ignore) {
   UNUSED(ignore);
   /* if (!profile) */
   /*   profile = malloc(100 * sizeof(char)); */
   /* strcpy(profile, name); */
   anki_load_profile(name);
   set_selectDeck();
 }
 
 void set_selectProfile() {
   menu_T menu = anki_to_menu(anki_get_profiles, profile_selected, stop);
   data_T data = data_new(menu, menu_hadleInput);
   widget_setData(&mainMenu_widget, data);
 }
 
 void set_selectDeck() {
   menu_T menu = anki_to_menu(anki_get_decks, deck_selected, set_selectProfile);
   data_T data = data_new(menu, menu_hadleInput);
   widget_setData(&mainMenu_widget, data);
 }
 
 int main(void) {
   start();
   {
     set_selectProfile();
     widget_activate(&mainMenu_widget, MAIN);
     pane_event_loop();
   }
   stop();
 
   return 0;
 }
 
 void stop(void) {
   anki_stop();
   pane_stop();
   exit(1);
 }
 
 void start(void) {
   struct tb_event ev;
   char message[] = "Can't start anki, make sure it's running and try again";
 
   pane_start(0);
   data_T data = data_new(message, NULL);
   widget_setData(&error_widget, data);
   widget_activate(&error_widget, MAIN);
 
   TRY { anki_start(); }
   EXCEPT(ANKIE_CONNECT) {
     error_widget.callback(&error_widget);
     tb_poll_event(&ev);
     if (ev.ch == 'q' || ev.key == TB_KEY_ESC)
       stop();
     start();
   }
   ELSE {
     stop();
     RERAISE;
   }
   END_TRY;
 }