juegos

app.c (21085B)

---

 /* app.c - Palabra: el Wordle en castellano para la PicoCalc.
  *
  * Adivinar una palabra de 5 letras en 6 intentos. Letras del teclado, ';' = Ñ,
  * Retroceso borra, Enter prueba, Esc pausa. Las tildes no cuentan (se muestran al
  * final). En modo difícil las pistas reveladas se tienen que usar.
  * La partida en curso se guarda despues de cada intento ("Continuar"). */
 #include <string.h>
 #include "mini.h"
 #include "palabras.h"
 
 /* 1: muestra la solucion en la barra y la fija en PALABRA_WORD (para probar). */
 #ifndef PALABRA_DEBUG
 #define PALABRA_DEBUG 0
 #endif
 #ifndef PALABRA_WORD
 #define PALABRA_WORD "perro"
 #endif
 
 enum { ROWS = 6, LEN = 5, NLET = 27, ENE = 26 };
 enum { PLAYING, WON, LOST };
 enum { UNK, ABSENT, PRESENT, CORRECT };             /* estado de letra / casilla */
 
 /* tablero y teclado en pantalla */
 enum { CELL = 30, GAP = 3, GX = (320 - (LEN * CELL + (LEN - 1) * GAP)) / 2, GY = 30,
        KW = 28, KH = 19, KGAP = 3, KY = 243 };
 enum { STEP_MS = 180, SHAKE_MS = 40, MSG_MS = 1800 };
 
 typedef struct {
     int sol;                      /* indice en SOLUCIONES */
     uint8_t ans[LEN];
     bool hard;
     uint8_t guess[ROWS][LEN], res[ROWS][LEN];
     int rows;                     /* intentos hechos */
     uint8_t cur[LEN];
     int ncur;
     uint8_t keys[NLET];           /* mejor estado conocido de cada letra */
     int state;
     char msg[48];
     uint32_t msg_t, shake_t, reveal_t;
     bool shaking, revealing;
     bool card;                    /* cartel de fin a la vista (Tab lo esconde) */
 } Game;
 
 static Game G;
 
 /* ------------------------------------------------------------ palabras */
 
 static void unpack(uint32_t w, uint8_t *l)
 {
     for (int i = LEN - 1; i >= 0; i--) { l[i] = (uint8_t)(w & 31); w >>= 5; }
 }
 
 static uint32_t pack(const uint8_t *l)
 {
     uint32_t w = 0;
     for (int i = 0; i < LEN; i++) w = w << 5 | l[i];
     return w;
 }
 
 static bool is_valid(const uint8_t *l)
 {
     uint32_t w = pack(l);
     int lo = 0, hi = NVALIDAS - 1;
     while (lo <= hi) {
         int m = (lo + hi) / 2;
         if (VALIDAS[m] == w) return true;
         if (VALIDAS[m] < w) lo = m + 1; else hi = m - 1;
     }
     return false;
 }
 
 /* Letra en UTF-8 (mayuscula). */
 static int put_letter(char *b, int n, int p, int l)
 {
     char t[3];
     if (l == ENE) { t[0] = (char)0xC3; t[1] = (char)0x91; t[2] = 0; }
     else { t[0] = (char)('A' + l); t[1] = 0; }
     return str_put(b, n, p, t);
 }
 
 /* La solucion con su tilde, en mayusculas. */
 static int put_solution(char *b, int n, int p)
 {
     uint32_t w = SOLUCIONES[G.sol];
     int acc = (int)(w >> 25 & 7), dier = (int)(w >> 28 & 1);
     for (int i = 0; i < LEN; i++) {
         int l = G.ans[i];
         if (acc == i + 1 && l < 26) {
             static const char V[] = "AEIOU";
             static const uint8_t TILDE[] = { 0xC1, 0xC9, 0xCD, 0xD3, 0xDA };   /* Latin-1 */
             const char *v = strchr(V, 'A' + l);
             if (v) {
                 int c = dier ? 0xDC : TILDE[v - V];                          /* Ü */
                 char t[3] = { (char)0xC3, (char)(c - 0x40), 0 };
                 p = str_put(b, n, p, t);
                 continue;
             }
         }
         p = put_letter(b, n, p, l);
     }
     return p;
 }
 
 /* Colores con la regla de las letras repetidas: primero las exactas, despues las
  * que estan en otro lado mientras queden sin usar en la solucion. */
 static void score(const uint8_t *g, uint8_t *r)
 {
     int left[NLET] = { 0 };
     for (int i = 0; i < LEN; i++) {
         if (g[i] == G.ans[i]) r[i] = CORRECT;
         else { r[i] = ABSENT; left[G.ans[i]]++; }
     }
     for (int i = 0; i < LEN; i++)
         if (r[i] != CORRECT && left[g[i]] > 0) { r[i] = PRESENT; left[g[i]]--; }
 }
 
 /* Modo dificil: los verdes en su lugar y las letras reveladas, al menos tantas veces. */
 static bool hard_ok(const uint8_t *g, char *why, int n)
 {
     for (int r = 0; r < G.rows; r++) {
         for (int i = 0; i < LEN; i++)
             if (G.res[r][i] == CORRECT && g[i] != G.guess[r][i]) {
                 int p = str_put(why, n, 0, "La ");
                 p = str_int(why, n, p, i + 1);
                 p = str_put(why, n, p, "ª letra tiene que ser ");
                 put_letter(why, n, p, G.guess[r][i]);
                 return false;
             }
         for (int i = 0; i < LEN; i++) {
             if (G.res[r][i] != PRESENT) continue;
             int l = G.guess[r][i], need = 0, have = 0;
             for (int j = 0; j < LEN; j++) {
                 if (G.guess[r][j] == l && G.res[r][j] != ABSENT) need++;
                 if (g[j] == l) have++;
             }
             if (have < need) {
                 int p = str_put(why, n, 0, "Tiene que tener la ");
                 put_letter(why, n, p, l);
                 return false;
             }
         }
     }
     return true;
 }
 
 static void update_keys(int r)
 {
     for (int i = 0; i < LEN; i++) {
         int l = G.guess[r][i];
         if (G.res[r][i] > G.keys[l]) G.keys[l] = G.res[r][i];
     }
 }
 
 /* ------------------------------------------------------------ partida y guardado */
 
 static void new_game(bool hard)
 {
     memset(&G, 0, sizeof G);
     G.hard = hard;
     G.sol = mini_rand(NSOLUCIONES);
 #if PALABRA_DEBUG
     uint8_t dw[LEN];
     for (int i = 0; i < LEN; i++) dw[i] = (uint8_t)(PALABRA_WORD[i] - 'a');
     for (int i = 0; i < NSOLUCIONES; i++)
         if ((SOLUCIONES[i] & PAL_MASK) == pack(dw)) G.sol = i;
 #endif
     unpack(SOLUCIONES[G.sol] & PAL_MASK, G.ans);
 }
 
 /* "p": modo (0/1), indice de la solucion, '.', los intentos (a..z, Ñ = '_'). */
 static void save_progress(void)
 {
     char b[64];
     int p = str_put(b, sizeof b, 0, G.hard ? "1" : "0");
     p = str_int(b, sizeof b, p, G.sol);
     p = str_put(b, sizeof b, p, ".");
     for (int r = 0; r < G.rows; r++)
         for (int i = 0; i < LEN; i++) {
             char t[2] = { G.guess[r][i] == ENE ? '_' : (char)('a' + G.guess[r][i]), 0 };
             p = str_put(b, sizeof b, p, t);
         }
     mini_set_str("p", b);
     mini_save();
 }
 
 static bool has_progress(void)
 {
     const char *s = mini_get_str("p");
     return s && s[0];
 }
 
 static bool load_progress(void)
 {
     const char *s = mini_get_str("p");
     if (!s || (s[0] != '0' && s[0] != '1')) return false;
     long idx = 0;
     int i = 1;
     while (s[i] >= '0' && s[i] <= '9') idx = idx * 10 + (s[i++] - '0');
     if (s[i] != '.' || idx >= NSOLUCIONES) return false;
     memset(&G, 0, sizeof G);
     G.hard = s[0] == '1';
     G.sol = (int)idx;
     unpack(SOLUCIONES[G.sol] & PAL_MASK, G.ans);
     const char *g = s + i + 1;
     while (G.rows < ROWS - 1 && strlen(g) >= LEN) {
         for (int k = 0; k < LEN; k++) {
             if (g[k] == '_') G.guess[G.rows][k] = ENE;
             else if (g[k] >= 'a' && g[k] <= 'z') G.guess[G.rows][k] = (uint8_t)(g[k] - 'a');
             else return false;
         }
         score(G.guess[G.rows], G.res[G.rows]);
         update_keys(G.rows);
         G.rows++;
         g += LEN;
     }
     return true;
 }
 
 static void add_stat(const char *k, long d) { mini_set(k, mini_get(k, 0) + d); }
 
 static void record(bool won)
 {
     add_stat("jug", 1);
     if (won) {
         add_stat("gan", 1);
         add_stat("rac", 1);
         if (mini_get("rac", 0) > mini_get("max", 0)) mini_set("max", mini_get("rac", 0));
         char k[4] = { 'd', (char)('0' + G.rows), 0 };
         add_stat(k, 1);
     } else mini_set("rac", 0);
     mini_set_str("p", "");
     mini_save();
 }
 
 /* Dejar una partida empezada cuenta como perdida (si no, se podria sortear la palabra). */
 static void abandon(void)
 {
     if (has_progress()) {
         const char *s = mini_get_str("p");
         const char *dot = strchr(s, '.');
         if (dot && dot[1]) record(false);
         else { mini_set_str("p", ""); mini_save(); }
     }
 }
 
 static void set_msg(const char *m)
 {
     str_put(G.msg, sizeof G.msg, 0, m);
     G.msg_t = hal_ms();
 }
 
 static void submit(void)
 {
     if (G.ncur < LEN) { set_msg("Faltan letras"); G.shaking = true; G.shake_t = hal_ms(); return; }
     if (!is_valid(G.cur)) { set_msg("No está en la lista"); G.shaking = true; G.shake_t = hal_ms(); return; }
     char why[48];
     if (G.hard && !hard_ok(G.cur, why, sizeof why)) { set_msg(why); G.shaking = true; G.shake_t = hal_ms(); return; }
     memcpy(G.guess[G.rows], G.cur, LEN);
     score(G.cur, G.res[G.rows]);
     G.rows++;
     G.ncur = 0;
     G.msg[0] = 0;
     G.revealing = true;
     G.reveal_t = hal_ms();
     bool won = !memcmp(G.guess[G.rows - 1], G.ans, LEN);
     if (won || G.rows == ROWS) {
         G.state = won ? WON : LOST;
         G.card = true;
         record(won);
     } else save_progress();
 }
 
 /* Termina la animacion de revelado (el teclado se actualiza recien ahi). */
 static void finish_reveal(void)
 {
     if (!G.revealing) return;
     G.revealing = false;
     update_keys(G.rows - 1);
 }
 
 static void type_letter(int l)
 {
     if (G.ncur < LEN) G.cur[G.ncur++] = (uint8_t)l;
 }
 
 /* ------------------------------------------------------------ dibujo */
 
 #define BG       RGB(16, 20, 30)
 #define C_GREEN  RGB(70, 150, 70)
 #define C_YELLOW RGB(196, 164, 48)
 #define C_GRAY   RGB(62, 66, 76)
 #define C_EMPTY  RGB(50, 56, 72)
 #define C_TYPED  RGB(130, 140, 162)
 #define C_KEY    RGB(104, 114, 136)
 
 static Color tile_color(int st)
 {
     return st == CORRECT ? C_GREEN : st == PRESENT ? C_YELLOW : C_GRAY;
 }
 
 static void draw_tile(Surface *s, int x, int y, int l, int st, bool typed)
 {
     char t[4];
     if (st == UNK) {
         gfx_rect(s, x, y, CELL, CELL, BG);
         gfx_frame(s, x, y, CELL, CELL, typed ? C_TYPED : C_EMPTY);
         gfx_frame(s, x + 1, y + 1, CELL - 2, CELL - 2, typed ? C_TYPED : C_EMPTY);
     } else gfx_rect(s, x, y, CELL, CELL, tile_color(st));
     if (l < 0) return;
     put_letter(t, sizeof t, 0, l);
     mini_big_text(s, &font_bold, x + (CELL - 12) / 2, y + 3, 2, t, C_WHITE);
 }
 
 /* Cuantas casillas de la ultima fila ya se revelaron. */
 static int revealed(void)
 {
     if (!G.revealing) return LEN;
     int n = (int)((hal_ms() - G.reveal_t) / STEP_MS);
     return n > LEN ? LEN : n;
 }
 
 static int shake_dx(void)
 {
     static const int8_t D[] = { -6, 6, -5, 5, -3, 3, -1, 0 };
     if (!G.shaking) return 0;
     uint32_t i = (hal_ms() - G.shake_t) / SHAKE_MS;
     return i < sizeof D ? D[i] : 0;
 }
 
 static void draw_board(Surface *s)
 {
     int rv = revealed();
     for (int r = 0; r < ROWS; r++) {
         int y = GY + r * (CELL + GAP), dx = r == G.rows && G.state == PLAYING ? shake_dx() : 0;
         for (int i = 0; i < LEN; i++) {
             int x = GX + dx + i * (CELL + GAP);
             if (r < G.rows) {
                 bool shown = r < G.rows - 1 || i < rv;
                 draw_tile(s, x, y, G.guess[r][i], shown ? G.res[r][i] : UNK, true);
             } else if (r == G.rows && G.state == PLAYING)
                 draw_tile(s, x, y, i < G.ncur ? G.cur[i] : -1, UNK, i < G.ncur);
             else draw_tile(s, x, y, -1, UNK, false);
         }
     }
 }
 
 static void draw_key(Surface *s, int x, int y, int w, const char *t, Color bg)
 {
     gfx_rect(s, x, y, w, KH, bg);
     gfx_text_center(s, &font_bold, x, y + 3, w, t, C_WHITE);
 }
 
 static const char *const KROWS[3] = { "QWERTYUIOP", "ASDFGHJKL;", "ZXCVBNM" };
 
 static void draw_keyboard(Surface *s)
 {
     for (int r = 0; r < 3; r++) {
         const char *k = KROWS[r];
         int n = (int)strlen(k), side = r == 2 ? 44 : 0;
         int w = n * KW + (n - 1) * KGAP + (side ? 2 * (side + KGAP) : 0);
         int x = (320 - w) / 2, y = KY + r * (KH + KGAP);
         if (side) {
             draw_key(s, x, y, side, "", C_KEY);
             gfx_text_center(s, &font_small, x, y + 6, side, "ENTER", C_WHITE);
             x += side + KGAP;
         }
         for (int i = 0; i < n; i++, x += KW + KGAP) {
             int l = k[i] == ';' ? ENE : k[i] - 'A';
             char t[3];
             put_letter(t, sizeof t, 0, l);
             Color bg = G.keys[l] == UNK ? C_KEY : G.keys[l] == ABSENT ? RGB(36, 40, 50) : tile_color(G.keys[l]);
             draw_key(s, x, y, KW, t, bg);
             if (G.keys[l] == ABSENT) gfx_text_center(s, &font_bold, x, y + 3, KW, t, RGB(90, 96, 110));
         }
         if (side) {                               /* borrar: una flecha */
             draw_key(s, x, y, side, "", C_KEY);
             int cx = x + side / 2, cy = y + KH / 2;
             int32_t xs[3] = { (cx - 10) * 16, (cx - 3) * 16, (cx - 3) * 16 };
             int32_t ys[3] = { cy * 16, (cy - 6) * 16, (cy + 6) * 16 };
             gfx_poly16(s, xs, ys, 3, C_WHITE);
             gfx_rect(s, cx - 3, cy - 2, 12, 5, C_WHITE);
         }
     }
 }
 
 static void stat_col(Surface *s, int x, int y, long v, const char *label)
 {
     char b[12];
     str_int(b, sizeof b, 0, v);
     int w = mini_big_w(&font_bold, 2, b);
     mini_big_text(s, &font_bold, x + (60 - w) / 2, y, 2, b, C_TEXT);
     gfx_text_center(s, &font_small, x, y + 28, 60, label, C_DIM);
 }
 
 static void draw_card(Surface *s)
 {
     int bx = 30, by = 34, w = 260, h = 232;
     Color edge = G.state == WON ? C_OK : C_ERR;
     char b[48];
     gfx_box(s, bx, by, w, h, C_PANEL, edge);
     gfx_box(s, bx + 1, by + 1, w - 2, h - 2, C_PANEL, edge);
     const char *title = G.state == WON ? "¡Ganaste!" : "Perdiste";
     mini_big_text(s, &font_bold, bx + (w - mini_big_w(&font_bold, 2, title)) / 2, by + 8, 2, title, edge);
     int p = str_put(b, sizeof b, 0, "La palabra era ");
     put_solution(b, sizeof b, p);
     gfx_text_center(s, &font_normal, bx, by + 38, w, b, C_TEXT);
 
     long jug = mini_get("jug", 0), gan = mini_get("gan", 0);
     int y = by + 58;
     stat_col(s, bx + 10, y, jug, "Jugadas");
     stat_col(s, bx + 70, y, jug ? (gan * 100 + jug / 2) / jug : 0, "% ganadas");
     stat_col(s, bx + 130, y, mini_get("rac", 0), "Racha");
     stat_col(s, bx + 190, y, mini_get("max", 0), "Máxima");
 
     y += 44;
     gfx_text_center(s, &font_bold, bx, y, w, "Intentos", C_ACCENT);
     y += 17;
     long d[ROWS], dmax = 1;
     for (int i = 0; i < ROWS; i++) {
         char k[4] = { 'd', (char)('1' + i), 0 };
         d[i] = mini_get(k, 0);
         if (d[i] > dmax) dmax = d[i];
     }
     for (int i = 0; i < ROWS; i++, y += 15) {
         char n[2] = { (char)('1' + i), 0 };
         gfx_text(s, &font_bold, bx + 16, y, n, C_TEXT);
         str_int(b, sizeof b, 0, d[i]);
         int tw = gfx_text_w(&font_bold, b), full = w - 44;
         int bw = (int)(d[i] * full / dmax);
         if (bw < tw + 8) bw = tw + 8;
         bool mine = G.state == WON && G.rows == i + 1;
         gfx_rect(s, bx + 28, y - 1, bw, 13, mine ? C_GREEN : C_GRAY);
         gfx_text(s, &font_bold, bx + 28 + bw - tw - 4, y, b, C_WHITE);
     }
     gfx_text_center(s, &font_small, bx, by + h - 14, w, "Enter otra   Tab tablero   Esc menú", C_DIM);
 }
 
 static void paint(Surface *s, void *ctx)
 {
     char b[40];
     gfx_rect(s, 0, 0, 320, 320, BG);
     gfx_rect(s, 0, 0, 320, 24, C_PANEL);
     int p = str_put(b, sizeof b, 0, "Intento ");
     p = str_int(b, sizeof b, p, G.rows + (G.state == PLAYING ? 1 : 0));
     str_put(b, sizeof b, p, "/6");
     gfx_text(s, &font_bold, 6, 6, b, C_TEXT);
     gfx_text_center(s, &font_normal, 100, 6, 120, G.hard ? "Difícil" : "Normal", C_ACCENT);
 #if PALABRA_DEBUG
     put_solution(b, sizeof b, 0);
 #else
     p = str_put(b, sizeof b, 0, "Racha ");
     str_int(b, sizeof b, p, mini_get("rac", 0));
 #endif
     gfx_text(s, &font_bold, 314 - gfx_text_w(&font_bold, b), 6, b, C_TEXT);
 
     draw_board(s);
     draw_keyboard(s);
     if (G.msg[0] && hal_ms() - G.msg_t < MSG_MS) {
         int w = gfx_text_w(&font_bold, G.msg) + 16;
         gfx_box(s, (320 - w) / 2, 226, w, 16, C_TEXT, C_TEXT);
         gfx_text_center(s, &font_bold, 0, 228, 320, G.msg, BG);
     }
     if (G.state != PLAYING && !G.revealing && G.card) draw_card(s);
     else if (G.state != PLAYING && !G.revealing)
         gfx_text_center(s, &font_small, 0, 311, 320, "Enter otra   Tab estadísticas   Esc menú", C_DIM);
     else gfx_text_center(s, &font_small, 0, 311, 320, "Enter probar   Retroceso borrar   ; = Ñ   Esc menú", C_DIM);
 }
 
 /* ------------------------------------------------------------ menus y bucle */
 
 static void art(Surface *s)
 {
     /* PALABRA en fichas de colores */
     static const char W[] = "PALABRA";
     static const uint8_t ST[] = { CORRECT, ABSENT, PRESENT, ABSENT, CORRECT, PRESENT, CORRECT };
     int c = 22, g = 3, x0 = (320 - 7 * c - 6 * g) / 2, y = 58;
     for (int i = 0; i < 7; i++) {
         int x = x0 + i * (c + g);
         char t[2] = { W[i], 0 };
         gfx_rect(s, x, y, c, c, tile_color(ST[i]));
         gfx_text_center(s, &font_bold, x, y + 5, c, t, C_WHITE);
     }
 }
 
 static const char *const MODES[] = { "Normal", "Difícil" };
 
 static void how_to(void)
 {
     Form f;
     form_begin(&f, "Cómo se juega");
     form_label(&f, "Adiviná la palabra de 5 letras en 6 intentos.");
     form_label(&f, "Verde: la letra está en ese lugar.");
     form_label(&f, "Amarillo: está en la palabra, en otro lugar.");
     form_label(&f, "Gris: no está (o no tantas veces).");
     form_label(&f, "Las tildes no cuentan. ; = Ñ");
     form_label(&f, "Difícil: las pistas se tienen que usar.");
     form_button(&f, 1, "OK");
     f.cur = f.n - 1;
     mini_form(&f);
 }
 
 /* 1 jugar nueva, 2 continuar */
 static int main_menu(bool *hard)
 {
     static char l1[64], l2[64];
     for (;;) {
         bool cont = has_progress();
         Form f;
         form_begin(&f, "Palabra");
         if (cont) form_button(&f, 2, "Continuar");
         form_button(&f, 1, "Palabra al azar");
         form_choice(&f, 3, "Modo", MODES, 2, *hard ? 1 : 0);
         form_button(&f, 4, "Cómo se juega");
         form_label(&f, "");
         long jug = mini_get("jug", 0), gan = mini_get("gan", 0);
         int p = str_put(l1, sizeof l1, 0, "Jugadas ");
         p = str_int(l1, sizeof l1, p, jug);
         p = str_put(l1, sizeof l1, p, ", ganadas ");
         p = str_int(l1, sizeof l1, p, jug ? (gan * 100 + jug / 2) / jug : 0);
         str_put(l1, sizeof l1, p, "%");
         p = str_put(l2, sizeof l2, 0, "Racha ");
         p = str_int(l2, sizeof l2, p, mini_get("rac", 0));
         p = str_put(l2, sizeof l2, p, ", máxima ");
         str_int(l2, sizeof l2, p, mini_get("max", 0));
         form_label(&f, l1);
         form_label(&f, l2);
         int r = mini_form(&f);
         bool h = form_get(&f, 3)->value == 1;
         if (h != *hard) { *hard = h; mini_set("modo", h); mini_save(); }
         if (r == 4) how_to();
         else if (r == 1 || r == 2) return r;
     }
 }
 
 /* Devuelve true si hay que volver al menu principal. */
 static bool pause_menu(void)
 {
     Form f;
     form_begin(&f, "Pausa");
     form_button(&f, 1, "Seguir");
     form_button(&f, 2, "Empezar de nuevo");
     form_button(&f, 3, "Menú principal");
     form_label(&f, "");
     form_label(&f, "La partida queda guardada.");
     form_label(&f, "Empezar de nuevo cuenta como perdida.");
     int r = mini_form(&f);
     if (r == 2) {
         if (G.rows) record(false);
         new_game(G.hard);
     }
     return r == 3;
 }
 
 static int to_letter(int k)
 {
     if (k >= 'a' && k <= 'z') return k - 'a';
     if (k >= 'A' && k <= 'Z') return k - 'A';
     if (k == ';' || k == 0xF1 || k == 0xD1) return ENE;       /* ñ Ñ en Latin-1 */
     return -1;
 }
 
 void app_main(void)
 {
     mini_start("Palabra", RGB(110, 200, 110));
     mini_art = art;
     bool hard = mini_get("modo", 0) == 1;
     for (;;) {
         int m = main_menu(&hard);
         if (m == 2 && load_progress()) {
             hard = G.hard;
         } else {
             abandon();
             new_game(hard);
         }
         bool dirty = true;
         int shown_rv = -1, shown_dx = 0;
         bool shown_msg = false;
         for (;;) {
             int k = hal_key();
             if (k == 0) dirty = true;
             else if (k > 0) {
                 dirty = true;
                 if (G.revealing) finish_reveal();
                 if (G.state != PLAYING) {
                     if (k == K_OK || k == ' ') { new_game(G.hard); }
                     else if (k == K_TAB) G.card = !G.card;
                     else if (k == K_BACK) break;
                     continue;
                 }
                 int l = to_letter(k);
                 if (l >= 0) type_letter(l);
                 else if (k == K_BKSP || k == K_LEFT) { if (G.ncur) G.ncur--; }
                 else if (k == K_OK) submit();
                 else if (k == K_BACK && pause_menu()) break;
             }
             /* animaciones: revelado, sacudon y mensaje */
             if (G.revealing) {
                 int rv = revealed();
                 if (rv != shown_rv) { shown_rv = rv; dirty = true; }
                 if (hal_ms() - G.reveal_t >= (uint32_t)(LEN * STEP_MS + 100)) { finish_reveal(); dirty = true; }
             }
             if (G.shaking) {
                 int dx = shake_dx();
                 if (dx != shown_dx) { shown_dx = dx; dirty = true; }
                 if (hal_ms() - G.shake_t > 8 * SHAKE_MS) G.shaking = false;
             }
             bool msg = G.msg[0] && hal_ms() - G.msg_t < MSG_MS;
             if (msg != shown_msg) { shown_msg = msg; dirty = true; }
             if (dirty) { hal_draw(paint, 0); dirty = false; }
             else hal_sleep(10);
         }
     }
 }