Beispiel #1
0
int
result_check_sufurenta (global_t *gp)
{
  if (cur_player == 3 && rvp == &rv[3][0]
      && (P_KIND (rvp->out) >= K_TON) && (P_KIND (rvp->out) <= K_PEI)
      && (P_KIND (rvp->out) == P_KIND (rv[0][0].out))
      && (P_KIND (rvp->out) == P_KIND (rv[1][0].out))
      && (P_KIND (rvp->out) == P_KIND (rv[2][0].out))
      && (T_GET (rv[0][0].attr) == T_RV || T_GET (rv[0][0].attr) == T_RV_RCH)
      && (T_GET (rv[1][0].attr) == T_RV || T_GET (rv[1][0].attr) == T_RV_RCH)
      && (T_GET (rv[2][0].attr) == T_RV || T_GET (rv[2][0].attr) == T_RV_RCH)
      && (T_GET (rv[3][0].attr) == T_RV || T_GET (rv[3][0].attr) == T_RV_RCH)
      && R_GET (rv[0][0].attr) == R_NUL
      && R_GET (rv[1][0].attr) == R_NUL
      && R_GET (rv[2][0].attr) == R_NUL && R_GET (rv[3][0].attr) == R_NUL)
    return 1;
  return 0;
}
Beispiel #2
0
int
result_check_kyushukyupai (global_t *gp)
{
  int i;

  if (rv_cur[cur_player] != 0)
    return 0;
  for (i = 0; i < cur_player; i++)
    {
      if ((T_GET (rv[i][0].attr) != T_RV) || R_GET (rv[i][0].attr) != R_NUL)
        return 0;
    }
  return hand_check_kyushukyupai (gp, cur_player);
}
Beispiel #3
0
int
result_check_nagasimangan (global_t *gp, int p)
{
  int i;
  for (i = 0; i <= rv_cur[p]; i++)
    {
      if (rv[p][i].out)
        {
          if (!IS_YAO (P_KIND (rv[p][i].out))
              || T_GET (rv[p][i].attr) != T_RV
              || R_GET (rv[p][i].attr) != R_NUL)
            return 0;
        }
    }
  return 1;
}
Beispiel #4
0
//str_end points right after the last char of str, the '\0' char
static s8 match(void *p,void *str,void *str_end,u8 flgs,
                                                  struct match_params *end_star)
{
  u8 *pc=p;
  u8 *sc=str;
  u8 c;

  while(1){
    c=*pc++;
    if(c=='\0') break;

    c=fold(c,flgs);

    u16 r;
    switch(c){
    case '[': case '*': case '?': case '+': case '@': case '!': case '\\':
      r=special_char(&c,&pc,&sc,str_end,flgs,end_star);
      break;
    default:
      r=MATCH_NORMAL;
    }

    if(!(r&NEXT_STR_CHAR)){
     if(r&RETURN_R) return R_GET(r);
     if(r&NEXT_P_CHAR) continue;
     if((r&MATCH_NORMAL)||(r&TEST_STR_END_REACHED))
       if(sc==str_end) return NOMATCH;
     if(r&MATCH_NORMAL)
       if(c!=fold(*sc,flgs)) return NOMATCH;
    }

    ++sc;
  }

  if(sc==str_end) return MATCH;
  return NOMATCH;
}
Beispiel #5
0
static void
collect_reveal_pai_info (global_t *gp)
{
  integer_t i, j, p, k;
  river_t *rp, *lastrv = 0;
  integer_t paikind;

  memset (pai_genbutu, 0, sizeof (pai_genbutu));
  memset (pai_reveal, 0, sizeof (pai_reveal));

  /* in river */
  for (p = 0; p < 4; p++)
    {
      integer_t reach = -1;
      for (i = 0; i <= rv_cur[p] && rv[p][i].out; i++)
        {
          if (T_GET (rv[p][i].attr) != T_HN_KAN_C)
            {
              paikind = P_KIND (rv[p][i].out);
              pai_genbutu[p][paikind] = 1;
            }
          if (T_GET (rv[p][i].attr) == T_RV_RCH)
            {
              reach = i;
            }
          if (R_GET (rv[p][i].attr) == R_NUL)
            {
              paikind = P_KIND (rv[p][i].out);
              pai_reveal[paikind]++;
            }
          lastrv = &rv[p][i];
        }                       /* for */

      if (reach > 0)
        {
          rp = &(rv[p][reach]);
        }
      else
        {
          rp = lastrv;
        }
#if 1
      while (rp && rp->next)
        {
          if (T_GET (rp->attr) != T_HN_KAN_C)
            {
              paikind = P_KIND (rp->out);
              pai_genbutu[p][paikind] = 1;
            }
          rp = rp->next;
        }
#endif
      /* opened furo-pai */
      for (j = 3; j >= 0; j--)
        {
          if (hand[p].opened_kind[j])
            {
              for (k = 0; k < 4; k++)
                {
                  if (k == 3 && (hand[p].opened_kind[j] == H_TIE
                                 || hand[p].opened_kind[j] == H_PON))
                    {
                      break;
                    }
                  paikind = P_KIND (hand[p].opened[j][k]);
                  pai_reveal[paikind]++;
                }
            }
        }
    }                           /* for */
/* dora */
  for (i = 0; i < 5; i++)
    {
      paikind = P_KIND (mt_dora (gp, i));
      pai_reveal[paikind]++;
    }
/* in hand */
  for (i = 0; i < hand[vself].closed_num; i++)
    {
      paikind = P_KIND (hand[vself].closed[i]);
      pai_reveal[paikind]++;
    }
}
Beispiel #6
0
int
result_calc_from_hand (global_t *gp, int p, result_t *yp)
{
  int i, j, k;
  int kinds[35], kindsr[35];
  river_t *rp;
  pai_t pai, pk;
  int man, pin, sou, ji, green;

  man = pin = sou = ji = green = 0;

  /* calc kinds */
  for (i = 0; i < 35; i++)
    kinds[i] = kindsr[i] = 0;
  for (i = 0; i < hand[p].closed_num; i++)
    {
      pai = hand[p].closed[i];
      pk = P_KIND (pai);
      kinds[pk]++;
      kindsr[pk]++;
      if (pai == K_MAN_5 * 4)
        yp->akadora += 1;
      if (pai == K_PIN_5 * 4)
        yp->akadora += 1;
      if (pai == K_SOU_5 * 4)
        yp->akadora += 1;
      if (IS_MAN (pk))
        man++;
      else if (IS_PIN (pk))
        pin++;
      else if (IS_SOU (pk))
        sou++;
      else
        ji++;
      if (IS_GREEN (pk))
        green++;
    }
  for (i = 0; i < 4; i++)
    if (k = hand[p].opened_kind[i])
      {
        for (j = 0; j < 4; j++)
          {
            pai = hand[p].opened[i][j];
            if (pai == 0)
              continue;
            pk = P_KIND (pai);
            kindsr[pk]++;
            if (j < 3)
              {
                kinds[pk]++;
                if (IS_MAN (pk))
                  man++;
                else if (IS_PIN (pk))
                  pin++;
                else if (IS_SOU (pk))
                  sou++;
                else
                  ji++;
                if (IS_GREEN (pk))
                  green++;
              }
            if (pai == K_MAN_5 * 4)
              yp->akadora += 1;
            if (pai == K_PIN_5 * 4)
              yp->akadora += 1;
            if (pai == K_SOU_5 * 4)
              yp->akadora += 1;
          }
      }

  /* reach */
  if (hand[p].reach)
    yp->reach = 1;
  /* tumo */
  if (!hand[p].naki && (cur_player == p))
    yp->tumo = 1;

  /* chankan rinshan */
  if ((cur_player != p) && (T_GET (rvp->attr) == T_HN_KAN))
    yp->chankan = 1;
  if ((cur_player == p)
      && (F_GET (rvp->attr) == F_RV_KAN || F_GET (rvp->attr) == F_MT_TOP))
    yp->rinshan = 1;
  /* haitei */
  if (mt_rest (gp) == 0)
    yp->haitei = 1;
  /* ippatu */
  rp = rvp;
  k = 0;
  for (i = 0; rp && i < 5; i++)
    {
      if (F_GET (rp->attr))
        break;
      if (T_GET (rp->attr) == T_HN_KAN)
        break;
      if (T_GET (rp->attr) == T_HN_KAN_C)
        break;
      if ((rv_find_player (gp, rp) == p) && (T_GET (rp->attr) == T_RV_RCH))
        {
          k = 1;
          break;
        }
      if (!rp->prev)
        break;
      rp = rp->prev;
    }
  if (k)
    yp->ippatu = 1;

  /* tenhou chihou renhou + double_reach */
  k = 0;
  rp = &(rv[0][0]);
  for (i = 0; i < 4; i++)
    {
      if (rp == rvp)
        {
          k = 1;
        }
      if (R_GET (rp->attr))
        break;
      if ((T_GET (rp->attr) == T_RV_RCH) && (rv_find_player (gp, rp) == p))
        yp->double_reach = 1;
      if (!rp->next || rp->next == &rv[0][0])
        break;
      rp = rp->next;
    }
  if (k)
    {
      if (rv_find_player (gp, rp) == p)
        if (p == 0)
          yp->tenhou = 1;
        else
          yp->chihou = 1;
      else if (rv_find_player (gp, rp) < p)
        yp->renhou = 1;
    }

  /* kokusi */
  if (kinds[K_MAN_1] && kinds[K_PIN_1] && kinds[K_SOU_1]
      && kinds[K_MAN_9] && kinds[K_PIN_9] && kinds[K_SOU_9]
      && kinds[K_TON] && kinds[K_NAN] && kinds[K_SHA] && kinds[K_PEI]
      && kinds[K_HAKU] && kinds[K_HATU] && kinds[K_CHUN])
    yp->kokusi = 1;
  /* chiraoutou honraotou */
  if ((kinds[K_MAN_1] + kinds[K_PIN_1] + kinds[K_SOU_1]
       + kinds[K_MAN_9] + kinds[K_PIN_9] + kinds[K_SOU_9]) == 14)
    {
      yp->chinraotou = 1;
    }
  else if ((kinds[K_MAN_1] + kinds[K_PIN_1] + kinds[K_SOU_1]
            + kinds[K_MAN_9] + kinds[K_PIN_9] + kinds[K_SOU_9]
            + kinds[K_TON] + kinds[K_NAN] + kinds[K_SHA] + kinds[K_PEI]
            + kinds[K_HAKU] + kinds[K_HATU] + kinds[K_CHUN]) == 14)
    {
      yp->honraotou = 1;
      yp->chanta = 0;
      yp->chanta_naki = 0;
    }

  /* tanyao */
  if (!(kinds[K_MAN_1] || kinds[K_PIN_1] || kinds[K_SOU_1]
        || kinds[K_MAN_9] || kinds[K_PIN_9] || kinds[K_SOU_9]
        || kinds[K_TON] || kinds[K_NAN] || kinds[K_SHA] || kinds[K_PEI]
        || kinds[K_HAKU] || kinds[K_HATU] || kinds[K_CHUN])
      && !(RL_NONAKITAN && hand[p].naki))
    yp->tanyao = 1;

  /* chinitu honitu */
  if ((man == 14) || (pin == 14) || (sou == 14))
    {
      if (hand[p].naki)
        yp->chinitu_naki = 1;
      else
        yp->chinitu = 1;
    }
  else if (ji == 14)
    {
      yp->tuisou = 1;
    }
  else if (((man + ji) == 14) || ((pin + ji) == 14) || ((sou + ji) == 14))
    {
      if (hand[p].naki)
        yp->honitu_naki = 1;
      else
        yp->honitu = 1;
    }
  if (green == 14)
    yp->ryuisou = 1;

  /* calc result hai */
  if (kinds[K_HAKU] >= 3)
    yp->haku = 1;
  if (kinds[K_HATU] >= 3)
    yp->hatu = 1;
  if (kinds[K_CHUN] >= 3)
    yp->chun = 1;
  if (kinds[K_TON + big_turn] >= 3)
    yp->bakaze = 1;
  if (kinds[K_TON + p] >= 3)
    yp->jikaze = 1;
  if ((kinds[K_HAKU] + kinds[K_HATU] + kinds[K_CHUN]) == 9)
    yp->daisangen = 1;
  if ((kinds[K_HAKU] + kinds[K_HATU] + kinds[K_CHUN]) == 8)
    yp->syosangen = 1;
  if ((kinds[K_TON] + kinds[K_NAN] + kinds[K_SHA] + kinds[K_PEI]) == 12)
    yp->daisusi = 1;
  if ((kinds[K_TON] + kinds[K_NAN] + kinds[K_SHA] + kinds[K_PEI]) == 11)
    yp->syosusi = 1;

  /* calc dora */
  for (i = 0; i < 5; i++)
    if (k = mt_dora (gp, i))
      yp->dora += kindsr[K_NEXT (P_KIND (k))];
  if (yp->reach)
    for (i = 0; i < (RL_NOKANURA ? 1 : 5); i++)
      if (k = mt_uradora (gp, i))
        yp->uradora += kindsr[K_NEXT (P_KIND (k))];
}