path: root/mbbsd/chc.c

/* $Id$ */
#include "bbs.h"
#include "chc.h"

#define assert_not_reached() assert(!"Should never be here!!!")

extern const double elo_exp_tab[1000];

enum Turn {
    BLK = 0,
    RED 
};

enum Kind {
    KIND_K=1,
    KIND_A,
    KIND_E,
    KIND_R,
    KIND_H,
    KIND_C,
    KIND_P,
};
#define CENTER(a, b)    (((a) + (b)) >> 1)
#define CHC_TIMEOUT 300

#define PHOTO_LINE      15
#define PHOTO_COLUMN    (256 + 25)

typedef struct drc_t {
    ChessStepType   type;  /* necessary one */
    rc_t            from, to;
}               drc_t;

typedef struct {
    rc_t select;
    char selected;
} chc_tag_data_t;

/* chess framework action functions */
static void chc_init_user(const userinfo_t *uinfo, ChessUser *user);
static void chc_init_user_userec(const userec_t *urec, ChessUser *user);
static void chc_init_board(board_t board);
static void chc_drawline(const ChessInfo* info, int line);
static void chc_movecur(int r, int c);
static int  chc_prepare_play(ChessInfo* info);
static int  chc_select(ChessInfo* info, rc_t scrloc, ChessGameResult* result);
static void chc_prepare_step(ChessInfo* info, const void* step);
static ChessGameResult chc_movechess(board_t board, const drc_t* move);
static void chc_drawstep(ChessInfo* info, const drc_t* move);
static void chc_gameend(ChessInfo* info, ChessGameResult result);
static void chc_genlog(ChessInfo* info, FILE* fp, ChessGameResult result);


static const char * const turn_color[2]={BLACK_COLOR, RED_COLOR};

/* some constant variable definition */

static const char * const turn_str[2] = {"黑的", "紅的"};

static const char * const num_str[2][10] = {
    {"", "１", "２", "３", "４", "５", "６", "７", "８", "９"},
    {"", "一", "二", "三", "四", "五", "六", "七", "八", "九"},
};

static const char * const chess_str[2][8] = {
    /* 0     1     2     3     4     5     6     7 */
    {"  ", "將", "士", "象", "車", "馬", "包", "卒"},
    {"  ", "帥", "仕", "相", "車", "傌", "炮", "兵"}
};

static const char * const chess_brd[BRD_ROW * 2 - 1] = {
    /* 0   1   2   3   4   5   6   7   8 */
    "┌─┬─┬─┬─┬─┬─┬─┬─┐",  /* 0 */
    "│  │  │  │＼│／│  │  │  │",
    "├─┼─┼─┼─┼─┼─┼─┼─┤",  /* 1 */
    "│  │  │  │／│＼│  │  │  │",
    "├─┼─┼─┼─┼─┼─┼─┼─┤",  /* 2 */
    "│  │  │  │  │  │  │  │  │",
    "├─┼─┼─┼─┼─┼─┼─┼─┤",  /* 3 */
    "│  │  │  │  │  │  │  │  │",
    "├─┴─┴─┴─┴─┴─┴─┴─┤",  /* 4 */
    "│  楚    河          漢    界  │",
    "├─┬─┬─┬─┬─┬─┬─┬─┤",  /* 5 */
    "│  │  │  │  │  │  │  │  │",
    "├─┼─┼─┼─┼─┼─┼─┼─┤",  /* 6 */
    "│  │  │  │  │  │  │  │  │",
    "├─┼─┼─┼─┼─┼─┼─┼─┤",  /* 7 */
    "│  │  │  │＼│／│  │  │  │",
    "├─┼─┼─┼─┼─┼─┼─┼─┤",  /* 8 */
    "│  │  │  │／│＼│  │  │  │",
    "└─┴─┴─┴─┴─┴─┴─┴─┘"   /* 9 */
};

static char * const hint_str[] = {
    "  q      認輸離開",
    "  p      要求和棋",
    "方向鍵   移動遊標",
    "Enter    選擇/移動"
};

static const ChessActions chc_actions = {
    &chc_init_user,
    &chc_init_user_userec,
    (void (*) (void*)) &chc_init_board,
    &chc_drawline,
    &chc_movecur,
    &chc_prepare_play,
    NULL, /* process_key */
    &chc_select,
    &chc_prepare_step,
    (ChessGameResult (*) (void*, const void*)) &chc_movechess,
    (void (*)(ChessInfo*, const void*)) &chc_drawstep,
    NULL, /* post_game */
    &chc_gameend,
    &chc_genlog
};

static const ChessConstants chc_constants = {
    sizeof(drc_t),
    CHC_TIMEOUT,
    BRD_ROW,
    BRD_COL,
    0,
    "楚河漢界",
    "photo_cchess",
#ifdef BN_CCHESS_LOG
    BN_CCHESS_LOG,
#else
    NULL,
#endif
    { BLACK_COLOR, RED_COLOR },
    {"黑的", "紅的"}
};

/*
 * Start of the drawing function.
 */
static void
chc_movecur(int r, int c)
{
    move(r * 2 + 3, c * 4 + 4);
}

static char *
getstep(board_t board, const rc_t *from, const rc_t *to, char buf[])
{
    int             turn, fc, tc;
    char           *dir;
    int         twin = 0, twin_r = 0;
    int         len = 0;

    turn = CHE_O(board[from->r][from->c]);
    if(CHE_P(board[from->r][from->c] != KIND_P)) { // TODO 目前不管兵卒前後
    int i;
    for(i=0;i<10;i++)
        if(board[i][from->c]==board[from->r][from->c]) {
        if(i!=from->r) {
            twin=1;
            twin_r=i;
        }
        }
    }
    fc = (turn == BLK ? from->c + 1 : 9 - from->c);
    tc = (turn == BLK ? to->c + 1 : 9 - to->c);
    if (from->r == to->r)
    dir = "平";
    else {
    if (from->c == to->c)
        tc = from->r - to->r;
    if (tc < 0)
        tc = -tc;

    if ((turn == BLK && to->r > from->r) ||
        (turn == RED && to->r < from->r))
        dir = "進";
    else
        dir = "退";
    }


    len=sprintf(buf, "%s", turn_color[turn]);
    /* 傌二|前傌 */
    if(twin) {
    len+=sprintf(buf+len, "%s%s",
        ((from->r>twin_r)==(turn==(BLK)))?"前":"後",
        chess_str[turn][CHE_P(board[from->r][from->c])]);
    } else {
    len+=sprintf(buf+len, "%s%s",
        chess_str[turn][CHE_P(board[from->r][from->c])],
        num_str[turn][fc]);
    }
    /* 進三 */
    len+=sprintf(buf+len, "%s%s" ANSI_RESET, dir, num_str[turn][tc]);
    /* ：象 */
    if(board[to->r][to->c]) {
    len+=sprintf(buf+len,"：%s%s" ANSI_RESET,
        turn_color[turn^1],
        chess_str[turn^1][CHE_P(board[to->r][to->c])]);
    }
    return buf;
}

inline static const char*
chc_timestr(int second)
{
    static char str[10];
    snprintf(str, sizeof(str), "%d:%02d", second / 60, second % 60);
    return str;
}

static void
chc_drawline(const ChessInfo* info, int line)
{
    int             i, j;
    board_p         board = (board_p) info->board;
    chc_tag_data_t *tag = info->tag;

    if (line == 0) {
    prints(ANSI_COLOR(1;46) "   象棋對戰   " ANSI_COLOR(45)
        "%30s VS %-20s%10s" ANSI_RESET,
           info->user1.userid, info->user2.userid,
           info->mode == CHESS_MODE_WATCH ? "[觀棋模式]" : "");
    } else if (line >= 3 && line <= 21) {
    outs("   ");
    for (i = 0; i < 9; i++) {
        j = board[RTL(info,line)][CTL(info,i)];
        if ((line & 1) == 1 && j) {
        if (tag->selected &&
            tag->select.r == RTL(info,line) && tag->select.c == CTL(info,i)) {
            prints("%s%s" ANSI_RESET,
               CHE_O(j) == BLK ? BLACK_REVERSE : RED_REVERSE,
               chess_str[CHE_O(j)][CHE_P(j)]);
        }
        else {
            prints("%s%s" ANSI_RESET,
               turn_color[CHE_O(j)],
               chess_str[CHE_O(j)][CHE_P(j)]);
        }
        } else
        prints("%c%c", chess_brd[line - 3][i * 4],
               chess_brd[line - 3][i * 4 + 1]);
        if (i != 8)
        prints("%c%c", chess_brd[line - 3][i * 4 + 2],
               chess_brd[line - 3][i * 4 + 3]);
    }
    } else if (line == 2 || line == 22) {
    outs("   ");
    if (line == 2)
        for (i = 1; i <= 9; i++)
        prints("%s  ", num_str[REDDOWN(info)?0:1][i]);
    else
        for (i = 9; i >= 1; i--)
        prints("%s  ", num_str[REDDOWN(info)?1:0][i]);
    }

    ChessDrawExtraInfo(info, line, 8);
}
/*
 * End of the drawing function.
 */


/*
 * Start of the log function.
 */

static void
chc_log_machine_step(FILE* fp, board_t board, const drc_t *step)
{
    static const char chess_char[8] = {
    0, 'K', 'A', 'B', 'R', 'N', 'C', 'P'
    };
    /* We have black at bottom in rc_t but the standard is
     * the red side at bottom, so that a rotation is needed. */
    fprintf(fp, "%c%c%d%c%c%d    ",
        chess_char[CHE_P(board[step->from.r][step->from.c])],
        step->from.c + 'a', BRD_ROW - step->from.r - 1,
        board[step->to.r][step->to.c] ? 'x' : '-',
        step->to.c   + 'a', BRD_ROW - step->to.r - 1
       );
}

static int
#if defined(__linux__)
chc_filter(const struct dirent *dir)
#else
chc_filter(struct dirent *dir)
#endif
{
    if (strcmp(dir->d_name, ".") == 0 || strcmp(dir->d_name, "..") == 0 )
    return 0;
    return strstr(dir->d_name, ".poem") != NULL;
}

static int
chc_log_poem(FILE* outfp)
{
    struct dirent **namelist;
    int n;

    // TODO use readdir(), don't use lots of memory
    n = scandir(BBSHOME"/etc/chess", &namelist, chc_filter, alphasort);
    if (n < 0)
    perror("scandir");
    else {
    char buf[80];
    FILE *fp;
    sprintf(buf, BBSHOME"/etc/chess/%s", namelist[random() % n]->d_name);
    if ((fp = fopen(buf, "r")) == NULL)
        return -1;

    while(fgets(buf, sizeof(buf), fp) != NULL)
        fputs(buf, outfp);
    while(n--)
        free(namelist[n]);
    free(namelist);
    fclose(fp);
    }
    return 0;
}

static void
chc_genlog(ChessInfo* info, FILE* fp, ChessGameResult result)
{
    const int nStep = info->history.used;
    board_t   board;
    int i;

    fprintf(fp, "按 z 可進入打譜模式\n");
    fprintf(fp, "\n");

    if (info->myturn == RED)
    fprintf(fp, "%s(%d) V.S. %s(%d)\n",
        info->user1.userid, info->user1.orig_rating,
        info->user2.userid, info->user2.orig_rating);
    else
    fprintf(fp, "%s(%d) V.S. %s(%d)\n",
        info->user2.userid, info->user2.orig_rating,
        info->user1.userid, info->user1.orig_rating);

    chc_init_board(board);
    /* format: "%3d. %8.8s  %8.8s  %3d. %8.8s  %8.8s\n" */
    for (i = 0; i < nStep; i++) {
    char buf[80];
    const drc_t *move = (const drc_t*)  ChessHistoryRetrieve(info, i);
    buf[0]='\0';
    if (move->type == CHESS_STEP_NORMAL) {
        getstep(board, &move->from, &move->to, buf);
        chc_movechess(board, move);
        if(i%2==0) fprintf(fp, "%3d. ",i/2+1);
        strip_ansi(buf, buf, STRIP_ALL);
        fprintf(fp, "%8.8s  ", buf);
        if(i%4==3 || i==nStep-1) fputc('\n', fp);
    }
    }

    if (result == CHESS_RESULT_TIE)
    fprintf(fp, "=> 和局\n");
    else if (result == CHESS_RESULT_WIN || result == CHESS_RESULT_LOST)
    fprintf(fp, "=> %s 勝\n",
        (info->myturn == RED) == (result== CHESS_RESULT_WIN) ?
        "紅" : "黑");
    
    /* generate machine readable log.
     * http://www.elephantbase.net/protocol/cchess_pgn.htm */
    {
    /* machine readable header */
    time_t     temp = (time_t) now;
    struct tm *mytm = localtime(&temp);

    fprintf(fp,
        "\n\n<chclog>\n"
        "[Game \"Chinese Chess\"]\n"
        "[Date \"%d.%d.%d\"]\n"
        "[Red \"%s\"]\n"
        "[Black \"%s\"]\n",
        mytm->tm_year + 1900, mytm->tm_mon + 1, mytm->tm_mday,
        info->myturn == RED ? info->user1.userid : info->user2.userid,
        info->myturn == RED ? info->user2.userid : info->user1.userid
           );

    if (result == CHESS_RESULT_TIE || result == CHESS_RESULT_WIN ||
        result == CHESS_RESULT_LOST)
        fprintf(fp, "[Result \"%s\"]\n",
            result == CHESS_RESULT_TIE ? "0.5-0.5" :
            (info->myturn == RED) == (result== CHESS_RESULT_WIN) ?
            "1-0" : "0-1");
    else
        fprintf(fp, "[Result \"*\"]\n");

    fprintf(fp,
        "[Notation \"Coord\"]\n"
        "[FEN \"rnbakabnr/9/1c5c1/p1p1p1p1p/9/9/P1P1P1P1P/1C5C1/9/RNBAKABNR"
        " r - - 0 1\"]\n");
    }
    chc_init_board(board);
    for (i = 0; i < nStep - 1; i += 2) {
    const drc_t *move = (const drc_t*)  ChessHistoryRetrieve(info, i);
    fprintf(fp, "%2d. ", i / 2 + 1);
    if (move->type == CHESS_STEP_NORMAL) {
        chc_log_machine_step(fp, board, move);
        chc_movechess(board, move);
    }

    fputs("    ", fp);

    move = (const drc_t*)  ChessHistoryRetrieve(info, i + 1);
    if (move->type == CHESS_STEP_NORMAL) {
        chc_log_machine_step(fp, board, move);
        chc_movechess(board, move);
    }

    fputc('\n', fp);
    }
    if (i < nStep) {
    const drc_t *move = (const drc_t*)  ChessHistoryRetrieve(info, i);
    if (move->type == CHESS_STEP_NORMAL) {
        fprintf(fp, "%2d. ", i / 2 + 1);
        chc_log_machine_step(fp, board, move);
        fputc('\n', fp);
    }
    }

    fputs("</chclog>\n\n--\n\n", fp);
    chc_log_poem(fp);
}
/*
 * End of the log function.
 */


/*
 * Start of the rule function.
 */
static void
chc_init_board(board_t board)
{
    memset(board, 0, sizeof(board_t));
    board[0][4] = CHE(KIND_K, BLK); /* 將 */
    board[0][3] = board[0][5] = CHE(KIND_A, BLK);   /* 士 */
    board[0][2] = board[0][6] = CHE(KIND_E, BLK);   /* 象 */
    board[0][0] = board[0][8] = CHE(KIND_R, BLK);   /* 車 */
    board[0][1] = board[0][7] = CHE(KIND_H, BLK);   /* 馬 */
    board[2][1] = board[2][7] = CHE(KIND_C, BLK);   /* 包 */
    board[3][0] = board[3][2] = board[3][4] =
    board[3][6] = board[3][8] = CHE(KIND_P, BLK);   /* 卒 */

    board[9][4] = CHE(KIND_K, RED); /* 帥 */
    board[9][3] = board[9][5] = CHE(KIND_A, RED);   /* 仕 */
    board[9][2] = board[9][6] = CHE(KIND_E, RED);   /* 相 */
    board[9][0] = board[9][8] = CHE(KIND_R, RED);   /* 車 */
    board[9][1] = board[9][7] = CHE(KIND_H, RED);   /* 傌 */
    board[7][1] = board[7][7] = CHE(KIND_C, RED);   /* 炮 */
    board[6][0] = board[6][2] = board[6][4] =
    board[6][6] = board[6][8] = CHE(KIND_P, RED);   /* 兵 */
}

static void
chc_prepare_step(ChessInfo* info, const void* step)
{
    const drc_t* move = (const drc_t*) step;
    getstep((board_p) info->board, 
        &move->from, &move->to, info->last_movestr);
}

static ChessGameResult
chc_movechess(board_t board, const drc_t* move)
{
    int end = (CHE_P(board[move->to.r][move->to.c]) == KIND_K);

    board[move->to.r][move->to.c] = board[move->from.r][move->from.c];
    board[move->from.r][move->from.c] = 0;

    return end ? CHESS_RESULT_WIN : CHESS_RESULT_CONTINUE;
}

static void
chc_drawstep(ChessInfo* info, const drc_t* move)
{
    ChessDrawLine(info, LTR(info, move->from.r));
    ChessDrawLine(info, LTR(info, move->to.r));
}

/* 求兩座標行或列(rowcol)的距離 */
static int
dist(rc_t from, rc_t to, int rowcol)
{
    int             d;

    d = rowcol ? from.c - to.c : from.r - to.r;
    return d > 0 ? d : -d;
}

/* 兩座標(行或列rowcol)中間有幾顆棋子 */
static int
between(board_t board, rc_t from, rc_t to, int rowcol)
{
    int             i, rtv = 0;

    if (rowcol) {
    if (from.c > to.c)
        i = from.c, from.c = to.c, to.c = i;
    for (i = from.c + 1; i < to.c; i++)
        if (board[to.r][i])
        rtv++;
    } else {
    if (from.r > to.r)
        i = from.r, from.r = to.r, to.r = i;
    for (i = from.r + 1; i < to.r; i++)
        if (board[i][to.c])
        rtv++;
    }
    return rtv;
}

static int
chc_canmove(board_t board, rc_t from, rc_t to)
{
    int             i;
    int             rd, cd, turn;

    if(0 ||
    !(0<=from.r && from.r<BRD_ROW) ||
    !(0<=from.c && from.c<BRD_COL) ||
    !(0<=to.r && to.r<BRD_ROW) ||
    !(0<=to.c && to.c<BRD_COL))
    return 0;

    rd = dist(from, to, 0);
    cd = dist(from, to, 1);
    turn = CHE_O(board[from.r][from.c]);

    /* general check */
    if (board[to.r][to.c] && CHE_O(board[to.r][to.c]) == turn)
    return 0;

    /* individual check */
    switch (CHE_P(board[from.r][from.c])) {
    case KIND_K:        /* 將 帥 */
    if (!(rd == 1 && cd == 0) &&
        !(rd == 0 && cd == 1))
        return 0;
    if ((turn == BLK && to.r > 2) ||
        (turn == RED && to.r < 7) ||
        to.c < 3 || to.c > 5)
        return 0;
    break;
    case KIND_A:        /* 士 仕 */
    if (!(rd == 1 && cd == 1))
        return 0;
    if ((turn == BLK && to.r > 2) ||
        (turn == RED && to.r < 7) ||
        to.c < 3 || to.c > 5)
        return 0;
    break;
    case KIND_E:        /* 象 相 */
    if (!(rd == 2 && cd == 2))
        return 0;
    if ((turn == BLK && to.r > 4) ||
        (turn == RED && to.r < 5))
        return 0;
    /* 拐象腿 */
    if (board[CENTER(from.r, to.r)][CENTER(from.c, to.c)])
        return 0;
    break;
    case KIND_R:        /* 車 */
    if (!(rd > 0 && cd == 0) &&
        !(rd == 0 && cd > 0))
        return 0;
    if (between(board, from, to, rd == 0))
        return 0;
    break;
    case KIND_H:        /* 馬 傌 */
    if (!(rd == 2 && cd == 1) &&
        !(rd == 1 && cd == 2))
        return 0;
    /* 拐馬腳 */
    if (rd == 2) {
        if (board[CENTER(from.r, to.r)][from.c])
        return 0;
    } else {
        if (board[from.r][CENTER(from.c, to.c)])
        return 0;
    }
    break;
    case KIND_C:        /* 包 炮 */
    if (!(rd > 0 && cd == 0) &&
        !(rd == 0 && cd > 0))
        return 0;
    i = between(board, from, to, rd == 0);
    if ((i > 1) ||
        (i == 1 && !board[to.r][to.c]) ||
        (i == 0 && board[to.r][to.c]))
        return 0;
    break;
    case KIND_P:        /* 卒 兵 */
    if (!(rd == 1 && cd == 0) &&
        !(rd == 0 && cd == 1))
        return 0;
    if (((turn == BLK && to.r < 5) ||
         (turn == RED && to.r > 4)) &&
        cd != 0)
        return 0;
    if ((turn == BLK && to.r < from.r) ||
        (turn == RED && to.r > from.r))
        return 0;
    break;
    }
    return 1;
}

/* 找 turn's king 的座標 */
static int
findking(board_t board, int turn, rc_t * buf)
{
    int             i, r, c;

    r = (turn == BLK ? 0 : 7);
    for (i = 0; i < 3; r++, i++)
    for (c = 3; c < 6; c++)
        if (CHE_P(board[r][c]) == KIND_K &&
        CHE_O(board[r][c]) == turn) {
        buf->r = r, buf->c = c;
        return 1;
        }
    /* one's king may be eaten */
    return 0;
}

static int
chc_iskfk(board_t board)
{
    rc_t            from, to;

    if (!findking(board, BLK, &to)) return 0;
    if (!findking(board, RED, &from)) return 0;
    if (from.c == to.c && between(board, from, to, 0) == 0)
    return 1;
    return 0;
}

static int
chc_ischeck(board_t board, int turn)
{
    rc_t            from, to;

    if (!findking(board, turn, &to)) return 0;
    for (from.r = 0; from.r < BRD_ROW; from.r++)
    for (from.c = 0; from.c < BRD_COL; from.c++)
        if (board[from.r][from.c] &&
        CHE_O(board[from.r][from.c]) != turn)
        if (chc_canmove(board, from, to))
            return 1;
    return 0;
}
/*
 * End of the rule function.
 */

static void
chcusr_put(userec_t* userec, const ChessUser* user)
{
    userec->chc_win = user->win;
    userec->chc_lose = user->lose;
    userec->chc_tie = user->tie;
    userec->chess_elo_rating = user->rating;
}

static void
chc_init_user(const userinfo_t *uinfo, ChessUser *user)
{
    strlcpy(user->userid, uinfo->userid, sizeof(user->userid));
    user->win    = uinfo->chc_win;
    user->lose   = uinfo->chc_lose;
    user->tie    = uinfo->chc_tie;
    user->rating = uinfo->chess_elo_rating;
    if(user->rating == 0)
    user->rating = 1500; /* ELO initial value */
    user->orig_rating = user->rating;
}

static void
chc_init_user_userec(const userec_t *urec, ChessUser *user)
{
    strlcpy(user->userid, urec->userid, sizeof(user->userid));
    user->win    = urec->chc_win;
    user->lose   = urec->chc_lose;
    user->tie    = urec->chc_tie;
    user->rating = urec->chess_elo_rating;
    if(user->rating == 0)
    user->rating = 1500; /* ELO initial value */
    user->orig_rating = user->rating;
}

static int
chc_prepare_play(ChessInfo* info)
{
    if (chc_ischeck((board_p) info->board, info->turn)) {
    strlcpy(info->warnmsg, ANSI_COLOR(1;31) "將軍!" ANSI_RESET,
        sizeof(info->warnmsg));
    bell();
    } else
    info->warnmsg[0] = 0;

    return 0;
}

static int
chc_select(ChessInfo* info, rc_t scrloc, ChessGameResult* result)
{
    chc_tag_data_t* tag = (chc_tag_data_t*) info->tag;
    board_p board       = (board_p)         info->board;
    rc_t loc;

    assert(tag);

    /* transform from screen to internal coordinate */
    if(REDDOWN(info)) {
      loc = scrloc;
    } else {
      loc.r = BRD_ROW-scrloc.r-1;
      loc.c = BRD_COL-scrloc.c-1;
    }

    if (!tag->selected) {
    /* trying to pick something */
    if (board[loc.r][loc.c] &&
        CHE_O(board[loc.r][loc.c]) == info->turn) {
        /* they can pick up this */
        tag->selected = 1;
        tag->select = loc;
        ChessDrawLine(info, LTR(info, loc.r));
    }
    return 0;
    } else if (tag->select.r == loc.r && tag->select.c == loc.c) {
    /* cancel selection */
    tag->selected = 0;
    ChessDrawLine(info, LTR(info, loc.r));
    return 0;
    } else if (chc_canmove(board, tag->select, loc)) {
    /* moving the chess */
    drc_t   moving = { CHESS_STEP_NORMAL, tag->select, loc };
    board_t tmpbrd;
    int valid_step = 1;

    if (CHE_P(board[loc.r][loc.c]) == KIND_K)
        /* 移到對方將帥 */
        *result = CHESS_RESULT_WIN;
    else {
        memcpy(tmpbrd, board, sizeof(board_t));
        chc_movechess(tmpbrd, &moving);
        valid_step = !chc_iskfk(tmpbrd);
    }

    if (valid_step) {
        getstep(board, &moving.from, &moving.to, info->last_movestr);

        chc_movechess(board, &moving);
        ChessDrawLine(info, LTR(info, moving.from.r));
        ChessDrawLine(info, LTR(info, moving.to.r));

        ChessHistoryAppend(info, &moving);
        ChessStepSend(info, &moving);

        tag->selected = 0;
        return 1;
    } else {
        /* 王見王 */
        strlcpy(info->warnmsg,
            ANSI_COLOR(1;33) "不可以王見王" ANSI_RESET,
            sizeof(info->warnmsg));
        bell();
        ChessDrawLine(info, CHESS_DRAWING_WARN_ROW);
        return 0;
    }
    } else
    /* nothing happened */
    return 0;
}

static int round_to_int(double x)
{
    /* assume that double cast to int will drop fraction parts */
    if(x>=0)
    return (int)(x+0.5);
    return (int)(x-0.5);
}

/*
 * ELO rating system
 * see http://www.wordiq.com/definition/ELO_rating_system
 */
static void
count_chess_elo_rating(ChessUser* user1, const ChessUser* user2, double myres)
{
    double k;
    double exp_res;
    int diff;
    int newrating;

    if(user1->rating < 1800)
    k = 30;
    else if(user1->rating < 2000)
    k = 25;
    else if(user1->rating < 2200)
    k = 20;
    else if(user1->rating < 2400)
    k = 15;
    else
    k = 10;

    //exp_res = 1.0/(1.0 + pow(10.0, (user2->rating-user1->rating)/400.0));
    //user1->rating += (int)floor(k*(myres-exp_res)+0.5);
    diff=(int)user2->rating-(int)user1->rating;
    if(diff<=-1000 || diff>=1000)
       exp_res=diff>0?0.0:1.0;
    else if(diff>=0)
       exp_res=elo_exp_tab[diff];
    else
       exp_res=1.0-elo_exp_tab[-diff];
    newrating = (int)user1->rating + round_to_int(k*(myres-exp_res));
    if(newrating > 3000) newrating = 3000;
    if(newrating < 1) newrating = 1;
    user1->rating = newrating;
}


/* 象棋功能進入點:
 * chc_main: 對奕
 * chc_personal: 打譜
 * chc_watch: 觀棋
 * talk.c: 對奕
 */
void
chc(int s, ChessGameMode mode)
{
    ChessInfo*     info = NewChessInfo(&chc_actions, &chc_constants, s, mode);
    board_t        board;
    chc_tag_data_t tag;

    chc_init_board(board);
    tag.selected = 0;

    info->board = board;
    info->tag   = &tag;

    if (info->mode == CHESS_MODE_VERSUS) {
    /* Assume that info->user1 is me. */
    info->user1.lose++;
    count_chess_elo_rating(&info->user1, &info->user2, 0.0);
    passwd_sync_query(usernum, &cuser);
    chcusr_put(&cuser, &info->user1);
    passwd_sync_update(usernum, &cuser);
    }

    if (mode == CHESS_MODE_WATCH)
    setutmpmode(CHESSWATCHING);
    else
    setutmpmode(CHC);
    currutmp->sig = SIG_CHC;

    ChessPlay(info);

    DeleteChessInfo(info);
}

static void
chc_gameend(ChessInfo* info, ChessGameResult result)
{
    ChessUser* const user1 = &info->user1;
    ChessUser* const user2 = &info->user2;

    if (info->mode == CHESS_MODE_VERSUS) {
    if (info->myturn == RED) {
        /* 由紅方作 log. 記的是下棋前的原始分數 */
        /* NOTE, 若紅方斷線則無 log */
        time_t t = time(NULL);
        char buf[100];
        sprintf(buf, "%s %s(%d,W%d/D%d/L%d) %s %s(%d,W%d/D%d/L%d)\n",
            ctime(&t),
            user1->userid, user1->rating, user1->win,
            user1->tie, user1->lose - 1,
            (result == CHESS_RESULT_TIE ? "和" :
             result == CHESS_RESULT_WIN ? "勝" : "負"),
            user2->userid, user2->rating, user2->win,
            user2->tie, user2->lose - 1);
        buf[24] = ' '; // replace '\n'
        log_file(BBSHOME "/log/chc.log", LOG_CREAT, buf);
    }

    user1->rating = user1->orig_rating;
    user1->lose--;
    if (result == CHESS_RESULT_WIN) {
        count_chess_elo_rating(user1, user2, 1.0);
        user1->win++;
        currutmp->chc_win++;
    } else if (result == CHESS_RESULT_LOST) {
        count_chess_elo_rating(user1, user2, 0.0);
        user1->lose++;
        currutmp->chc_lose++;
    } else {
        count_chess_elo_rating(user1, user2, 0.5);
        user1->tie++;
        currutmp->chc_tie++;
    }
    currutmp->chess_elo_rating = user1->rating;
    chcusr_put(&cuser, user1);
    passwd_sync_update(usernum, &cuser);
    } else if (info->mode == CHESS_MODE_REPLAY) {
    free(info->board);
    free(info->tag);
    }
}

int
chc_main(void)
{
    return ChessStartGame('c', SIG_CHC, "楚河漢界之爭");
}

int
chc_personal(void)
{
    chc(0, CHESS_MODE_PERSONAL);
    return 0;
}

int
chc_watch(void)
{
    return ChessWatchGame(&chc, CHC, "楚河漢界之爭");
}

ChessInfo*
chc_replay(FILE* fp)
{
    ChessInfo *info;
    char       buf[256];

    info = NewChessInfo(&chc_actions, &chc_constants,
        0, CHESS_MODE_REPLAY);

    while (fgets(buf, sizeof(buf), fp)) {
    if (strcmp("</chclog>\n", buf) == 0)
        break;
    if (buf[0] == '[') {
        if (strncmp(buf + 1, "Red", 3) == 0 ||
            strncmp(buf + 1, "Black", 5) == 0) {
        /* /\[(Red|Black) "([a-zA-Z0-9]+)"\]/; $2 */
        userec_t   rec;
        char      *userid;
        char *strtok_pos = NULL;
        ChessUser *user =
            (buf[1] == 'R' ? &info->user1 : &info->user2);

        strtok_r(buf, "\"", &strtok_pos);
        userid = strtok_r(NULL, "\"", &strtok_pos);
        if (userid != NULL && getuser(userid, &rec))
            chc_init_user_userec(&rec, user);
        }
    } else {
        /* " 1. Ch2-e2        Nb9-c7" */
        drc_t       step = { .type = CHESS_STEP_NORMAL };
        const char *p = strchr(buf, '.');

        if (p == NULL) continue;

        ++p; /* skip '.' */
        while (*p && isspace(*p)) ++p;
        if (!*p) continue;

        /* p -> "Ch2-e2 ...." */
        step.from.c = p[1] - 'a';
        step.from.r = BRD_ROW - 1 - (p[2] - '0');
        step.to.c   = p[4] - 'a';
        step.to.r   = BRD_ROW - 1 - (p[5] - '0');

#define INVALID_ROW(R) ((R) < 0 || (R) >= BRD_ROW)
#define INVALID_COL(C) ((C) < 0 || (C) >= BRD_COL)
#define INVALID_LOC(S) (INVALID_ROW(S.r) || INVALID_COL(S.c))
        if (INVALID_LOC(step.from) || INVALID_LOC(step.to))
        continue;
        ChessHistoryAppend(info, &step);

        p += 6;
        while (*p && isspace(*p)) ++p;
        if (!*p) continue;

        /* p -> "Nb9-c7\n" */
        step.from.c = p[1] - 'a';
        step.from.r = BRD_ROW - 1 - (p[2] - '0');
        step.to.c   = p[4] - 'a';
        step.to.r   = BRD_ROW - 1 - (p[5] - '0');

        if (INVALID_LOC(step.from) || INVALID_LOC(step.to))
        continue;
        ChessHistoryAppend(info, &step);

#undef INVALID_ROW
#undef INVALID_COL
#undef INVALID_LOC
    }
    }

    info->board = malloc(sizeof(board_t));
    info->tag   = malloc(sizeof(chc_tag_data_t));

    chc_init_board(info->board);
    ((chc_tag_data_t*) info->tag)->selected = 0;

    return info;
}