juegos

ctrl.c (6821B)

---

 /* ctrl.c - maquina de estados de la interaccion con el tablero. */
 #include <string.h>
 #include "ctrl.h"
 
 static void msg(Ctrl *c, const char *m, bool err)
 {
     str_put(c->msg, sizeof c->msg, 0, m ? m : "");
     c->msg_err = err;
 }
 
 void ctrl_init(Ctrl *c, uint8_t local, bool flipped)
 {
     memset(c, 0, sizeof *c);
     c->local = local;
     c->flipped = flipped;
     c->sel = -1;
     c->cursor = flipped ? SQ(4, 6) : SQ(4, 1);
 }
 
 bool ctrl_my_turn(const Ctrl *c)
 {
     return c->g && c->g->result == R_NONE && ((c->local >> c->g->pos.side) & 1);
 }
 
 static void deselect(Ctrl *c)
 {
     c->sel = -1;
     c->ntargets = 0;
     if (c->mode == CM_PROMO) c->mode = CM_BOARD;
 }
 
 static void select_sq(Ctrl *c, int sq)
 {
     MoveList l;
     pos_legal(&c->g->pos, &l);
     c->ntargets = 0;
     for (int i = 0; i < l.n && c->ntargets < 32; i++)
         if (MFROM(l.m[i]) == sq) {
             /* las coronaciones se muestran una vez por casilla */
             bool dup = false;
             for (int k = 0; k < c->ntargets; k++) if (MTO(c->targets[k]) == MTO(l.m[i])) dup = true;
             if (!dup) c->targets[c->ntargets++] = l.m[i];
         }
     c->sel = c->ntargets ? sq : -1;
 }
 
 void ctrl_sync(Ctrl *c, const Game *g)
 {
     c->g = g;
     if (c->sel >= 0) {
         int s = c->sel;
         if (!ctrl_my_turn(c)) deselect(c);
         else select_sq(c, s);
     }
     if (!ctrl_my_turn(c) && c->mode != CM_ENTRY) c->mode = CM_BOARD;
 }
 
 void ctrl_error(Ctrl *c, int err) { msg(c, err_text(err), true); }
 
 bool ctrl_is_target(const Ctrl *c, int sq)
 {
     for (int i = 0; i < c->ntargets; i++) if (MTO(c->targets[i]) == sq) return true;
     return false;
 }
 
 int ctrl_last_move(const Ctrl *c, int *from, int *to)
 {
     if (!c->g || !c->g->nply) return 0;
     Move m = c->g->mv[c->g->nply - 1];
     *from = MFROM(m);
     *to = MTO(m);
     return 1;
 }
 
 const char *ctrl_prompt(const Ctrl *c)
 {
     if (!c->g) return "";
     if (c->mode == CM_ENTRY) return tr(S_P_ENTRY);
     if (c->g->result != R_NONE) return tr(S_P_OVER);
     if (!ctrl_my_turn(c)) return tr(S_P_WAIT);
     if (c->mode == CM_PROMO) return tr(S_P_PROMO);
     return c->sel >= 0 ? tr(S_P_TARGET) : tr(S_P_SELECT);
 }
 
 static bool emit_move(Ctrl *c, Move m, Act *out)
 {
     memset(out, 0, sizeof *out);
     out->type = ACT_MOVE;
     out->c = (int8_t)c->g->pos.side;
     out->m = m;
     deselect(c);
     msg(c, "", false);
     return true;
 }
 
 /* eleccion de destino: si es coronacion, primero se elige la pieza */
 static bool choose_target(Ctrl *c, int to, Act *out)
 {
     for (int i = 0; i < c->ntargets; i++) {
         Move m = c->targets[i];
         if (MTO(m) != to) continue;
         if (MIS_PROMO(m)) {
             int from = MFROM(m), capflag = MIS_CAPTURE(m) ? 4 : 0;
             for (int k = 0; k < 4; k++) c->promo[k] = MOVE(from, to, MF_PROMO + 3 - k + capflag);   /* Q R B N */
             c->promo_cur = 0;
             c->mode = CM_PROMO;
             return false;
         }
         return emit_move(c, m, out);
     }
     return false;
 }
 
 static bool press_square(Ctrl *c, int sq, Act *out)
 {
     if (!ctrl_my_turn(c)) { if (c->g && c->g->result == R_NONE) msg(c, err_text(E_TURN), true); return false; }
     uint8_t pc = c->g->pos.sq[sq];
     if (c->sel >= 0) {
         if (sq == c->sel) { deselect(c); return false; }
         if (ctrl_is_target(c, sq)) return choose_target(c, sq, out);
     }
     if (pc && PCOLOR(pc) == c->g->pos.side) {
         select_sq(c, sq);
         if (c->sel < 0) msg(c, tr(S_NO_MOVES), true);
         else msg(c, "", false);
         return false;
     }
     if (c->sel >= 0) msg(c, err_text(E_ILLEGAL), true);
     return false;
 }
 
 /* Tab: siguiente pieza propia con jugadas, o siguiente destino si hay una elegida */
 static void tab(Ctrl *c)
 {
     if (!ctrl_my_turn(c)) return;
     if (c->sel >= 0 && c->ntargets) {
         int cur = -1;
         for (int i = 0; i < c->ntargets; i++) if (MTO(c->targets[i]) == c->cursor) cur = i;
         c->cursor = MTO(c->targets[(cur + 1) % c->ntargets]);
         return;
     }
     MoveList l;
     pos_legal(&c->g->pos, &l);
     for (int k = 1; k <= 64; k++) {
         int s = (c->cursor + k) & 63;
         for (int i = 0; i < l.n; i++) if (MFROM(l.m[i]) == s) { c->cursor = s; return; }
     }
 }
 
 static const char PROMO_ES[] = "dtac", PROMO_EN[] = "qrbn";
 
 bool ctrl_key(Ctrl *c, int key, Act *out)
 {
     if (!c->g) return false;
     if (c->mode == CM_ENTRY) {
         int n = (int)strlen(c->entry);
         if (key == K_BACK) { c->mode = CM_BOARD; c->entry[0] = 0; return false; }
         if (key == K_BKSP) { if (n) c->entry[n - 1] = 0; return false; }
         if (key == K_OK) {
             c->mode = CM_BOARD;
             Move m = ctrl_my_turn(c) ? move_from_san(&c->g->pos, c->entry) : MOVE_NONE;
             c->entry[0] = 0;
             if (!ctrl_my_turn(c)) { msg(c, err_text(E_TURN), true); return false; }
             if (!m) { msg(c, err_text(E_ILLEGAL), true); return false; }
             return emit_move(c, m, out);
         }
         if (key > ' ' && key < 127 && n < (int)sizeof c->entry - 1) { c->entry[n] = (char)key; c->entry[n + 1] = 0; }
         return false;
     }
     if (c->mode == CM_PROMO) {
         const char *keys = g_lang ? PROMO_EN : PROMO_ES;
         const char *k = key < 128 && key > 0 ? strchr(keys, key | 0x20) : 0;
         if (k && *k) return emit_move(c, c->promo[k - keys], out);
         switch (key) {
         case K_LEFT: case K_UP: c->promo_cur = (c->promo_cur + 3) & 3; return false;
         case K_RIGHT: case K_DOWN: case K_TAB: c->promo_cur = (c->promo_cur + 1) & 3; return false;
         case K_OK: case ' ': return emit_move(c, c->promo[c->promo_cur], out);
         case K_BACK: c->mode = CM_BOARD; return false;
         }
         return false;
     }
     int f = FILE_OF(c->cursor), r = RANK_OF(c->cursor);
     int dir = c->flipped ? -1 : 1;
     switch (key) {
     case K_UP: case 'k': r += dir; break;
     case K_DOWN: case 'j': r -= dir; break;
     case K_LEFT: case 'h': f -= dir; break;
     case K_RIGHT: case 'l': f += dir; break;
     case K_OK: case ' ': return press_square(c, c->cursor, out);
     case K_BACK: if (c->sel >= 0) deselect(c); return false;
     case K_TAB: tab(c); return false;
     case ':': case '/':
         if (ctrl_my_turn(c)) { c->mode = CM_ENTRY; c->entry[0] = 0; }
         return false;
     default: return false;
     }
     if (f < 0) f = 0;
     if (f > 7) f = 7;
     if (r < 0) r = 0;
     if (r > 7) r = 7;
     c->cursor = SQ(f, r);
     return false;
 }
 
 bool ctrl_click(Ctrl *c, int kind, int id, Act *out)
 {
     if (kind == HIT_PROMO && c->mode == CM_PROMO && id >= 0 && id < 4) return emit_move(c, c->promo[id], out);
     if (kind == HIT_SQUARE && id >= 0 && id < 64) {
         if (c->mode == CM_PROMO) c->mode = CM_BOARD;
         c->cursor = id;
         return press_square(c, id, out);
     }
     return false;
 }