juegos

tui.c (14912B)

---

 /* tui.c - interfaz de terminal (ncurses, sobre comun/linux/tuikit).
  *
  * El tablero son celdas de texto con el fondo del tema y las piezas como glifos
  * Unicode rellenos, coloreados por bando (como el ajedrez en bash). El tamano
  * de las casillas se adapta a la terminal. */
 #include "tuikit.h"
 #include <stdlib.h>
 #include <string.h>
 #include "frontend.h"
 
 /* ♙ para los peones de los dos bandos: ♟ (U+265F) muchas terminales lo muestran
  * como emoji y no respetan el color (el ajedrez en bash tenia el mismo problema) */
 static const char *const GLYPH[7] = { " ", "♙", "♞", "♝", "♜", "♛", "♚" };
 
 #define FG_WHITE 231
 #define FG_BLACK 16
 
 static void cat(char *b, int n, const char *s) { size_t l = strlen(b); snprintf(b + l, (size_t)n - l, "%s", s); }
 
 /* casilla (fila/columna de pantalla) de una casilla del tablero */
 static void cell_of(const View *v, int sq, int *col, int *row)
 {
     int f = FILE_OF(sq), r = RANK_OF(sq);
     if (v->c && v->c->flipped) { f = 7 - f; r = 7 - r; }
     *col = f;
     *row = 7 - r;
 }
 
 static void draw_board(Frontend *fe, const View *v, int y0, int x0, int sw, int sh)
 {
     const Theme *th = &THEMES[v->theme % NTHEMES];
     const Game *g = v->g;
     const Ctrl *c = v->c;
     int lf = -1, lt = -1;
     if (g->nply) { lf = MFROM(g->mv[g->nply - 1]); lt = MTO(g->mv[g->nply - 1]); }
     int check_sq = -1;
     if ((g->result == R_NONE && pos_in_check(&g->pos)) || g->reason == RS_MATE) check_sq = g->pos.king[g->pos.side];
     for (int sq = 0; sq < 64; sq++) {
         int col, row;
         cell_of(v, sq, &col, &row);
         int x = x0 + col * sw, y = y0 + row * sh;
         bool light = (FILE_OF(sq) + RANK_OF(sq)) & 1;
         short bg = light ? th->xterm[TH_LIGHT] : th->xterm[TH_DARK];
         if (sq == lf || sq == lt) bg = th->xterm[TH_PATH];
         if (c && sq == c->sel) bg = th->xterm[TH_FROM];
         if (sq == check_sq) bg = th->xterm[TH_CAPTURE];
         bool target = c && ctrl_is_target(c, sq);
         bool cursor = c && sq == c->cursor && g->result == R_NONE;
         for (int j = 0; j < sh; j++) {
             tk_att(0, bg, 0);
             tk_fill(y + j, x, sw, " ");
         }
         int cy = y + sh / 2, cx = x + sw / 2;
         uint8_t pc = g->pos.sq[sq];
         if (pc) {
             tk_att(PCOLOR(pc) == WHITE ? FG_WHITE : FG_BLACK, bg, A_BOLD);
             mvaddstr(cy, cx, GLYPH[PTYPE(pc)]);
         }
         if (target) {
             short tc = pc ? th->xterm[TH_CAPTURE] : th->xterm[TH_TARGET];
             if (pc) {
                 /* captura: el borde de la casilla en el color de captura */
                 tk_att(0, tc, 0);
                 for (int j = 0; j < sh; j++) { mvaddstr(y + j, x, " "); mvaddstr(y + j, x + sw - 1, " "); }
             } else {
                 tk_att(tc, bg, A_BOLD);
                 mvaddstr(cy, cx, "●");
             }
         }
         if (cursor) {
             tk_att(0, tk_xterm(C_CURSOR), A_BOLD);
             if (sw >= 5) {
                 mvaddstr(y, x, "▛"); mvaddstr(y, x + sw - 1, "▜");
                 if (sh >= 2) { mvaddstr(y + sh - 1, x, "▙"); mvaddstr(y + sh - 1, x + sw - 1, "▟"); }
                 tk_att(tk_xterm(C_CURSOR), bg, A_BOLD);
                 mvaddstr(y, x, "▛"); mvaddstr(y, x + sw - 1, "▜");
                 if (sh >= 2) { mvaddstr(y + sh - 1, x, "▙"); mvaddstr(y + sh - 1, x + sw - 1, "▟"); }
             } else {
                 tk_att(tk_xterm(C_CURSOR), bg, A_BOLD);
                 mvaddstr(cy, x, "[");
                 mvaddstr(cy, x + sw - 1, "]");
             }
         }
         hit_add(&fe->hits, x, y, sw, sh, HIT_SQUARE, sq);
     }
     /* coordenadas */
     bool fl = c && c->flipped;
     tk_att(244, TK_DEF, 0);
     for (int i = 0; i < 8; i++) {
         char fc[2] = { (char)('a' + (fl ? 7 - i : i)), 0 }, rc[2] = { (char)('8' - (fl ? 7 - i : i)), 0 };
         mvaddstr(y0 + 8 * sh, x0 + i * sw + sw / 2, fc);
         mvaddstr(y0 + i * sh + sh / 2, x0 - 2, rc);
     }
     /* coronacion: las cuatro piezas en una cajita */
     if (c && c->mode == CM_PROMO) {
         int bw = 4 * 4 + 3, bx = x0 + 4 * sw - bw / 2, by = y0 + 4 * sh - 2;
         tk_box(by, bx, 3, bw, "", C_ACCENT);
         for (int k = 0; k < 4; k++) {
             int px = bx + 2 + k * 4;
             bool on = k == c->promo_cur;
             tk_att(g->pos.side == WHITE ? FG_WHITE : FG_BLACK, on ? tk_xterm(C_ACCENT) : 238, A_BOLD);
             mvaddstr(by + 1, px, " ");
             mvaddstr(by + 1, px + 1, GLYPH[MPROMO(c->promo[k])]);
             mvaddstr(by + 1, px + 2, " ");
             hit_add(&fe->hits, px, by + 1, 3, 1, HIT_PROMO, k);
         }
     }
 }
 
 static void status_text(const View *v, char *buf, int n)
 {
     const Game *g = v->g;
     buf[0] = 0;
     if (g->result == R_DRAW) { cat(buf, n, tr(S_DRAW)); cat(buf, n, " · "); cat(buf, n, reason_text(g->reason)); }
     else if (g->result != R_NONE) {
         cat(buf, n, color_name(g->result == R_WHITE ? WHITE : BLACK));
         cat(buf, n, " ");
         cat(buf, n, tr(S_WINS));
         cat(buf, n, " · ");
         cat(buf, n, reason_text(g->reason));
     } else {
         const char *nm = v->names[g->pos.side] && *v->names[g->pos.side] ? v->names[g->pos.side] : color_name(g->pos.side);
         if (g_lang) { cat(buf, n, nm); cat(buf, n, " to move"); }
         else { cat(buf, n, "Juegan "); cat(buf, n, nm); }
         if (pos_in_check(&g->pos)) { cat(buf, n, " · "); cat(buf, n, tr(S_CHECK)); }
     }
 }
 
 static void player_line(const View *v, int color, int y, int x, int w)
 {
     const Game *g = v->g;
     bool active = g->result == R_NONE && g->pos.side == color;
     tk_att(active ? 255 : 250, active ? 238 : 236, active ? A_BOLD : 0);
     tk_fill(y, x, w, " ");
     tk_att(color == WHITE ? FG_WHITE : FG_BLACK, active ? 238 : 236, A_BOLD);
     mvaddstr(y, x + 1, "♚");
     tk_att(active ? 255 : 250, active ? 238 : 236, active ? A_BOLD : 0);
     const char *nm = v->names[color] && *v->names[color] ? v->names[color] : color_name(color);
     int cw = 0;
     if (v->has_clock) {
         char clk[16];
         fmt_clock(v->clock[color], clk, sizeof clk);
         cw = tk_ulen(clk) + 1;
         if (active && v->clock[color] < 20000) tk_att(tk_xterm(C_ERR), 238, A_BOLD);
         else if (active) tk_att(tk_xterm(C_ACCENT), 238, A_BOLD);
         mvaddstr(y, x + w - cw, clk);
         tk_att(active ? 255 : 250, active ? 238 : 236, active ? A_BOLD : 0);
     }
     tk_put(y, x + 3, nm, w - 4 - cw);
 }
 
 static void captured_line(const View *v, int who, int y, int x, int w)
 {
     int cap[2][7];
     captured_pieces(v->g, cap);
     char buf[128] = "";
     for (int t = QUEEN; t >= PAWN; t--)
         for (int k = 0; k < cap[who][t]; k++) cat(buf, sizeof buf, GLYPH[t]);
     tk_att(who == WHITE ? FG_WHITE : 245, TK_DEF, 0);
     tk_put(y, x + 1, buf, w - 2);
 }
 
 static void draw_panel(const View *v, int y, int x, int w, int h)
 {
     const Game *g = v->g;
     bool fl = v->c && v->c->flipped;
     int top = fl ? WHITE : BLACK, bot = top ^ 1;
     int ybot = y + h - 1;
     player_line(v, top, y, x, w);
     captured_line(v, bot, y + 1, x, w);
     char buf[200];
     int ly = y + 3;
     status_text(v, buf, sizeof buf);
     tk_att(g->result != R_NONE ? tk_xterm(C_ACCENT) : 252, TK_DEF, A_BOLD);
     tk_put(ly++, x + 1, buf, w - 2);
     if (v->status && *v->status) { tk_att(245, TK_DEF, 0); tk_put(ly++, x + 1, v->status, w - 2); }
     if (v->opening) { tk_att(tk_xterm(C_OK), TK_DEF, 0); tk_put(ly++, x + 1, v->opening, w - 2); }
     if (v->show_eval && v->eval_valid) {
         char e[24];
         int ev = v->eval;
         if (MATE_IN(ev)) snprintf(e, sizeof e, "%sM%d", ev > 0 ? "+" : "-", (MATE - abs(ev) + 1) / 2);
         else snprintf(e, sizeof e, "%+.2f", ev / 100.0);
         int bw = w - 10;
         int cp = ev > 800 ? 800 : ev < -800 ? -800 : ev;
         int wx = MATE_IN(ev) ? (ev > 0 ? bw : 0) : bw / 2 + cp * bw / 1600;
         tk_att(250, TK_DEF, 0);
         mvaddstr(ly, x + 1, e);
         for (int i = 0; i < bw; i++) { tk_att(0, i < wx ? 255 : 234, 0); mvaddstr(ly, x + 9 + i, " "); }
         ly++;
     }
     if (v->banner) {
         ly++;
         tk_att(0, tk_xterm(C_ACCENT), A_BOLD);
         tk_fill(ly, x, w, " ");
         tk_put(ly++, x + 1, v->banner, w - 2);
     }
     ly++;
     tk_section(ly++, x, w, tr(S_MOVES));
     /* jugadas: las ultimas que entran */
     int rows = ybot - 2 - ly;
     if (rows < 1) rows = 1;
     int first_side = g->start.side;
     int total = (g->nply + first_side + 1) / 2;
     int first_row = total > rows ? total - rows : 0;
     Pos p = g->start;
     int ply = 0, target = first_row * 2 - first_side;
     if (target < 0) target = 0;
     for (; ply < target; ply++) { Undo u; pos_make(&p, g->mv[ply], &u); }
     for (int r = first_row; r < total && ply < g->nply; r++) {
         char num[12];
         snprintf(num, sizeof num, "%d.", g->start.fullmove + r);
         tk_att(244, TK_DEF, 0);
         mvaddstr(ly, x + 1, num);
         for (int col = 0; col < 2 && ply < g->nply; col++) {
             if (r == 0 && col == 0 && first_side == BLACK) { mvaddstr(ly, x + 6, "..."); continue; }
             char san[16];
             move_san(&p, g->mv[ply], san, sizeof san);
             bool last = ply == g->nply - 1;
             tk_att(last ? tk_xterm(C_ACCENT) : 252, TK_DEF, last ? A_BOLD : 0);
             tk_put(ly, x + 6 + col * 10, san, 9);
             Undo u;
             pos_make(&p, g->mv[ply], &u);
             ply++;
         }
         ly++;
     }
     captured_line(v, top, ybot - 1, x, w);
     player_line(v, bot, ybot, x, w);
 }
 
 static void draw_help(int y, int x, int w)
 {
     const char *t = tr(S_HELP_KEYS);
     char lines[24][96];
     int n = 0;
     while (*t && n < 24) {
         int k = 0;
         while (*t && !(t[0] == ' ' && t[1] == '\xc2')) { if (k < 95) lines[n][k++] = *t; t++; }
         lines[n++][k] = 0;
         if (*t) t += 4;
         while (*t == ' ') t++;
     }
     tk_box(y, x, n + 2, w, g_lang ? "Keys" : "Teclas", C_ACCENT);
     tk_att(252, 236, 0);
     for (int i = 0; i < n; i++) tk_put(y + 1 + i, x + 2, lines[i], w - 4);
 }
 
 static void tui_draw_game(Frontend *f, const View *v)
 {
     f->hits.n = 0;
     tk_clear();
     int H = LINES, W = COLS;
     if (W < 60 || H < 20) {
         tk_att(tk_xterm(C_ERR), TK_DEF, A_BOLD);
         mvaddstr(0, 0, g_lang ? "Make the terminal bigger (60x20 min)" : "Agrandá la terminal (mínimo 60x20)");
         refresh();
         return;
     }
     /* tamano de casilla: el mas grande que deja lugar al panel */
     int sh = (H - 4) / 8;
     if (sh > 2) sh = 2;     /* casillas chicas: la pieza (un solo caracter) tiene que llenar la casilla */
     int sw = sh * 2 + 1;
     while (sh > 1 && 8 * sw + 3 + 28 > W) { sh--; sw = sh * 2 + 1; }
     if (8 * sw + 3 + 28 > W) sw = 3;
     int bx = 3, by = 1;
     tk_att(tk_xterm(C_BLACK), tk_xterm(C_ACCENT), A_BOLD);
     tk_fill(0, 0, W, " ");
     mvaddstr(0, 1, tr(S_TITLE));
     if (v->status && *v->status) { tk_att(tk_xterm(C_BLACK), tk_xterm(C_ACCENT), 0); tk_put(0, 10, v->status, W - 12); }
     draw_board(f, v, by, bx, sw, sh);
     int px = bx + 8 * sw + 2, pw = W - px - 1;
     if (pw > 48) pw = 48;
     draw_panel(v, by, px, pw, 8 * sh + 1);
     /* instruccion y mensajes */
     const Ctrl *c = v->hide_prompt ? 0 : v->c;
     tk_att(tk_xterm(C_ACCENT), TK_DEF, A_BOLD);
     tk_fill(H - 2, 0, W, " ");
     char buf[160] = "";
     if (c && c->mode == CM_ENTRY) snprintf(buf, sizeof buf, "▶ %s %s█", tr(S_P_ENTRY), c->entry);
     else if (c && c->g && c->g->result == R_NONE && !ctrl_my_turn(c)) {
         int side = c->g->pos.side;
         snprintf(buf, sizeof buf, "▶ %s %s", ctrl_prompt(c), v->names[side] && *v->names[side] ? v->names[side] : color_name(side));
     } else if (c) snprintf(buf, sizeof buf, "▶ %s", ctrl_prompt(c));
     tk_put(H - 2, 1, buf, W - 2);
     tk_fill(H - 1, 0, W, " ");
     if (c && c->msg[0]) { tk_att(tk_xterm(c->msg_err ? C_ERR : C_OK), TK_DEF, A_BOLD); tk_put(H - 1, 1, c->msg, W - 2); }
     else if (c) {
         tk_att(244, TK_DEF, 0);
         tk_put(H - 1, 1, g_lang ? "Enter pick · arrows move · Tab next · : type move · m menu · ? help · q quit"
                                 : "Enter elegir · flechas mover · Tab siguiente · : escribir jugada · m menú · ? ayuda · q salir", W - 2);
     }
     if (v->show_help) draw_help(by + 1, bx + 1, 8 * sw > 60 ? 60 : 8 * sw);
     if (v->modal) {
         int w = 8 * sw - 4 > 56 ? 56 : 8 * sw - 4, h = v->modal2 ? 5 : 4;
         int x = bx + (8 * sw - w) / 2, y = by + (8 * sh - h) / 2;
         tk_box(y, x, h, w, "", C_ACCENT);
         tk_att(tk_xterm(C_ACCENT), 236, A_BOLD);
         tk_put(y + 1, x + (w - tk_ulen(v->modal)) / 2, v->modal, w - 4);
         if (v->modal2) { tk_att(250, 236, 0); tk_put(y + 3, x + (w - tk_ulen(v->modal2)) / 2, v->modal2, w - 4); }
     }
     refresh();
 }
 
 static void tui_draw_form(Frontend *f, const Form *form) { tk_draw_form(form, &f->hits); }
 
 /* logo de los menus: una fila de piezas */
 static void form_logo(int cols)
 {
     static const int ROW[] = { ROOK, KNIGHT, BISHOP, QUEEN, KING, BISHOP, KNIGHT, ROOK };
     int lx = cols / 2 - 12;
     for (int i = 0; i < 8; i++) {
         tk_att(i & 1 ? FG_BLACK : FG_WHITE, (i & 1) ? THEMES[0].xterm[TH_LIGHT] : THEMES[0].xterm[TH_DARK], A_BOLD);
         mvaddstr(1, lx + i * 3, " ");
         mvaddstr(1, lx + i * 3 + 1, GLYPH[ROW[i]]);
         mvaddstr(1, lx + i * 3 + 2, " ");
     }
 }
 
 static int tui_wait(Frontend *f, int timeout_ms, const int *fds, int nfds, InEvent *ev)
 {
     (void)f;
     return tk_wait(timeout_ms, fds, nfds, ev);
 }
 
 /* Para pegar texto largo se suelta la pantalla un momento y se lee la entrada
  * comun hasta Ctrl-D, como en el ajedrez en bash. */
 static char *tui_paste(Frontend *f)
 {
     (void)f;
     def_prog_mode();
     endwin();
     printf("\n%s\n\n", g_lang ? "Paste the game (PGN) or a position (FEN), then press Ctrl-D on an empty line:"
                               : "Pegá la partida (PGN) o una posición (FEN) y después Ctrl-D en una línea vacía:");
     fflush(stdout);
     size_t cap = 4096, n = 0;
     char *buf = malloc(cap), line[1024];
     while (buf && fgets(line, sizeof line, stdin)) {
         size_t l = strlen(line);
         if (n + l + 1 > cap) {
             if (cap > (4u << 20)) break;
             char *nb = realloc(buf, cap * 2);
             if (!nb) break;
             buf = nb;
             cap *= 2;
         }
         memcpy(buf + n, line, l);
         n += l;
     }
     if (buf) buf[n] = 0;
     clearerr(stdin);
     reset_prog_mode();
     flushinp();
     refresh();
     if (buf && !n) { free(buf); buf = 0; }
     return buf;
 }
 
 static void tui_close(Frontend *f)
 {
     (void)f;
     tk_close();
 }
 
 Frontend *tui_open(void)
 {
     static Frontend fe;
     tk_open();
     tk_form_logo = form_logo;
     memset(&fe, 0, sizeof fe);
     fe.draw_game = tui_draw_game;
     fe.draw_form = tui_draw_form;
     fe.wait = tui_wait;
     fe.close = tui_close;
     fe.paste = tui_paste;
     return &fe;
 }