juegos

game.c (41115B)

---

 /* game.c - reglas: validacion (game_check) y aplicacion (game_apply) de movidas. */
 #include <string.h>
 #include "catan.h"
 
 const uint8_t COST_ROAD[NRES]   = { 1, 1, 0, 0, 0 };
 const uint8_t COST_SETTLE[NRES] = { 1, 1, 1, 1, 0 };
 const uint8_t COST_CITY[NRES]   = { 0, 0, 0, 2, 3 };
 const uint8_t COST_DEV[NRES]    = { 0, 0, 1, 1, 1 };
 const uint8_t COST_SHIP[NRES]   = { 0, 1, 1, 0, 0 };
 
 void opts_default(Opts *o, int players, bool variant2p)
 {
     memset(o, 0, sizeof *o);
     o->variant2p = variant2p && players == 2;
     o->np = o->variant2p ? 4 : (uint8_t)players;
     o->vp_target = 10;
     o->friendly_robber = o->variant2p;
     o->tokens_start = 2;
     o->neutral_setup = 2;
     o->beginner = 0;
 }
 
 int opts_family(const Opts *o)
 {
 #ifdef CATAN_SMALL
     (void)o;
     return BF_CLASSIC;
 #else
     if (o->scenario && o->np <= 4) return BF_SEA1 + o->scenario - SCEN_SEA1;
     return o->np > 4 ? BF_LARGE : BF_CLASSIC;
 #endif
 }
 
 int opts_board(const Opts *o)
 {
 #ifdef CATAN_SMALL
     (void)o;
     return BOARD_CLASSIC;
 #else
     return opts_family(o) * NMAPS + (o->map < NMAPS ? o->map : 0);
 #endif
 }
 
 void opts_scenario(Opts *o, int scenario)
 {
     o->scenario = (uint8_t)(scenario > SCEN_NONE && scenario < SCEN__COUNT ? scenario : SCEN_NONE);
     if (o->scenario) { o->vp_target = 13; o->beginner = 0; }
 }
 
 bool game_has_sea(const Game *g) { return game_topo(g)->sea; }
 
 int bank_start(const Opts *o) { return opts_family(o) == BF_LARGE ? 24 : 19; }
 
 int dev_counts(const Opts *o, uint8_t out[])
 {
     static const uint8_t C[2][NDEV] = { { 14, 2, 2, 2, 5 }, { 20, 3, 3, 3, 5 } };
     int big = opts_family(o) == BF_LARGE, n = 0;
     for (int d = 0; d < NDEV; d++) { out[d] = C[big][d]; n += out[d]; }
     return n;
 }
 
 int res_total(const uint8_t r[NRES])
 {
     int n = 0;
     for (int i = 0; i < NRES; i++) n += r[i];
     return n;
 }
 
 int hand_size(const Game *g, int p) { return res_total(g->p[p].res); }
 
 bool game_is_neutral(const Game *g, int p) { return p >= 0 && p < g->o.np && g->p[p].neutral; }
 
 static int desert_hex(const Game *g)
 {
     for (int h = 0; h < game_topo(g)->nhex; h++)
         if (g->terrain[h] == T_DESERT) return h;
     return 0;
 }
 
 /* el pueblo que p pone ahora en el setup es el segundo (cobra recursos) */
 static bool setup_second(const Game *g, int p)
 {
     for (int i = 0; i < g->setup_i; i++)
         if (g->setup_order[i] == p) return true;
     return false;
 }
 
 void game_init(Game *g, const Opts *o)
 {
     uint8_t ter[NHEX], num[NHEX], port[NPORT];
     memcpy(ter, g->terrain, sizeof ter);
     memcpy(num, g->num, sizeof num);
     memcpy(port, g->port, sizeof port);
     memset(g, 0, sizeof *g);
     memcpy(g->terrain, ter, sizeof ter);
     memcpy(g->num, num, sizeof num);
     memcpy(g->port, port, sizeof port);
 
     g->o = *o;
     for (int v = 0; v < NVERT; v++) g->vown[v] = -1;
     for (int e = 0; e < NEDGE; e++) g->eown[e] = -1;
     g->o.board = (uint8_t)opts_board(o);
     {                                       /* lo que este tablero no usa queda en cero */
         const Topo *t = game_topo(g);
         for (int h = t->nhex; h < NHEX; h++) g->terrain[h] = g->num[h] = 0;
         for (int i = t->nport; i < NPORT; i++) g->port[i] = 0;
     }
     uint8_t cnt[NDEV];
     for (int r = 0; r < NRES; r++) g->bank[r] = (uint8_t)bank_start(&g->o);
     g->deck_n = (uint8_t)dev_counts(&g->o, cnt);
     g->robber = (uint8_t)desert_hex(g);
     g->pirate = game_has_sea(g) ? (uint8_t)game_topo(g)->sea_start : 0xFF;
     for (int i = 0; i < o->np; i++) {
         Player *pl = &g->p[i];
         pl->roads = MAX_ROADS; pl->settles = MAX_SETTLES; pl->cities = MAX_CITIES;
         pl->ships = game_has_sea(g) ? MAX_SHIPS : 0;
         pl->neutral = o->variant2p && i >= 2;
         pl->tokens = o->variant2p && !pl->neutral ? o->tokens_start : 0;
     }
     g->longest = g->army = g->winner = -1;
     g->phase = PH_SETUP;
     /* serpiente (1 2 3 4 4 3 2 1); con setup_first, primero la serpiente de esos
      * asientos y despues la del resto (ej. humano contra bots: 1 1 2 3 4 4 3 2) */
     int n = 0, first = o->first < o->np ? o->first : 0;   /* desde que asiento se da la vuelta a la mesa */
     for (int grp = 0; grp < 2; grp++) {
         int real[MAXP], nr = 0;
         for (int k = 0; k < o->np; k++) {
             int i = (first + k) % o->np;
             if (!g->p[i].neutral && ((o->setup_first >> i & 1) == (grp == 0))) real[nr++] = i;
         }
         for (int i = 0; i < nr; i++) {
             g->setup_order[n + i] = (uint8_t)real[i];
             g->setup_order[n + 2 * nr - 1 - i] = (uint8_t)real[i];
         }
         n += 2 * nr;
     }
     g->setup_n = (uint8_t)n;
     g->cur = g->setup_order[0];
     g->setup_v = -1;
 }
 
 int game_next_player(const Game *g, int p)
 {
     for (int i = 1; i <= g->o.np; i++) {
         int q = (p + i) % g->o.np;
         if (!g->p[q].neutral) return q;
     }
     return p;
 }
 
 uint8_t game_offer_candidates(const Game *g, int p)
 {
     uint8_t m = 0;
     for (int q = 0; q < g->o.np; q++)
         if (q != p && !g->p[q].neutral) m |= (uint8_t)(1 << q);
     return m;
 }
 
 int game_rival(const Game *g, int p)
 {
     for (int q = 0; q < g->o.np; q++)
         if (q != p && !g->p[q].neutral) return q;
     return -1;
 }
 
 /* ------------------------------------------------------------------ puntos */
 
 int game_vp_public(const Game *g, int p)
 {
     const Player *pl = &g->p[p];
     int vp = (MAX_SETTLES - pl->settles) + 2 * (MAX_CITIES - pl->cities) + pl->bonus;
     if (g->longest == p) vp += 2;
     if (g->army == p) vp += 2;
     return vp;
 }
 
 int game_vp(const Game *g, int p)
 {
     return game_vp_public(g, p) + g->p[p].dev[D_VP] + g->p[p].dev_new[D_VP];
 }
 
 int game_token_cost(const Game *g, int p)
 {
     int r = game_rival(g, p);
     return (r >= 0 && game_vp_public(g, p) > game_vp_public(g, r)) ? 2 : 1;
 }
 
 /* -------------------------------------------------------------- colocacion */
 
 static bool vert_free_dist(const Game *g, int v)
 {
     const Topo *t = game_topo(g);
     if (g->vown[v] >= 0) return false;
     for (int k = 0; k < 3; k++) {
         int u = t->vert_adj[v][k];
         if (u >= 0 && g->vown[u] >= 0) return false;
     }
     return true;
 }
 
 /* el vertice toca tierra (con mar, hay vertices rodeados de agua); region: -1 cualquiera,
  * -2 alguna de arranque */
 static bool vert_land(const Game *g, int v, int region)
 {
     const Topo *t = game_topo(g);
     for (int k = 0; k < 3; k++) {
         int h = t->vert_hex[v][k];
         if (h < 0 || !ter_land(g->terrain[h])) continue;
         if (region == -1 || t->region[h] == region) return true;
         if (region == -2 && t->region[h] >= 0 && t->region[h] < 8 && ((t->home >> t->region[h]) & 1)) return true;
     }
     return false;
 }
 
 /* arista con tierra de algun lado (rutas) / con mar de algun lado (barcos) */
 static bool edge_land(const Game *g, int e)
 {
     const Topo *t = game_topo(g);
     for (int s = 0; s < 2; s++) {
         int h = t->edge_hex[e][s];
         if (h >= 0 && ter_land(g->terrain[h])) return true;
     }
     return false;
 }
 
 static bool edge_sea(const Game *g, int e)
 {
     const Topo *t = game_topo(g);
     for (int s = 0; s < 2; s++) {
         int h = t->edge_hex[e][s];
         if (h >= 0 && !ter_land(g->terrain[h])) return true;
     }
     return false;
 }
 
 bool game_can_settle(const Game *g, int p, int v, bool setup)
 {
     const Topo *t = game_topo(g);
     if (v < 0 || v >= t->nvert || !vert_free_dist(g, v)) return false;
     if (game_has_sea(g) && !vert_land(g, v, setup ? -2 : -1)) return false;   /* el setup, en tierra de arranque */
     if (setup) return true;
     for (int k = 0; k < 3; k++) {
         int e = t->vert_edge[v][k];
         if (e >= 0 && g->eown[e] == p) return true;
     }
     return false;
 }
 
 /* Rutas por tierra y barcos por agua; una ruta sigue a otra ruta y un barco a otro
  * barco, pero para pasar de ruta a barco hace falta un edificio propio en el medio. */
 static bool edge_connects(const Game *g, int p, int e, bool ship)
 {
     const Topo *t = game_topo(g);
     for (int s = 0; s < 2; s++) {
         int v = t->edge_v[e][s];
         if (g->vown[v] == p) return true;
         if (g->vown[v] >= 0) continue;          /* edificio ajeno corta la conexion */
         for (int k = 0; k < 3; k++) {
             int f = t->vert_edge[v][k];
             if (f >= 0 && f != e && g->eown[f] == p && (g->ship[f] != 0) == ship) return true;
         }
     }
     return false;
 }
 
 bool game_can_road(const Game *g, int p, int e)
 {
     const Topo *t = game_topo(g);
     if (e < 0 || e >= t->nedge || g->eown[e] >= 0) return false;
     if (game_has_sea(g) && !edge_land(g, e)) return false;
     return edge_connects(g, p, e, false);
 }
 
 static bool pirate_next(const Game *g, int e)
 {
     const Topo *t = game_topo(g);
     return t->edge_hex[e][0] == g->pirate || t->edge_hex[e][1] == g->pirate;
 }
 
 bool game_can_ship(const Game *g, int p, int e, bool setup)
 {
     const Topo *t = game_topo(g);
     if (!game_has_sea(g) || e < 0 || e >= t->nedge || g->eown[e] >= 0) return false;
     if (!edge_sea(g, e) || pirate_next(g, e)) return false;
     if (setup) return t->edge_v[e][0] == g->setup_v || t->edge_v[e][1] == g->setup_v;
     return edge_connects(g, p, e, true);
 }
 
 /* Un barco se puede mover si esta en una punta de la cadena: en uno de sus extremos
  * no hay edificio propio ni otro barco propio. No el que se puso en este turno. */
 bool game_ship_movable(const Game *g, int p, int e)
 {
     const Topo *t = game_topo(g);
     if (e < 0 || e >= t->nedge || g->eown[e] != p || !g->ship[e]) return false;
     if ((g->ship_new[e / 8] >> (e % 8)) & 1 || pirate_next(g, e)) return false;
     for (int s = 0; s < 2; s++) {
         int v = t->edge_v[e][s];
         if (g->vown[v] == p) continue;
         bool more = false;
         for (int k = 0; k < 3; k++) {
             int f = t->vert_edge[v][k];
             if (f >= 0 && f != e && g->eown[f] == p && g->ship[f]) more = true;
         }
         if (!more) return true;
     }
     return false;
 }
 
 bool game_can_moveship(const Game *g, int p, int from, int to)
 {
     if (from == to || !game_ship_movable(g, p, from)) return false;
     static Game tmp;                         /* sin el barco que se mueve */
     tmp = *g;
     tmp.eown[from] = -1;
     tmp.ship[from] = 0;
     return game_can_ship(&tmp, p, to, false);
 }
 
 bool game_can_city(const Game *g, int p, int v)
 {
     return v >= 0 && v < game_topo(g)->nvert && g->vown[v] == p && g->vlev[v] == 1;
 }
 
 static bool any_road(const Game *g, int p)
 {
     for (int e = 0; e < game_topo(g)->nedge; e++)
         if (game_can_road(g, p, e)) return true;
     return false;
 }
 
 bool game_neutral_possible(const Game *g, int kind)
 {
     for (int n = 0; n < g->o.np; n++) {
         if (!g->p[n].neutral) continue;
         if (kind == NEED_SETTLE) {
             if (g->p[n].settles == 0) continue;
             for (int v = 0; v < game_topo(g)->nvert; v++)
                 if (game_can_settle(g, n, v, false)) return true;
         } else if (g->p[n].roads > 0 && any_road(g, n)) {
             return true;
         }
     }
     return false;
 }
 
 /* ------------------------------------------------------------------- ladron */
 
 static bool friendly_blocked(const Game *g, int p, int h)
 {
     const Topo *t = game_topo(g);
     if (g->terrain[h] == T_DESERT) return false;
     for (int k = 0; k < 6; k++) {
         int o = g->vown[t->hex_vert[h][k]];
         if (o >= 0 && o != p && !g->p[o].neutral && game_vp_public(g, o) <= 2) return true;
     }
     return false;
 }
 
 bool game_can_robber(const Game *g, int p, int h)
 {
     if (h < 0 || h >= game_topo(g)->nhex || h == g->robber) return false;
     if (!ter_land(g->terrain[h])) return h != g->pirate;     /* al mar va el pirata */
     if (!g->o.friendly_robber || !friendly_blocked(g, p, h)) return true;
     /* si la regla amistosa bloquea todo, no se aplica */
     for (int i = 0; i < game_topo(g)->nhex; i++)
         if (i != g->robber && !friendly_blocked(g, p, i)) return false;
     return true;
 }
 
 bool game_robber_victim_ok(const Game *g, int p, int h, int victim)
 {
     const Topo *t = game_topo(g);
     bool any = false, found = false;
     bool sea = !ter_land(g->terrain[h]);      /* el pirata le roba a los barcos de alrededor */
     for (int k = 0; k < 6; k++) {
         int e = t->hex_edge[h][k];
         int o = sea ? (g->ship[e] ? g->eown[e] : -1) : g->vown[t->hex_vert[h][k]];
         if (o < 0 || o == p || g->p[o].neutral || hand_size(g, o) == 0) continue;
         any = true;
         if (o == victim) found = true;
     }
     return any ? found : victim < 0;
 }
 
 /* ---------------------------------------------------------- camino y ejercito */
 
 /* camino comercial: rutas y barcos; cambiar de uno a otro solo en un edificio propio */
 static int road_dfs(const Game *g, int p, int v, uint8_t *used, bool first, int prev_ship)
 {
     const Topo *t = game_topo(g);
     if (!first && g->vown[v] >= 0 && g->vown[v] != p) return 0;
     int best = 0;
     for (int k = 0; k < 3; k++) {
         int e = t->vert_edge[v][k];
         if (e < 0 || used[e] || g->eown[e] != p) continue;
         if (!first && g->vown[v] != p && g->ship[e] != prev_ship) continue;
         used[e] = 1;
         int u = t->edge_v[e][0] == v ? t->edge_v[e][1] : t->edge_v[e][0];
         int l = 1 + road_dfs(g, p, u, used, false, g->ship[e]);
         used[e] = 0;
         if (l > best) best = l;
     }
     return best;
 }
 
 int game_road_len(const Game *g, int p)
 {
     const Topo *t = game_topo(g);
     uint8_t used[NEDGE];
     memset(used, 0, sizeof used);
     int best = 0;
     for (int v = 0; v < t->nvert; v++) {
         bool mine = false;
         for (int k = 0; k < 3; k++) {
             int e = t->vert_edge[v][k];
             if (e >= 0 && g->eown[e] == p) mine = true;
         }
         if (!mine) continue;
         int l = road_dfs(g, p, v, used, true, 0);
         if (l > best) best = l;
     }
     return best;
 }
 
 static void update_longest(Game *g)
 {
     int m = 0;
     for (int p = 0; p < g->o.np; p++) {
         g->p[p].road_len = (uint8_t)game_road_len(g, p);
         if (!g->p[p].neutral && g->p[p].road_len > m) m = g->p[p].road_len;
     }
     int h = g->longest;
     if (h >= 0 && g->p[h].road_len == m && m >= 5) return;
     if (m < 5) { g->longest = -1; return; }
     int who = -1, cnt = 0;
     for (int p = 0; p < g->o.np; p++)
         if (!g->p[p].neutral && g->p[p].road_len == m) { who = p; cnt++; }
     g->longest = (int8_t)(cnt == 1 ? who : -1);
 }
 
 static void update_army(Game *g, int p)
 {
     if (g->p[p].knights >= 3 && (g->army < 0 || g->p[p].knights > g->p[g->army].knights))
         g->army = (int8_t)p;
 }
 
 /* ----------------------------------------------------------------- recursos */
 
 bool game_can_afford(const Game *g, int p, const uint8_t cost[NRES])
 {
     for (int r = 0; r < NRES; r++)
         if (g->p[p].res[r] < cost[r]) return false;
     return true;
 }
 
 static void pay(Game *g, int p, const uint8_t cost[NRES])
 {
     for (int r = 0; r < NRES; r++) {
         g->p[p].res[r] -= cost[r];
         g->bank[r] += cost[r];
     }
 }
 
 static void take_bank(Game *g, int p, int r, int n)
 {
     if (n > g->bank[r]) n = g->bank[r];
     g->bank[r] -= (uint8_t)n;
     g->p[p].res[r] += (uint8_t)n;
 }
 
 static void transfer(Game *g, int from, int to, int r, int n)
 {
     if (n > g->p[from].res[r]) n = g->p[from].res[r];
     g->p[from].res[r] -= (uint8_t)n;
     g->p[to].res[r] += (uint8_t)n;
 }
 
 int game_bank_ratio(const Game *g, int p, int res)
 {
     const Topo *t = game_topo(g);
     int best = 4;
     for (int i = 0; i < t->nport; i++) {
         int e = t->port_edge[i];
         if (g->vown[t->edge_v[e][0]] != p && g->vown[t->edge_v[e][1]] != p) continue;
         if (g->port[i] == res) return 2;
         if (g->port[i] == PORT_ANY) best = 3;
     }
     return best;
 }
 
 static void produce(Game *g, int roll)
 {
     const Topo *t = game_topo(g);
     uint8_t want[MAXP][NRES];
     memset(want, 0, sizeof want);
     for (int h = 0; h < t->nhex; h++) {
         if (g->num[h] != roll || h == g->robber) continue;
         bool gold = g->terrain[h] == T_GOLD;
         if (!gold && !ter_res(g->terrain[h])) continue;
         for (int k = 0; k < 6; k++) {
             int v = t->hex_vert[h][k], o = g->vown[v];
             if (o < 0 || g->p[o].neutral) continue;
             if (gold) g->p[o].gold = (uint8_t)(g->p[o].gold + g->vlev[v]);   /* elige despues (PH_GOLD) */
             else want[o][g->terrain[h]] += g->vlev[v];
         }
     }
     for (int r = 0; r < NRES; r++) {
         int total = 0, who = -1, cnt = 0;
         for (int p = 0; p < g->o.np; p++)
             if (want[p][r]) { total += want[p][r]; who = p; cnt++; }
         if (!total) continue;
         if (total <= g->bank[r]) {
             for (int p = 0; p < g->o.np; p++) take_bank(g, p, r, want[p][r]);
         } else if (cnt == 1) {
             take_bank(g, who, r, g->bank[r]);    /* uno solo: se lleva lo que queda */
         }
     }
 }
 
 static void start_seven(Game *g)
 {
     bool any = false;
     for (int p = 0; p < g->o.np; p++) {
         int n = hand_size(g, p);
         g->p[p].discard = n > 7 ? (uint8_t)(n / 2) : 0;
         if (g->p[p].discard) any = true;
     }
     g->phase = any ? PH_DISCARD : PH_ROBBER;
 }
 
 static void use_dev(Game *g, int p, int d)
 {
     Player *pl = &g->p[p];
     if (pl->dev[d]) pl->dev[d]--;
     else if (pl->dev_hidden) pl->dev_hidden--;
     g->dev_played = 1;
 }
 
 /* Tras construir una ruta o pueblo en la variante 2p: construccion neutral. */
 static void maybe_neutral(Game *g, int p, int kind, int next_phase)
 {
     g->phase = (uint8_t)next_phase;
     if (!g->o.variant2p || g->p[p].neutral) return;
     if (kind == NEED_SETTLE && !game_neutral_possible(g, NEED_SETTLE)) kind = NEED_ROAD;
     if (!game_neutral_possible(g, kind)) return;
     g->neutral_need = (uint8_t)kind;
     g->ret_phase = (uint8_t)next_phase;
     g->phase = PH_NEUTRAL;
 }
 
 static bool any_ship(const Game *g, int p)
 {
     if (!g->p[p].ships) return false;
     for (int e = 0; e < game_topo(g)->nedge; e++)
         if (game_can_ship(g, p, e, false)) return true;
     return false;
 }
 
 static int after_free_road(const Game *g)
 {
     int p = g->cur;
     bool more = (g->p[p].roads > 0 && any_road(g, p)) || any_ship(g, p);
     return g->free_roads > 0 && more ? PH_ROADBUILD : PH_MAIN;
 }
 
 static bool adj_desert(const Game *g, int v)
 {
     const Topo *t = game_topo(g);
     for (int k = 0; k < 3; k++) {
         int h = t->vert_hex[v][k];
         if (h >= 0 && g->terrain[h] == T_DESERT) return true;
     }
     return false;
 }
 
 /* --------------------------------------------------------------- validacion */
 
 static bool res_valid(const uint8_t r[NRES], const uint8_t have[NRES])
 {
     for (int i = 0; i < NRES; i++)
         if (r[i] > have[i]) return false;
     return true;
 }
 
 static int check_dev(const Game *g, int p, int d)
 {
     if (p != g->cur) return E_TURN;
     if (g->dev_played) return E_DEVPLAYED;
     if (g->p[p].dev[d] == 0) return E_NODEV;
     return E_OK;
 }
 
 /* construir, comprar y cambiar con el banco: en el turno propio o en el de pareja */
 static bool build_phase(const Game *g) { return g->phase == PH_MAIN || g->phase == PH_PAIRED; }
 
 int game_check(const Game *g, const Move *m)
 {
     int p = m->p;
     if (p < 0 || p >= g->o.np) return E_ARGS;
     if (g->phase == PH_OVER) return E_PHASE;
     const Player *pl = &g->p[p];
     const Topo *t = game_topo(g);
 
     switch (m->type) {
     case M_SETTLE:
         if (p != g->cur) return E_TURN;
         if (g->phase == PH_SETUP) {
             if (g->setup_sub != 0) return E_PHASE;
             return game_can_settle(g, p, m->a, true) ? E_OK : E_PLACE;
         }
         if (!build_phase(g)) return E_PHASE;
         if (!pl->settles) return E_PIECES;
         if (!game_can_afford(g, p, COST_SETTLE)) return E_RES;
         return game_can_settle(g, p, m->a, false) ? E_OK : E_PLACE;
 
     case M_ROAD:
         if (p != g->cur) return E_TURN;
         if (m->a < 0 || m->a >= game_topo(g)->nedge) return E_ARGS;
         if (!pl->roads) return E_PIECES;
         if (g->phase == PH_SETUP) {
             if (g->setup_sub != 1) return E_PHASE;
             if (g->eown[m->a] >= 0 || (game_has_sea(g) && !edge_land(g, m->a))) return E_PLACE;
             return (t->edge_v[m->a][0] == g->setup_v || t->edge_v[m->a][1] == g->setup_v) ? E_OK : E_PLACE;
         }
         if (g->phase == PH_ROADBUILD) return game_can_road(g, p, m->a) ? E_OK : E_PLACE;
         if (!build_phase(g)) return E_PHASE;
         if (!game_can_afford(g, p, COST_ROAD)) return E_RES;
         return game_can_road(g, p, m->a) ? E_OK : E_PLACE;
 
     case M_SHIP:
         if (p != g->cur) return E_TURN;
         if (m->a < 0 || m->a >= t->nedge) return E_ARGS;
         if (!pl->ships) return E_PIECES;
         if (g->phase == PH_SETUP) {
             if (g->setup_sub != 1) return E_PHASE;
             return game_can_ship(g, p, m->a, true) ? E_OK : E_PLACE;
         }
         if (g->phase == PH_ROADBUILD) return game_can_ship(g, p, m->a, false) ? E_OK : E_PLACE;
         if (!build_phase(g)) return E_PHASE;
         if (!game_can_afford(g, p, COST_SHIP)) return E_RES;
         return game_can_ship(g, p, m->a, false) ? E_OK : E_PLACE;
 
     case M_MOVESHIP:
         if (p != g->cur) return E_TURN;
         if (g->phase != PH_MAIN) return E_PHASE;
         if (g->ship_moved) return E_PIECES;
         return game_can_moveship(g, p, m->a, m->b) ? E_OK : E_PLACE;
 
     case M_GOLD: {
         if (g->phase != PH_GOLD) return E_PHASE;
         if (!pl->gold) return E_TURN;
         if (res_total(m->r) != pl->gold) return E_ARGS;
         for (int r = 0; r < NRES; r++) if (m->r[r] > g->bank[r]) return E_BANK;
         return E_OK;
     }
 
     case M_CITY:
         if (p != g->cur) return E_TURN;
         if (!build_phase(g)) return E_PHASE;
         if (!pl->cities) return E_PIECES;
         if (!game_can_afford(g, p, COST_CITY)) return E_RES;
         return game_can_city(g, p, m->a) ? E_OK : E_PLACE;
 
     case M_ROLL:
         if (p != g->cur) return E_TURN;
         return g->phase == PH_ROLL ? E_OK : E_PHASE;
 
     case M_DISCARD:
         if (g->phase != PH_DISCARD) return E_PHASE;
         if (!pl->discard) return E_TURN;
         if (res_total(m->r) != pl->discard || !res_valid(m->r, pl->res)) return E_ARGS;
         return E_OK;
 
     case M_ROBBER:
         if (p != g->cur) return E_TURN;
         if (g->phase != PH_ROBBER) return E_PHASE;
         if (!game_can_robber(g, p, m->a)) return E_ROBBER;
         return game_robber_victim_ok(g, p, m->a, m->b) ? E_OK : E_ARGS;
 
     case M_BUYDEV:
         if (p != g->cur) return E_TURN;
         if (!build_phase(g)) return E_PHASE;
         if (!g->deck_n) return E_BANK;
         return game_can_afford(g, p, COST_DEV) ? E_OK : E_RES;
 
     case M_KNIGHT:
         if (g->phase != PH_ROLL && g->phase != PH_MAIN) return E_PHASE;
         return check_dev(g, p, D_KNIGHT);
 
     case M_ROADS:
         if (g->phase != PH_MAIN) return E_PHASE;
         if (!pl->roads) return E_PIECES;
         return check_dev(g, p, D_ROADS);
 
     case M_PLENTY: {
         if (g->phase != PH_MAIN) return E_PHASE;
         int e = check_dev(g, p, D_PLENTY);
         if (e) return e;
         if (m->a < 0 || m->a >= NRES || m->b < 0 || m->b >= NRES) return E_ARGS;
         if (m->a == m->b ? g->bank[m->a] < 2 : (!g->bank[m->a] || !g->bank[m->b])) return E_BANK;
         return E_OK;
     }
 
     case M_MONO:
         if (g->phase != PH_MAIN) return E_PHASE;
         if (m->a < 0 || m->a >= NRES) return E_ARGS;
         return check_dev(g, p, D_MONO);
 
     case M_BANK: {
         if (p != g->cur) return E_TURN;
         if (!build_phase(g)) return E_PHASE;
         if (m->a < 0 || m->a >= NRES || m->b < 0 || m->b >= NRES || m->a == m->b || m->c < 1) return E_ARGS;
         if (pl->res[m->a] < game_bank_ratio(g, p, m->a) * m->c) return E_RES;
         return g->bank[m->b] >= m->c ? E_OK : E_BANK;
     }
 
     case M_OFFER:
         if (p != g->cur) return E_TURN;
         if (g->phase != PH_MAIN) return E_PHASE;
         if (!res_total(m->r) || !res_total(m->r2)) return E_ARGS;
         for (int r = 0; r < NRES; r++)
             if (m->r[r] && m->r2[r]) return E_ARGS;
         if (m->a != -1 && (m->a <= 0 || (m->a & ~game_offer_candidates(g, p)))) return E_ARGS;
         return res_valid(m->r, pl->res) ? E_OK : E_RES;
 
     case M_ACCEPT:
         if (!g->offer.active || g->phase != PH_MAIN) return E_OFFER;
         if (p == g->offer.from || pl->neutral) return E_TURN;
         if (!((g->offer.tomask >> p) & 1)) return E_TURN;
         return res_valid(g->offer.get, pl->res) ? E_OK : E_RES;
 
     case M_REJECT:
         if (!g->offer.active) return E_OFFER;
         return (p != g->offer.from && !pl->neutral) ? E_OK : E_TURN;
 
     case M_CONFIRM: {
         if (!g->offer.active || g->phase != PH_MAIN) return E_OFFER;
         if (p != g->offer.from) return E_TURN;
         if (m->a < 0 || m->a >= g->o.np) return E_OFFER;
         int q = m->a, rs = g->offer.resp[q];
         if (rs == 1)
             return res_valid(g->offer.give, pl->res) && res_valid(g->offer.get, g->p[q].res) ? E_OK : E_RES;
         if (rs == 2)      /* con los terminos de la contraoferta */
             return res_valid(g->offer.cget[q], pl->res) && res_valid(g->offer.cgive[q], g->p[q].res) ? E_OK : E_RES;
         return E_OFFER;
     }
 
     case M_COUNTER:
         if (!g->offer.active || g->phase != PH_MAIN) return E_OFFER;
         if (p == g->offer.from || pl->neutral || !((g->offer.tomask >> p) & 1)) return E_TURN;
         if (!res_total(m->r) || !res_total(m->r2)) return E_ARGS;
         for (int r = 0; r < NRES; r++)
             if (m->r[r] && m->r2[r]) return E_ARGS;
         return res_valid(m->r, pl->res) ? E_OK : E_RES;
 
     case M_CANCEL:
         if (!g->offer.active) return E_OFFER;
         return p == g->offer.from ? E_OK : E_TURN;
 
     case M_END:
         if (p != g->cur) return E_TURN;
         return (g->phase == PH_MAIN || g->phase == PH_ROADBUILD || g->phase == PH_PAIRED) ? E_OK : E_PHASE;
 
     case M_NEUTRAL: {
         int n = m->a;
         if (!game_is_neutral(g, n) || (m->b != 0 && m->b != 1)) return E_ARGS;
         const Player *np = &g->p[n];
         if (g->phase == PH_SETUP) {
             if (p != n || g->setup_i != 0 || g->setup_sub != 0) return E_PHASE;
             int placed = MAX_SETTLES - np->settles, roads = MAX_ROADS - np->roads;
             if (m->b == 1) {
                 if (placed >= g->o.neutral_setup) return E_PIECES;
                 return game_can_settle(g, n, m->c, true) ? E_OK : E_PLACE;
             }
             if (roads >= placed) return E_PIECES;
             return game_can_road(g, n, m->c) ? E_OK : E_PLACE;
         }
         if (g->phase != PH_NEUTRAL) return E_PHASE;
         if (p != g->cur) return E_TURN;
         if (m->b == 1) {
             if (g->neutral_need != NEED_SETTLE || !np->settles) return E_ARGS;
             return game_can_settle(g, n, m->c, false) ? E_OK : E_PLACE;
         }
         if (g->neutral_need == NEED_SETTLE && game_neutral_possible(g, NEED_SETTLE)) return E_ARGS;
         if (!np->roads) return E_PIECES;
         return game_can_road(g, n, m->c) ? E_OK : E_PLACE;
     }
 
     case M_TOKTRADE:
         if (!g->o.variant2p) return E_PHASE;
         if (p != g->cur) return E_TURN;
         if (g->phase != PH_MAIN) return E_PHASE;
         return pl->tokens >= game_token_cost(g, p) ? E_OK : E_TOKENS;
 
     case M_GIVEBACK:
         if (p != g->cur) return E_TURN;
         if (g->phase != PH_GIVEBACK) return E_PHASE;
         if (res_total(m->r) != g->give_back || !res_valid(m->r, pl->res)) return E_ARGS;
         return E_OK;
 
     case M_TOKROBBER:
         if (!g->o.variant2p) return E_PHASE;
         if (p != g->cur) return E_TURN;
         if (g->phase != PH_ROLL && g->phase != PH_MAIN) return E_PHASE;
         if (g->terrain[g->robber] == T_DESERT) return E_ROBBER;
         return pl->tokens >= game_token_cost(g, p) ? E_OK : E_TOKENS;
 
     case M_WIN:
         return E_OK;
 
     case M_UNDO:
         if (p != g->cur) return E_TURN;
         if (g->phase != PH_MAIN && g->phase != PH_NEUTRAL && g->phase != PH_ROADBUILD && g->phase != PH_PAIRED) return E_PHASE;
         return g->undo_n ? E_OK : E_PHASE;
     }
     return E_ARGS;
 }
 
 /* ---------------------------------------------------------------- aplicacion */
 
 int game_pair(const Game *g, int p)
 {
     if (game_topo(g)->family != BF_LARGE || g->o.np < 5) return -1;
     int q = (p + 3) % g->o.np;
     return g->p[q].neutral ? -1 : q;
 }
 
 /* la pareja juega solo si algo le alcanza: construir, comprar o cambiar con el banco */
 static bool pair_can_act(const Game *g, int q)
 {
     const Player *pl = &g->p[q];
     if (pl->roads && game_can_afford(g, q, COST_ROAD) && any_road(g, q)) return true;
     if (pl->cities && game_can_afford(g, q, COST_CITY))
         for (int v = 0; v < game_topo(g)->nvert; v++) if (game_can_city(g, q, v)) return true;
     if (pl->settles && game_can_afford(g, q, COST_SETTLE))
         for (int v = 0; v < game_topo(g)->nvert; v++) if (game_can_settle(g, q, v, false)) return true;
     if (g->deck_n && game_can_afford(g, q, COST_DEV)) return true;
     for (int r = 0; r < NRES; r++) if (pl->res[r] >= game_bank_ratio(g, q, r)) return true;
     return false;
 }
 
 void game_apply(Game *g, const Move *m)
 {
     const Topo *t = game_topo(g);
     int p = m->p;
     Player *pl = &g->p[p];
     g->nmoves++;
 
     if (game_undoable(g, m)) { if (g->undo_n < UNDO_MAX) g->undo_n++; }
     else if (m->type != M_OFFER && m->type != M_ACCEPT && m->type != M_REJECT && m->type != M_CANCEL && m->type != M_COUNTER)
         g->undo_n = 0;
 
     /* si quien ofrecio hace cualquier otra cosa, la oferta se retira */
     if (g->offer.active && p == g->offer.from &&
         m->type != M_OFFER && m->type != M_CONFIRM && m->type != M_CANCEL)
         g->offer.active = 0;
 
     switch (m->type) {
     case M_SETTLE:
         g->vown[m->a] = (int8_t)p;
         g->vlev[m->a] = 1;
         pl->settles--;
         if (g->phase == PH_SETUP) {
             g->setup_v = (int16_t)m->a;
             g->setup_sub = 1;
             if (setup_second(g, p))
                 for (int k = 0; k < 3; k++) {
                     int h = t->vert_hex[m->a][k];
                     if (h >= 0 && ter_res(g->terrain[h])) take_bank(g, p, g->terrain[h], 1);
                 }
             if (g->o.variant2p && adj_desert(g, m->a)) pl->tokens++;
             for (int k = 0; k < 3; k++) {      /* Navegantes: las islas donde arranca no dan puntos */
                 int h = t->vert_hex[m->a][k], r = h >= 0 ? t->region[h] : -1;
                 if (r >= 0 && r < 8) pl->isles |= (uint8_t)(1 << r);
             }
             update_longest(g);
             break;
         }
         pay(g, p, COST_SETTLE);
         if (g->o.variant2p && adj_desert(g, m->a)) pl->tokens++;
         for (int k = 0; k < 3 && t->sea; k++) {    /* Navegantes: primer pueblo en una isla nueva, +2 */
             int h = t->vert_hex[m->a][k], r = h >= 0 ? t->region[h] : -1;
             if (r >= 0 && r < 8 && !((pl->isles >> r) & 1)) { pl->isles |= (uint8_t)(1 << r); pl->bonus += 2; }
         }
         update_longest(g);
         maybe_neutral(g, p, NEED_SETTLE, g->phase == PH_PAIRED ? PH_PAIRED : PH_MAIN);
         break;
 
     case M_ROAD:
         g->eown[m->a] = (int8_t)p;
         pl->roads--;
         if (g->phase == PH_SETUP) {
             g->setup_sub = 0;
             g->setup_v = -1;
             g->setup_i++;
             if (g->setup_i >= g->setup_n) {
                 g->phase = PH_ROLL;
                 g->cur = g->setup_order[0];
             } else {
                 g->cur = g->setup_order[g->setup_i];
             }
             update_longest(g);
             break;
         }
         if (g->phase == PH_ROADBUILD) {
             if (g->free_roads) g->free_roads--;
             update_longest(g);
             maybe_neutral(g, p, NEED_ROAD, after_free_road(g));
             break;
         }
         pay(g, p, COST_ROAD);
         update_longest(g);
         maybe_neutral(g, p, NEED_ROAD, g->phase == PH_PAIRED ? PH_PAIRED : PH_MAIN);
         break;
 
     case M_SHIP:
         g->eown[m->a] = (int8_t)p;
         g->ship[m->a] = 1;
         pl->ships--;
         g->ship_new[m->a / 8] |= (uint8_t)(1 << (m->a % 8));
         if (g->phase == PH_SETUP) {
             g->setup_sub = 0;
             g->setup_v = -1;
             g->setup_i++;
             if (g->setup_i >= g->setup_n) { g->phase = PH_ROLL; g->cur = g->setup_order[0]; }
             else g->cur = g->setup_order[g->setup_i];
             update_longest(g);
             break;
         }
         if (g->phase == PH_ROADBUILD) {
             if (g->free_roads) g->free_roads--;
             update_longest(g);
             g->phase = (uint8_t)after_free_road(g);
             break;
         }
         pay(g, p, COST_SHIP);
         update_longest(g);
         break;
 
     case M_MOVESHIP:
         g->eown[m->a] = -1;
         g->ship[m->a] = 0;
         g->eown[m->b] = (int8_t)p;
         g->ship[m->b] = 1;
         g->ship_moved = 1;
         update_longest(g);
         break;
 
     case M_GOLD: {
         for (int r = 0; r < NRES; r++) take_bank(g, p, r, m->r[r]);
         pl->gold = 0;
         bool left = false;
         for (int q = 0; q < g->o.np; q++) if (g->p[q].gold) left = true;
         if (!left) g->phase = PH_MAIN;
         break;
     }
 
     case M_CITY:
         g->vlev[m->a] = 2;
         pl->cities--;
         pl->settles++;
         pay(g, p, COST_CITY);
         break;
 
     case M_ROLL: {
         for (int i = 0; i < 4; i++) g->dice[i] = m->r[i];
         g->rolled = 1;
         int s1 = m->r[0] + m->r[1], s2 = m->r[2] + m->r[3];
         bool seven = s1 == 7;
         if (s1 != 7) produce(g, s1);
         if (s2) {
             if (s2 == 7) seven = true;
             else produce(g, s2);
         }
         if (seven) start_seven(g);
         else g->phase = PH_MAIN;
         if (!seven) {                         /* oro: cada uno elige, si el banco tiene */
             int bank = 0;
             for (int r = 0; r < NRES; r++) bank += g->bank[r];
             bool any = false;
             for (int q = 0; q < g->o.np; q++) {
                 if (g->p[q].gold > bank) g->p[q].gold = (uint8_t)bank;
                 if (g->p[q].gold) any = true;
             }
             if (any) g->phase = PH_GOLD;
         }
         break;
     }
 
     case M_DISCARD: {
         for (int r = 0; r < NRES; r++) {
             pl->res[r] -= m->r[r];
             g->bank[r] += m->r[r];
         }
         pl->discard = 0;
         bool left = false;
         for (int q = 0; q < g->o.np; q++)
             if (g->p[q].discard) left = true;
         if (!left) g->phase = PH_ROBBER;
         break;
     }
 
     case M_ROBBER:
         if (ter_land(g->terrain[m->a])) g->robber = (uint8_t)m->a;
         else g->pirate = (uint8_t)m->a;
         if (m->b >= 0 && m->c >= 0) transfer(g, m->b, p, m->c, 1);
         g->phase = g->rolled ? PH_MAIN : PH_ROLL;
         break;
 
     case M_BUYDEV:
         pay(g, p, COST_DEV);
         if (g->deck_n) g->deck_n--;
         if (m->a >= 0 && m->a < NDEV) pl->dev_new[m->a]++;
         else pl->dev_hidden++;
         break;
 
     case M_KNIGHT:
         use_dev(g, p, D_KNIGHT);
         pl->knights++;
         if (g->o.variant2p) pl->tokens++;
         update_army(g, p);
         g->phase = PH_ROBBER;
         break;
 
     case M_ROADS:
         use_dev(g, p, D_ROADS);
         g->free_roads = 2;
         g->phase = (uint8_t)after_free_road(g);
         break;
 
     case M_PLENTY:
         use_dev(g, p, D_PLENTY);
         take_bank(g, p, m->a, 1);
         take_bank(g, p, m->b, 1);
         break;
 
     case M_MONO:
         use_dev(g, p, D_MONO);
         for (int q = 0; q < g->o.np; q++)
             if (q != p) transfer(g, q, p, m->a, g->p[q].res[m->a]);
         break;
 
     case M_BANK: {
         int n = game_bank_ratio(g, p, m->a) * m->c;
         pl->res[m->a] -= (uint8_t)n;
         g->bank[m->a] += (uint8_t)n;
         take_bank(g, p, m->b, m->c);
         break;
     }
 
     case M_OFFER:
         if (g->offers < 255) g->offers++;
         memset(&g->offer, 0, sizeof g->offer);
         g->offer.active = 1;
         g->offer.from = (uint8_t)p;
         g->offer.tomask = m->a == -1 ? game_offer_candidates(g, p) : (uint8_t)m->a;
         memcpy(g->offer.give, m->r, NRES);
         memcpy(g->offer.get, m->r2, NRES);
         break;
 
     case M_ACCEPT: g->offer.resp[p] = 1; break;
     case M_REJECT: g->offer.resp[p] = -1; break;
 
     case M_CONFIRM: {
         bool counter = g->offer.resp[m->a] == 2;
         for (int r = 0; r < NRES; r++) {
             transfer(g, p, m->a, r, counter ? g->offer.cget[m->a][r] : g->offer.give[r]);
             transfer(g, m->a, p, r, counter ? g->offer.cgive[m->a][r] : g->offer.get[r]);
         }
         g->offer.active = 0;
         break;
     }
 
     case M_COUNTER:
         g->offer.resp[p] = 2;
         memcpy(g->offer.cgive[p], m->r, NRES);
         memcpy(g->offer.cget[p], m->r2, NRES);
         break;
 
     case M_CANCEL: g->offer.active = 0; break;
 
     case M_END:
         if (g->phase == PH_ROADBUILD) {
             g->free_roads = 0;
             g->phase = PH_MAIN;
             break;
         }
         g->offer.active = 0;
         for (int d = 0; d < NDEV; d++) {
             pl->dev[d] += pl->dev_new[d];
             pl->dev_new[d] = 0;
         }
         if (g->phase == PH_MAIN) {           /* 5-6: ahora juega la pareja, si puede hacer algo */
             int q = game_pair(g, p);
             if (q >= 0 && pair_can_act(g, q)) {
                 g->owner = (uint8_t)p;
                 g->cur = (uint8_t)q;
                 g->phase = PH_PAIRED;
                 break;
             }
         }
         if (g->phase == PH_PAIRED) p = g->owner;
         g->cur = (uint8_t)game_next_player(g, p);
         g->phase = PH_ROLL;
         g->rolled = g->dev_played = g->free_roads = g->offers = g->ship_moved = 0;
         memset(g->ship_new, 0, sizeof g->ship_new);
         memset(g->dice, 0, sizeof g->dice);
         g->turn++;
         break;
 
     case M_NEUTRAL: {
         Player *np = &g->p[m->a];
         if (m->b == 1) {
             g->vown[m->c] = (int8_t)m->a;
             g->vlev[m->c] = 1;
             np->settles--;
         } else {
             g->eown[m->c] = (int8_t)m->a;
             np->roads--;
         }
         update_longest(g);
         if (g->phase == PH_NEUTRAL) {
             g->neutral_need = NEED_NONE;
             g->phase = g->ret_phase;
             if (g->phase == PH_ROADBUILD) g->phase = (uint8_t)after_free_road(g);
         }
         break;
     }
 
     case M_TOKTRADE: {
         int r = game_rival(g, p);
         pl->tokens -= (uint8_t)game_token_cost(g, p);
         g->give_back = 0;
         if (r >= 0) {
             if (m->a >= 0) { transfer(g, r, p, m->a, 1); g->give_back++; }
             if (m->b >= 0) { transfer(g, r, p, m->b, 1); g->give_back++; }
         }
         if (g->give_back) g->phase = PH_GIVEBACK;
         break;
     }
 
     case M_GIVEBACK: {
         int r = game_rival(g, p);
         for (int i = 0; i < NRES; i++) transfer(g, p, r, i, m->r[i]);
         g->give_back = 0;
         g->phase = PH_MAIN;
         break;
     }
 
     case M_TOKROBBER:
         pl->tokens -= (uint8_t)game_token_cost(g, p);
         g->robber = (uint8_t)desert_hex(g);
         break;
 
     case M_WIN: {
         int known = pl->dev[D_VP] + pl->dev_new[D_VP];
         if (m->a > known) {
             int extra = m->a - known;
             if (extra > pl->dev_hidden) extra = pl->dev_hidden;
             pl->dev_hidden -= (uint8_t)extra;
             pl->dev[D_VP] += (uint8_t)extra;
         }
         g->winner = (int8_t)p;
         if (!g->o.freeplay) g->phase = PH_OVER;
         break;
     }
     }
 }
 
 bool game_undoable(const Game *g, const Move *m)
 {
     if (m->p != g->cur) return false;
     switch (m->type) {
     case M_ROAD: case M_SHIP: return g->phase == PH_MAIN || g->phase == PH_ROADBUILD || g->phase == PH_PAIRED;
     case M_MOVESHIP: return g->phase == PH_MAIN;
     case M_SETTLE: case M_CITY: case M_BANK: return g->phase == PH_MAIN || g->phase == PH_PAIRED;
     case M_NEUTRAL: return g->phase == PH_NEUTRAL;
     }
     return false;
 }
 
 void game_apply_u(Game *g, Undo *u, const Move *m)
 {
     if (m->type == M_UNDO) {
         if (u->n) {
             uint32_t nm = g->nmoves;
             *g = u->snap[--u->n];
             g->nmoves = nm + 1;
         }
         return;
     }
     if (game_undoable(g, m)) {
         if (u->n == UNDO_MAX) {           /* se olvida la mas vieja */
             memmove(&u->snap[0], &u->snap[1], sizeof(Game) * (UNDO_MAX - 1));
             u->n--;
             for (int i = 0; i < u->n; i++) u->snap[i].undo_n--;
         }
         g->undo_n = u->n;
         u->snap[u->n++] = *g;
     } else if (m->type != M_OFFER && m->type != M_ACCEPT && m->type != M_REJECT && m->type != M_CANCEL && m->type != M_COUNTER) {
         u->n = 0;
     }
     game_apply(g, m);
 }
 
 /* ¿seat tiene que (o puede) hacer algo ahora? */
 bool game_needs(const Game *g, int seat)
 {
     if (seat < 0 || seat >= g->o.np || g->phase == PH_OVER || g->p[seat].neutral) return false;
     if (g->phase == PH_DISCARD) return g->p[seat].discard > 0;
     if (g->phase == PH_GOLD) return g->p[seat].gold > 0;
     if (g->offer.active && seat != g->offer.from && ((g->offer.tomask >> seat) & 1) && g->offer.resp[seat] == 0)
         return true;
     return seat == g->cur;
 }