juegos

app.c (17185B)

---

 /* app.c - sudoku para la PicoCalc.
  *
  * Flechas mueven el cursor, 1-9 ponen un numero (o una nota en modo notas, N),
  * 0/espacio/Retroceso borran, P da una pista, U deshace, Esc pausa.
  * Los sudokus se generan en el aparato (gen.c) con solucion unica. La partida en
  * curso se guarda en la SD despues de cada jugada. */
 #include <string.h>
 #include "mini.h"
 #include "gen.h"
 
 enum { CELL = 30, OX = 18, OY = 25, GRID = 284, UNDO_MAX = 400 };
 
 static const char *const LEVEL_NAMES[] = { "Fácil", "Medio", "Difícil", "Experto" };
 static const char *const YESNO[] = { "No", "Sí" };
 enum { NLEVELS = 4 };
 
 enum { PLAYING, WON };
 
 /* Una jugada para deshacer: la celda, lo que tenia y las notas del digito
  * puesto que se borraron en sus 20 vecinas. */
 typedef struct { uint8_t cell, old; uint16_t notes; uint32_t peers; } Undo;
 
 typedef struct {
     int lvl;
     uint8_t given[81], sol[81], val[81];
     uint8_t fixed[81];            /* 1 pista original, 2 llenada con P */
     uint16_t notes[81];
     int cx, cy;
     bool notes_mode, mark;
     int state, errors, hints;
     uint32_t t0, elapsed;
     bool record;
     Undo undo[UNDO_MAX];
     int nundo;
 } Game;
 
 static Game G;
 
 /* ------------------------------------------------------------ guardado de la partida */
 
 /* sg: pistas (81 digitos), sv: valores (1-9 del jugador, a-i llenados con P),
  * sn: notas, 9 bits por celda de a 6 bits por caracter ('0'+x), si: nivel,
  * tiempo, errores, pistas usadas. */
 static void save_game(void)
 {
     static char b[140];
     for (int i = 0; i < 81; i++) b[i] = (char)('0' + G.given[i]);
     b[81] = 0;
     mini_set_str("sg", b);
     for (int i = 0; i < 81; i++)
         b[i] = G.fixed[i] == 2 ? (char)('a' + G.val[i] - 1) : (char)('0' + (G.fixed[i] ? 0 : G.val[i]));
     mini_set_str("sv", b);
     uint32_t acc = 0;
     int bits = 0, n = 0;
     for (int i = 0; i < 81; i++) {
         acc |= (uint32_t)G.notes[i] << bits;
         bits += 9;
         while (bits >= 6) { b[n++] = (char)('0' + (acc & 63)); acc >>= 6; bits -= 6; }
     }
     if (bits) b[n++] = (char)('0' + (acc & 63));
     b[n] = 0;
     mini_set_str("sn", b);
     mini_set("sl", G.lvl);
     mini_set("st", (long)(hal_ms() - G.t0));
     mini_set("se", G.errors);
     mini_set("sh", G.hints);
     mini_save();
 }
 
 static void clear_saved(void)
 {
     mini_set_str("sg", "-");
     mini_save();
 }
 
 static bool has_saved(void)
 {
     const char *s = mini_get_str("sg");
     return s && strlen(s) == 81;
 }
 
 static bool load_game(void)
 {
     const char *s = mini_get_str("sg");
     if (!s || strlen(s) != 81) return false;
     memset(&G, 0, sizeof G);
     for (int i = 0; i < 81; i++) {
         if (s[i] < '0' || s[i] > '9') return false;
         G.given[i] = (uint8_t)(s[i] - '0');
         G.val[i] = G.given[i];
         G.fixed[i] = G.given[i] ? 1 : 0;
     }
     if (su_count(G.given, 2, G.sol, 0, 1000000) != 1) return false;
     s = mini_get_str("sv");
     if (s && strlen(s) == 81)
         for (int i = 0; i < 81; i++) {
             if (G.fixed[i]) continue;
             if (s[i] >= 'a' && s[i] <= 'i') { G.val[i] = (uint8_t)(s[i] - 'a' + 1); G.fixed[i] = 2; }
             else if (s[i] >= '1' && s[i] <= '9') G.val[i] = (uint8_t)(s[i] - '0');
         }
     s = mini_get_str("sn");
     if (s) {
         uint32_t acc = 0;
         int bits = 0, i = 0;
         for (; *s && i < 81; s++) {
             acc |= (uint32_t)((*s - '0') & 63) << bits;
             bits += 6;
             if (bits >= 9) { G.notes[i++] = (uint16_t)(acc & 0x1FF); acc >>= 9; bits -= 9; }
         }
     }
     G.lvl = (int)mini_get("sl", 0);
     if (G.lvl < 0 || G.lvl >= NLEVELS) G.lvl = 0;
     G.t0 = hal_ms() - (uint32_t)mini_get("st", 0);
     G.errors = (int)mini_get("se", 0);
     G.hints = (int)mini_get("sh", 0);
     G.cx = G.cy = 4;
     return true;
 }
 
 /* ------------------------------------------------------------ reglas */
 
 static void paint_wait(Surface *s, void *ctx)
 {
     gfx_rect(s, 0, 0, 320, 320, RGB(16, 20, 30));
     gfx_box(s, 80, 140, 160, 40, C_PANEL, C_ACCENT);
     gfx_text_center(s, &font_bold, 80, 154, 160, "Generando...", C_TEXT);
 }
 
 static void new_game(int lvl)
 {
     bool mark = G.mark;
     hal_draw(paint_wait, 0);
     memset(&G, 0, sizeof G);
     G.mark = mark;
     G.lvl = lvl;
     su_generate(lvl, G.given, G.sol);
     for (int i = 0; i < 81; i++) { G.val[i] = G.given[i]; G.fixed[i] = G.given[i] ? 1 : 0; }
     G.cx = G.cy = 4;
     G.t0 = hal_ms();
     save_game();
 }
 
 static uint32_t elapsed(void) { return G.state == PLAYING ? hal_ms() - G.t0 : G.elapsed; }
 
 static void level_key(char *k, int n, const char *pre, int lvl)
 {
     int p = str_put(k, n, 0, pre);
     str_int(k, n, p, lvl);
 }
 
 static void check_win(void)
 {
     for (int i = 0; i < 81; i++) if (G.val[i] != G.sol[i]) return;
     G.state = WON;
     G.elapsed = hal_ms() - G.t0;
     char k[8];
     level_key(k, sizeof k, "res", G.lvl);
     mini_set(k, mini_get(k, 0) + 1);
     if (!G.hints) {                             /* el record vale sin pistas */
         level_key(k, sizeof k, "rec", G.lvl);
         long best = mini_get(k, 0);
         if (!best || (long)G.elapsed < best) { mini_set(k, (long)G.elapsed); G.record = true; }
     }
     clear_saved();
 }
 
 static void push_undo(int c, uint32_t peers)
 {
     if (G.nundo == UNDO_MAX) {                  /* se olvida la mas vieja */
         memmove(G.undo, G.undo + 1, sizeof G.undo[0] * (UNDO_MAX - 1));
         G.nundo--;
     }
     Undo *u = &G.undo[G.nundo++];
     u->cell = (uint8_t)c; u->old = G.val[c]; u->notes = G.notes[c]; u->peers = peers;
 }
 
 /* Pone v en c y borra esa nota de las vecinas; devuelve que vecinas la tenian. */
 static uint32_t set_value(int c, int v)
 {
     uint32_t peers = 0;
     G.val[c] = (uint8_t)v;
     G.notes[c] = 0;
     for (int i = 0; i < 20; i++) {
         uint16_t *n = &G.notes[su_peer[c][i]];
         if (*n >> (v - 1) & 1) { *n &= (uint16_t)~(1u << (v - 1)); peers |= 1u << i; }
     }
     return peers;
 }
 
 static void act_digit(int v)
 {
     int c = G.cy * 9 + G.cx;
     if (G.fixed[c]) return;
     if (G.notes_mode) {
         if (G.val[c]) return;
         push_undo(c, 0);
         G.notes[c] ^= (uint16_t)(1u << (v - 1));
     } else if (G.val[c] == v) {                 /* el mismo numero lo borra */
         push_undo(c, 0);
         G.val[c] = 0;
     } else {
         push_undo(c, 0);
         G.undo[G.nundo - 1].peers = set_value(c, v);
         if (v != G.sol[c]) G.errors++;
         check_win();
     }
     if (G.state == PLAYING) save_game();
 }
 
 static void act_clear(void)
 {
     int c = G.cy * 9 + G.cx;
     if (G.fixed[c] || (!G.val[c] && !G.notes[c])) return;
     push_undo(c, 0);
     G.val[c] = 0;
     G.notes[c] = 0;
     save_game();
 }
 
 static void act_undo(void)
 {
     while (G.nundo) {
         Undo *u = &G.undo[--G.nundo];
         int c = u->cell;
         if (G.fixed[c]) continue;               /* la lleno una pista: no se toca */
         int v = G.val[c];
         if (v && u->peers)
             for (int i = 0; i < 20; i++)
                 if (u->peers >> i & 1) G.notes[su_peer[c][i]] |= (uint16_t)(1u << (v - 1));
         G.val[c] = u->old;
         G.notes[c] = u->notes;
         G.cx = c % 9; G.cy = c / 9;
         save_game();
         return;
     }
 }
 
 static void act_hint(void)
 {
     int c = G.cy * 9 + G.cx;
     if (G.val[c] == G.sol[c]) {                 /* la celda actual esta bien: otra al azar */
         static uint8_t cand[81];
         int n = 0;
         for (int i = 0; i < 81; i++) if (G.val[i] != G.sol[i]) cand[n++] = (uint8_t)i;
         if (!n) return;
         c = cand[mini_rand(n)];
         G.cx = c % 9; G.cy = c / 9;
     }
     set_value(c, G.sol[c]);
     G.fixed[c] = 2;
     G.hints++;
     check_win();
     if (G.state == PLAYING) save_game();
 }
 
 /* ------------------------------------------------------------ dibujo */
 
 #define C_BG     RGB(16, 20, 30)
 #define C_THIN   RGB(58, 66, 86)
 #define C_THICK  RGB(160, 170, 192)
 #define C_CELL   RGB(30, 36, 50)
 #define C_ZONE   RGB(42, 52, 72)       /* fila/columna/bloque del cursor */
 #define C_SAME   RGB(66, 84, 124)      /* mismo numero que el del cursor */
 #define C_CUR    RGB(92, 112, 160)
 #define C_GIVEN  RGB(235, 235, 240)
 #define C_MINE   RGB(110, 180, 255)    /* numeros del jugador */
 #define C_HINT   RGB(120, 220, 140)
 #define C_BAD    RGB(255, 80, 70)
 
 static int pos(int i) { return 31 * i + 2 + i / 3; }
 
 static void paint_grid(Surface *s)
 {
     int cc = G.cy * 9 + G.cx, cur = G.val[cc];
     bool playing = G.state == PLAYING;
     gfx_rect(s, OX, OY, GRID, GRID, C_THIN);
     for (int k = 0; k <= 3; k++) {
         int p = k == 3 ? GRID - 2 : pos(3 * k) - 2;
         gfx_rect(s, OX + p, OY, 2, GRID, C_THICK);
         gfx_rect(s, OX, OY + p, GRID, 2, C_THICK);
     }
     for (int y = 0; y < 9; y++)
         for (int x = 0; x < 9; x++) {
             int c = y * 9 + x, px = OX + pos(x), py = OY + pos(y), v = G.val[c];
             Color bg = C_CELL;
             if (playing) {
                 if (c == cc) bg = C_CUR;
                 else if (cur && v == cur) bg = C_SAME;
                 else if (x == G.cx || y == G.cy || (x / 3 == G.cx / 3 && y / 3 == G.cy / 3)) bg = C_ZONE;
             }
             gfx_rect(s, px, py, CELL, CELL, bg);
             if (v) {
                 char t[2] = { (char)('0' + v), 0 };
                 Color col = G.fixed[c] == 1 ? C_GIVEN : G.fixed[c] == 2 ? C_HINT : C_MINE;
                 if (!G.fixed[c] && G.mark && v != G.sol[c]) col = C_BAD;
                 mini_big_text(s, &font_bold, px + 9, py + 2, 2, t, col);
             } else if (G.notes[c]) {
                 for (int d = 0; d < 9; d++) {
                     if (!(G.notes[c] >> d & 1)) continue;
                     char t[2] = { (char)('1' + d), 0 };
                     int nx = px + 2 + (d % 3) * 9, ny = py + 2 + (d / 3) * 9;
                     bool hl = playing && cur == d + 1;
                     if (hl) gfx_rect(s, nx - 1, ny - 1, 8, 9, C_ACCENT);
                     gfx_text(s, &font_small, nx + 1, ny, t, hl ? C_BLACK : RGB(170, 178, 196));
                 }
             }
         }
     if (playing) {
         int px = OX + pos(G.cx), py = OY + pos(G.cy);
         gfx_frame(s, px, py, CELL, CELL, C_CURSOR);
         gfx_frame(s, px + 1, py + 1, CELL - 2, CELL - 2, C_CURSOR);
     }
 }
 
 static void paint(Surface *s, void *ctx)
 {
     char buf[40];
     int p;
 
     gfx_rect(s, 0, 0, 320, 320, C_BG);
     gfx_rect(s, 0, 0, 320, 24, C_PANEL);
     if (G.mark) {
         p = str_put(buf, sizeof buf, 0, "Errores ");
         str_int(buf, sizeof buf, p, G.errors);
         gfx_text(s, &font_normal, 6, 6, buf, G.errors ? C_ERR : C_TEXT);
     } else {
         p = str_put(buf, sizeof buf, 0, "Pistas ");
         str_int(buf, sizeof buf, p, G.hints);
         gfx_text(s, &font_normal, 6, 6, buf, C_TEXT);
     }
     str_time(buf, sizeof buf, 0, elapsed());
     gfx_text(s, &font_bold, 314 - gfx_text_w(&font_bold, buf), 6, buf, C_TEXT);
     if (G.notes_mode && G.state == PLAYING) {
         gfx_rect(s, 130, 4, 60, 16, C_ACCENT);
         gfx_text_center(s, &font_bold, 130, 6, 60, "NOTAS", C_BLACK);
     } else gfx_text_center(s, &font_normal, 100, 6, 120, LEVEL_NAMES[G.lvl], C_ACCENT);
 
     paint_grid(s);
     if (G.state == PLAYING) {
         gfx_text_center(s, &font_small, 0, 311, 320,
                         G.notes_mode ? "1-9 nota  N números  P pista  U deshacer  Esc menú"
                                      : "1-9 poner  N notas  P pista  U deshacer  Esc menú", C_DIM);
         return;
     }
     /* cartel de fin */
     int bx = 40, by = 122, w = 240, h = 76;
     gfx_box(s, bx, by, w, h, C_PANEL, C_OK);
     gfx_box(s, bx + 1, by + 1, w - 2, h - 2, C_PANEL, C_OK);
     gfx_text_center(s, &font_bold, bx, by + 8, w, "¡Resuelto!", C_OK);
     p = str_put(buf, sizeof buf, 0, "Tiempo ");
     p = str_time(buf, sizeof buf, p, G.elapsed);
     if (G.record) str_put(buf, sizeof buf, p, "  ¡récord!");
     gfx_text_center(s, &font_normal, bx, by + 26, w, buf, G.record ? C_ACCENT : C_TEXT);
     p = str_put(buf, sizeof buf, 0, "Errores ");
     p = str_int(buf, sizeof buf, p, G.errors);
     p = str_put(buf, sizeof buf, p, "   Pistas ");
     str_int(buf, sizeof buf, p, G.hints);
     gfx_text_center(s, &font_normal, bx, by + 42, w, buf, C_TEXT);
     gfx_text_center(s, &font_small, bx, by + 61, w, "Enter otro   Esc menú", C_DIM);
 }
 
 /* ------------------------------------------------------------ menus y bucle */
 
 static void art(Surface *s)
 {
     /* una tirita de celdas: pistas, del jugador y una con notas */
     static const int8_t demo[] = { 5, 3, -1, 7, 9, 0, 1 };
     int c = 22, x0 = (320 - 7 * c) / 2, y = 58;
     gfx_rect(s, x0 - 2, y - 2, 7 * c + 4, c + 4, C_THICK);
     for (int i = 0; i < 7; i++) {
         int x = x0 + i * c;
         gfx_rect(s, x + 1, y, c - 2, c, i == 3 ? C_CUR : C_CELL);
         if (demo[i] > 0) {
             char t[2] = { (char)('0' + demo[i]), 0 };
             gfx_text(s, &font_bold, x + 8, y + 5, t, i == 1 || i == 4 ? C_MINE : C_GIVEN);
         } else if (demo[i] < 0) {
             static const char *const nn[] = { "2", "4", "6", "8" };
             for (int k = 0; k < 4; k++)
                 gfx_text(s, &font_small, x + 4 + (k % 2) * 9, y + 3 + (k / 2) * 9, nn[k], RGB(170, 178, 196));
         }
     }
 }
 
 enum { M_CONT = 1, M_PLAY, M_LEVEL, M_MARK };
 
 /* Devuelve M_CONT o M_PLAY; el nivel y "marcar errores" quedan en *lvl y G.mark. */
 static int main_menu(int *lvl)
 {
     static char lines[NLEVELS][48];
     Form f;
     form_begin(&f, "Sudoku");
     if (has_saved()) form_button(&f, M_CONT, "Continuar");
     form_button(&f, M_PLAY, "Juego nuevo");
     form_choice(&f, M_LEVEL, "Nivel", LEVEL_NAMES, NLEVELS, *lvl);
     form_choice(&f, M_MARK, "Marcar errores", YESNO, 2, G.mark);
     form_label(&f, "");
     for (int i = 0; i < NLEVELS; i++) {
         char k[8];
         level_key(k, sizeof k, "rec", i);
         long rec = mini_get(k, 0);
         int p = str_put(lines[i], sizeof lines[i], 0, LEVEL_NAMES[i]);
         p = str_put(lines[i], sizeof lines[i], p, ": récord ");
         if (rec) p = str_time(lines[i], sizeof lines[i], p, (uint32_t)rec);
         else p = str_put(lines[i], sizeof lines[i], p, "-");
         level_key(k, sizeof k, "res", i);
         p = str_put(lines[i], sizeof lines[i], p, ", resueltos ");
         str_int(lines[i], sizeof lines[i], p, mini_get(k, 0));
         form_label(&f, lines[i]);
     }
     for (;;) {
         int r = mini_form(&f);
         if (r != M_CONT && r != M_PLAY) continue;
         int nl = form_get(&f, M_LEVEL)->value;
         bool mark = form_get(&f, M_MARK)->value;
         if (nl != *lvl || mark != G.mark) {
             *lvl = nl; G.mark = mark;
             mini_set("nivel", nl); mini_set("marca", mark);
             mini_save();
         }
         return r;
     }
 }
 
 /* Devuelve true si hay que volver al menu principal. */
 static bool pause_menu(void)
 {
     uint32_t t = hal_ms();
     Form f;
     form_begin(&f, "Pausa");
     form_button(&f, 1, "Seguir");
     form_button(&f, 2, "Empezar de nuevo");
     form_button(&f, 3, "Menú principal");
     int r = mini_form(&f);
     G.t0 += hal_ms() - t;                       /* la pausa no cuenta */
     if (r == 2) {                               /* el mismo sudoku, desde cero */
         for (int i = 0; i < 81; i++)
             if (G.fixed[i] != 1) { G.val[i] = 0; G.fixed[i] = 0; }
         memset(G.notes, 0, sizeof G.notes);
         G.errors = G.hints = G.nundo = 0;
         G.notes_mode = false;
         G.t0 = hal_ms();
     }
     save_game();
     return r == 3;
 }
 
 void app_main(void)
 {
     mini_start("Sudoku", RGB(120, 200, 255));
     mini_art = art;
     su_init();
     int lvl = (int)mini_get("nivel", 0);
     if (lvl < 0 || lvl >= NLEVELS) lvl = 0;
     G.mark = mini_get("marca", 1) != 0;
     for (;;) {
         int r = main_menu(&lvl);
         bool mark = G.mark;
         if (r != M_CONT || !load_game()) new_game(lvl);
         G.mark = mark;
         bool dirty = true;
         uint32_t shown_sec = 0;
         for (;;) {
             int k = hal_key();
             if (k == 0) dirty = true;
             else if (k > 0) {
                 dirty = true;
                 if (G.state != PLAYING) {
                     if (k == K_OK || k == ' ') new_game(lvl);
                     else if (k == K_BACK) break;
                     continue;
                 }
                 switch (k) {
                 case K_LEFT:  G.cx = (G.cx + 8) % 9; break;
                 case K_RIGHT: G.cx = (G.cx + 1) % 9; break;
                 case K_UP:    G.cy = (G.cy + 8) % 9; break;
                 case K_DOWN:  G.cy = (G.cy + 1) % 9; break;
                 case '0': case ' ': case K_BKSP: act_clear(); break;
                 case 'n': case 'N': case K_TAB: G.notes_mode = !G.notes_mode; break;
                 case 'p': case 'P': act_hint(); break;
                 case 'u': case 'U': act_undo(); break;
                 case K_BACK: if (pause_menu()) goto menu; break;
                 default: if (k >= '1' && k <= '9') act_digit(k - '0'); break;
                 }
             }
             uint32_t sec = elapsed() / 1000;
             if (sec != shown_sec) { shown_sec = sec; dirty = true; }
             if (dirty) { hal_draw(paint, 0); dirty = false; }
             else hal_sleep(10);
         }
     menu:;
     }
 }