juegos

app.c (17168B)

---

 /* app.c - 2048 para la PicoCalc.
  *
  * Flechas deslizan todas las fichas; dos iguales que chocan se funden (una vez por
  * jugada). Despues de cada jugada aparece un 2 (90%) o un 4 (10%) en un hueco.
  * U o Retroceso deshace la ultima jugada (una sola vez seguida). Esc pausa.
  * La partida en curso se guarda en la SD despues de cada jugada. */
 #include <string.h>
 #include "mini.h"
 
 enum { MAXN = 5, TOP = 28, FLASH_MS = 90 };
 
 typedef struct { const char *name; int n, cell, gap; } Size;
 static const Size SIZES[] = {
     { "4x4", 4, 64, 4 },
     { "5x5", 5, 50, 4 },
 };
 enum { NSIZES = 2 };
 
 enum { PLAYING, WINBOX, LOST };
 
 typedef struct {
     int sz, n;
     uint8_t b[MAXN][MAXN];            /* exponente: 0 vacio, 1 = 2, 2 = 4, ... */
     uint8_t ub[MAXN][MAXN];           /* tablero antes de la ultima jugada */
     uint8_t merged[MAXN][MAXN];       /* fusionadas en la ultima jugada (destello) */
     long score, uscore;
     bool can_undo;
     bool won;                         /* ya se mostro el cartel de 2048 */
     int state, sel;                   /* sel: boton del cartel de 2048 */
     int new_x, new_y;                 /* ficha recien aparecida (-1 ninguna) */
     bool flash;                       /* dibujar el destello */
     bool record;                      /* supero el record en esta partida */
 } Game;
 
 static Game G;
 static bool g_flash_on = true;        /* opcion del menu */
 
 /* ------------------------------------------------------------ records y guardado */
 
 static void key_for(char *k, int n, const char *pre, int sz)
 {
     int p = str_put(k, n, 0, pre);
     str_int(k, n, p, SIZES[sz].n);
 }
 
 static long best_score(int sz) { char k[8]; key_for(k, sizeof k, "r", sz); return mini_get(k, 0); }
 static long best_tile(int sz)  { char k[8]; key_for(k, sizeof k, "t", sz); return mini_get(k, 0); }
 
 /* Partida en curso: "p <n><fichas a..><:puntos:ganada>", o "-" si no hay. */
 static void save_game(void)
 {
     char v[64];
     int p = 0;
     v[p++] = (char)('0' + G.n);
     for (int y = 0; y < G.n; y++)
         for (int x = 0; x < G.n; x++) v[p++] = (char)('a' + G.b[y][x]);
     v[p] = 0;
     p = str_put(v, sizeof v, p, ":");
     p = str_int(v, sizeof v, p, G.score);
     str_put(v, sizeof v, p, G.won ? ":1" : ":0");
     mini_set_str("p", v);
 }
 
 static bool has_saved(void)
 {
     const char *v = mini_get_str("p");
     return v && (v[0] == '4' || v[0] == '5');
 }
 
 static bool load_game(void)
 {
     const char *v = mini_get_str("p");
     if (!v) return false;
     int n = v[0] - '0', sz = -1;
     for (int i = 0; i < NSIZES; i++) if (SIZES[i].n == n) sz = i;
     if (sz < 0 || (int)strlen(v) < 1 + n * n + 2) return false;
     memset(&G, 0, sizeof G);
     G.sz = sz; G.n = n;
     for (int i = 0; i < n * n; i++) {
         int e = v[1 + i] - 'a';
         if (e < 0 || e > 20) return false;
         G.b[i / n][i % n] = (uint8_t)e;
     }
     const char *s = v + 1 + n * n;
     if (*s++ != ':' || !(s = str_scan_int(s, &G.score))) return false;
     G.won = s[0] == ':' && s[1] == '1';
     G.new_x = G.new_y = -1;
     return true;
 }
 
 static void clear_saved(void) { mini_set_str("p", "-"); }
 
 /* ------------------------------------------------------------ reglas */
 
 static void spawn(void)
 {
     int empty[MAXN * MAXN], ne = 0;
     for (int y = 0; y < G.n; y++)
         for (int x = 0; x < G.n; x++)
             if (!G.b[y][x]) empty[ne++] = y * MAXN + x;
     if (!ne) { G.new_x = G.new_y = -1; return; }
     int c = empty[mini_rand(ne)];
     G.new_x = c % MAXN; G.new_y = c / MAXN;
     G.b[G.new_y][G.new_x] = mini_rand(10) ? 1 : 2;
 }
 
 static void new_game(int sz)
 {
     memset(&G, 0, sizeof G);
     G.sz = sz;
     G.n = SIZES[sz].n;
     spawn();
     spawn();
     G.new_x = G.new_y = -1;
 }
 
 static bool can_move(void)
 {
     for (int y = 0; y < G.n; y++)
         for (int x = 0; x < G.n; x++) {
             if (!G.b[y][x]) return true;
             if (x + 1 < G.n && G.b[y][x + 1] == G.b[y][x]) return true;
             if (y + 1 < G.n && G.b[y + 1][x] == G.b[y][x]) return true;
         }
     return false;
 }
 
 static int max_exp(void)
 {
     int m = 0;
     for (int y = 0; y < G.n; y++)
         for (int x = 0; x < G.n; x++)
             if (G.b[y][x] > m) m = G.b[y][x];
     return m;
 }
 
 /* Desliza hacia (dx, dy). Devuelve true si algo se movio. */
 static bool slide(int dx, int dy)
 {
     uint8_t old[MAXN][MAXN];
     long old_score = G.score;
     bool moved = false;
     memcpy(old, G.b, sizeof old);
     memset(G.merged, 0, sizeof G.merged);
     for (int line = 0; line < G.n; line++) {
         /* celdas de la linea, empezando por la del borde hacia donde se desliza */
         int cx[MAXN], cy[MAXN];
         for (int i = 0; i < G.n; i++) {
             int j = (dx > 0 || dy > 0) ? G.n - 1 - i : i;
             if (dx) { cx[i] = j; cy[i] = line; }
             else    { cx[i] = line; cy[i] = j; }
         }
         int out = 0;
         bool last_merged = false;
         for (int i = 0; i < G.n; i++) {
             int e = G.b[cy[i]][cx[i]];
             if (!e) continue;
             G.b[cy[i]][cx[i]] = 0;
             if (out > 0 && !last_merged && G.b[cy[out - 1]][cx[out - 1]] == e) {
                 G.b[cy[out - 1]][cx[out - 1]] = (uint8_t)(e + 1);
                 G.merged[cy[out - 1]][cx[out - 1]] = 1;
                 G.score += 1L << (e + 1);
                 last_merged = true;
             } else {
                 G.b[cy[out]][cx[out]] = (uint8_t)e;
                 out++;
                 last_merged = false;
             }
         }
     }
     for (int y = 0; y < G.n && !moved; y++)
         for (int x = 0; x < G.n; x++)
             if (G.b[y][x] != old[y][x]) { moved = true; break; }
     if (moved) {
         memcpy(G.ub, old, sizeof old);
         G.uscore = old_score;
         G.can_undo = true;
     }
     return moved;
 }
 
 static void update_records(void)
 {
     char k[8];
     key_for(k, sizeof k, "r", G.sz);
     if (G.score > mini_get(k, 0)) { mini_set(k, G.score); G.record = G.score > 0; }
     key_for(k, sizeof k, "t", G.sz);
     long tile = 1L << max_exp();
     if (tile > mini_get(k, 0)) mini_set(k, tile);
 }
 
 /* Si no quedan jugadas termina la partida; si no, la guarda. No escribe la SD. */
 static void check_lost(void)
 {
     if (can_move()) { save_game(); return; }
     G.state = LOST;
     char k[8];
     key_for(k, sizeof k, "j", G.sz);
     mini_set(k, mini_get(k, 0) + 1);
     clear_saved();
 }
 
 static void act_move(int dx, int dy)
 {
     if (!slide(dx, dy)) return;
     spawn();
     G.flash = g_flash_on;
     update_records();
     if (!G.won && max_exp() >= 11) { G.won = true; G.state = WINBOX; G.sel = 0; save_game(); }
     else check_lost();
     mini_save();
 }
 
 static void act_undo(void)
 {
     if (!G.can_undo) return;
     memcpy(G.b, G.ub, sizeof G.b);
     G.score = G.uscore;
     G.can_undo = false;
     G.flash = false;
     G.new_x = G.new_y = -1;
     memset(G.merged, 0, sizeof G.merged);
     if (G.state == LOST) {                        /* deshacer la jugada perdedora */
         char k[8];
         key_for(k, sizeof k, "j", G.sz);
         mini_set(k, mini_get(k, 0) - 1);
     }
     G.state = PLAYING;
     save_game();
     mini_save();
 }
 
 /* ------------------------------------------------------------ dibujo */
 
 static Color tile_bg(int e)
 {
     static const Color C[] = {
         RGB(44, 50, 66),                                   /* vacia */
         RGB(238, 228, 218), RGB(237, 224, 200), RGB(242, 177, 121), RGB(245, 149, 99),
         RGB(246, 124, 95), RGB(246, 94, 59), RGB(237, 207, 114), RGB(237, 204, 97),
         RGB(237, 200, 80), RGB(237, 197, 63), RGB(237, 194, 46),               /* 2048 */
         RGB(178, 110, 240), RGB(140, 90, 230), RGB(96, 110, 235), RGB(60, 150, 230),
         RGB(40, 180, 190), RGB(40, 180, 120),
     };
     return C[e < (int)(sizeof C / sizeof C[0]) ? e : (int)(sizeof C / sizeof C[0]) - 1];
 }
 
 static Color tile_fg(int e) { return e <= 2 ? RGB(110, 100, 90) : RGB(250, 248, 242); }
 
 /* Rectangulo con las esquinas recortadas (r = 1 o 2). */
 static void round_rect(Surface *s, int x, int y, int w, int h, Color c)
 {
     gfx_rect(s, x + 2, y, w - 4, h, c);
     gfx_rect(s, x, y + 2, w, h - 4, c);
     gfx_rect(s, x + 1, y + 1, w - 2, h - 2, c);
 }
 
 static void num_text(char *t, int n, int e)
 {
     str_int(t, n, 0, 1L << e);
 }
 
 /* Numero lo mas grande posible que entre en la ficha. */
 static void draw_num(Surface *s, int x, int y, int c, const char *t, Color col)
 {
     static const struct { const Font *f; int sc; } OPT[] = {
         { &font_bold, 3 }, { &font_bold, 2 }, { &font_small, 3 }, { &font_small, 2 }, { &font_bold, 1 },
     };
     int nopt = (int)(sizeof OPT / sizeof OPT[0]);
     for (int i = 0; i < nopt; i++) {
         const Font *f = OPT[i].f;
         int sc = OPT[i].sc, w = mini_big_w(f, sc, t), h = f->h * sc;
         if (i < nopt - 1 && (w > c - 8 || h > c - 8)) continue;
         /* los digitos de font_bold ocupan las filas 2..11: centrar eso */
         int gy = f == &font_bold ? (c - 10 * sc) / 2 - 2 * sc : (c - h) / 2;
         mini_big_text(s, f, x + (c - w) / 2 + 1, y + gy, sc, t, col);
         return;
     }
 }
 
 static void draw_tile(Surface *s, int px, int py, int c, int e, bool is_new, bool merged)
 {
     if (!e) { round_rect(s, px, py, c, c, tile_bg(0)); return; }
     if (is_new) {                                 /* aparece: mas chica y palida */
         int in = c / 6;
         round_rect(s, px, py, c, c, tile_bg(0));
         round_rect(s, px + in, py + in, c - 2 * in, c - 2 * in, tile_bg(e));
         return;
     }
     round_rect(s, px, py, c, c, tile_bg(e));
     if (merged) {                                 /* destello: borde blanco */
         gfx_frame(s, px + 1, py + 1, c - 2, c - 2, C_WHITE);
         gfx_frame(s, px + 2, py + 2, c - 4, c - 4, C_WHITE);
     }
     char t[12];
     num_text(t, sizeof t, e);
     draw_num(s, px, py, c, t, tile_fg(e));
 }
 
 static void draw_banner(Surface *s, int bx, int by, int w, int h, Color border)
 {
     gfx_box(s, bx, by, w, h, C_PANEL, border);
     gfx_box(s, bx + 1, by + 1, w - 2, h - 2, C_PANEL, border);
 }
 
 static void paint(Surface *s, void *ctx)
 {
     const Size *sz = &SIZES[G.sz];
     int n = G.n, c = sz->cell, g = sz->gap, bw = n * c + (n + 1) * g;
     int ox = (320 - bw) / 2, oy = TOP + (278 - bw) / 2;
     char buf[48];
     int p;
 
     gfx_rect(s, 0, 0, 320, 320, RGB(16, 20, 30));
     gfx_rect(s, 0, 0, 320, 24, C_PANEL);
     p = str_put(buf, sizeof buf, 0, "Puntos ");
     str_int(buf, sizeof buf, p, G.score);
     gfx_text(s, &font_bold, 6, 6, buf, C_TEXT);
     p = str_put(buf, sizeof buf, 0, "Récord ");
     long best = best_score(G.sz);
     str_int(buf, sizeof buf, p, best > G.score ? best : G.score);
     gfx_text(s, &font_bold, 314 - gfx_text_w(&font_bold, buf), 6, buf, G.record ? C_ACCENT : C_TEXT);
     gfx_text_center(s, &font_normal, 130, 6, 60, sz->name, C_ACCENT);
 
     round_rect(s, ox, oy, bw, bw, RGB(30, 35, 48));
     for (int y = 0; y < n; y++)
         for (int x = 0; x < n; x++)
             draw_tile(s, ox + g + x * (c + g), oy + g + y * (c + g), c, G.b[y][x],
                       G.flash && x == G.new_x && y == G.new_y, G.flash && G.merged[y][x]);
 
     if (G.state == PLAYING) {
         gfx_text_center(s, &font_small, 0, 311, 320,
                         G.can_undo ? "Flechas mover  U deshacer  Esc menú" : "Flechas mover  Esc menú", C_DIM);
         return;
     }
     int bx = 40, w = 240;
     if (G.state == WINBOX) {
         int by = 120, h = 80;
         draw_banner(s, bx, by, w, h, C_ACCENT);
         gfx_text_center(s, &font_bold, bx, by + 10, w, "¡Llegaste a 2048!", C_ACCENT);
         p = str_put(buf, sizeof buf, 0, "Puntos ");
         str_int(buf, sizeof buf, p, G.score);
         gfx_text_center(s, &font_normal, bx, by + 28, w, buf, C_TEXT);
         static const char *const BTN[2] = { "Seguir jugando", "Menú" };
         int bxs[2] = { bx + 16, bx + 148 }, bws[2] = { 120, 76 };
         for (int i = 0; i < 2; i++) {
             bool on = G.sel == i;
             gfx_box(s, bxs[i], by + 50, bws[i], 20, on ? C_PANEL2 : C_PANEL, on ? C_CURSOR : C_DIM);
             gfx_text_center(s, &font_normal, bxs[i], by + 54, bws[i], BTN[i], on ? C_CURSOR : C_TEXT);
         }
         return;
     }
     /* sin movimientos */
     int by = 125, h = 70;
     draw_banner(s, bx, by, w, h, C_ERR);
     gfx_text_center(s, &font_bold, bx, by + 8, w, "Sin movimientos", C_ERR);
     p = str_put(buf, sizeof buf, 0, "Puntos ");
     p = str_int(buf, sizeof buf, p, G.score);
     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);
     gfx_text_center(s, &font_small, bx, by + 46, w,
                     G.can_undo ? "Enter otra  U deshacer  Esc menú" : "Enter otra   Esc menú", C_DIM);
 }
 
 /* ------------------------------------------------------------ menus y bucle */
 
 static void art(Surface *s)
 {
     /* una tirita de fichas de adorno: 2 4 8 ... 128 */
     int c = 22, gap = 3, nt = 7, x0 = (320 - nt * c - (nt - 1) * gap) / 2, y = 56;
     for (int i = 0; i < nt; i++) {
         int x = x0 + i * (c + gap), e = i + 1;
         char t[8];
         round_rect(s, x, y, c, c, tile_bg(e));
         num_text(t, sizeof t, e);
         const Font *f = e < 4 ? &font_bold : &font_small;
         gfx_text(s, f, x + (c - gfx_text_w(f, t)) / 2 + 1, y + (c - f->h) / 2 + 1, t, tile_fg(e));
     }
 }
 
 static const char *const SIZE_NAMES[] = { "4x4", "5x5" };
 static const char *const YESNO[] = { "No", "Sí" };
 
 /* Devuelve 1 jugar, 2 continuar; cambia *sz y la opcion de destello. */
 static int main_menu(int *sz)
 {
     static char lines[NSIZES][48];
     Form f;
     form_begin(&f, "2048");
     if (has_saved()) form_button(&f, 2, mini_get_str("p")[0] == '5' ? "Continuar (5x5)" : "Continuar (4x4)");
     form_button(&f, 1, "Jugar");
     form_choice(&f, 3, "Tamaño", SIZE_NAMES, NSIZES, *sz);
     form_choice(&f, 4, "Destello", YESNO, 2, g_flash_on);
     form_label(&f, "");
     for (int i = 0; i < NSIZES; i++) {
         int p = str_put(lines[i], sizeof lines[i], 0, SIZE_NAMES[i]);
         p = str_put(lines[i], sizeof lines[i], p, ": récord ");
         p = str_int(lines[i], sizeof lines[i], p, best_score(i));
         long t = best_tile(i);
         if (t) {
             p = str_put(lines[i], sizeof lines[i], p, ", ficha ");
             str_int(lines[i], sizeof lines[i], p, t);
         }
         form_label(&f, lines[i]);
     }
     for (;;) {
         int r = mini_form(&f);
         if (r == 1 || r == 2) {
             int nsz = form_get(&f, 3)->value;
             bool fl = form_get(&f, 4)->value != 0;
             if (nsz != *sz || fl != g_flash_on) {
                 *sz = nsz; g_flash_on = fl;
                 mini_set("tam", nsz); mini_set("fl", fl); mini_save();
             }
             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");
     int r = mini_form(&f);
     if (r == 2) {
         new_game(G.sz);
         save_game();
         mini_save();
     }
     return r == 3;
 }
 
 void app_main(void)
 {
     mini_start("2048", RGB(237, 194, 46));
     mini_art = art;
     int sz = (int)mini_get("tam", 0);
     if (sz < 0 || sz >= NSIZES) sz = 0;
     g_flash_on = mini_get("fl", 1) != 0;
     for (;;) {
         int r = main_menu(&sz);
         if (r != 2 || !load_game()) {
             new_game(sz);
             save_game();
             mini_save();
         }
         bool dirty = true;
         uint32_t flash_t = 0;
         for (;;) {
             int k = hal_key();
             if (k == 0) dirty = true;
             else if (k > 0) {
                 dirty = true;
                 G.flash = false;
                 if (G.state == WINBOX) {
                     if (k == K_LEFT || k == K_RIGHT || k == K_TAB) G.sel ^= 1;
                     else if (k == K_OK || k == ' ') {
                         if (G.sel == 1) break;
                         G.state = PLAYING;
                         check_lost();
                         mini_save();
                     } else if (k == K_BACK) break;
                     continue;
                 }
                 if (G.state == LOST) {
                     if (k == 'u' || k == 'U' || k == K_BKSP) act_undo();
                     else if (k == K_OK || k == ' ') { new_game(G.sz); save_game(); mini_save(); }
                     else if (k == K_BACK) break;
                     continue;
                 }
                 switch (k) {
                 case K_LEFT:  act_move(-1, 0); break;
                 case K_RIGHT: act_move(1, 0); break;
                 case K_UP:    act_move(0, -1); break;
                 case K_DOWN:  act_move(0, 1); break;
                 case 'u': case 'U': case K_BKSP: act_undo(); break;
                 case K_BACK: if (pause_menu()) goto menu; break;
                 }
                 if (G.flash) flash_t = hal_ms();
             }
             if (G.flash && hal_ms() - flash_t >= FLASH_MS) { G.flash = false; dirty = true; }
             if (dirty) { hal_draw(paint, 0); dirty = false; }
             else hal_sleep(10);
         }
     menu:;
     }
 }