/* $Id: reversi.c,v 2.1 2004/11/12 20:48:16 bbs Exp $ */

#include "bbs.h"

void reversi_freturn_grid(FILE *fp, int x, int y);
void reversi_write_header(FILE * fp); 
void reversi_init_ai();

static const char *num_str[16] = {
	"A", "B", "C", "D", "E",
	"F", "G", "H", "J", "K",
	"L", "M", "N", "O", "P",
	"Q"
};

static const char num_str3 = 'Z';

static const char *num_str2[16] = {
	"Ａ", "Ｂ", "Ｃ", "Ｄ", "Ｅ",
	"Ｆ", "Ｇ", "Ｈ", "Ｊ", "Ｋ",
	"Ｌ", "Ｍ", "Ｎ", "Ｏ", "Ｐ",
	"Ｑ"
};

static int reversi_mode;

static int reversi_nowx;
static int reversi_nowy;
static int reversi_count;
static int reversi_old_count;
static int reversi_boardsize;
static int reversi_now_side;
static int reversi_board[16][16];
static int reversi_ai_board[16][16];
static char reversi_log_x[361];
static int  reversi_log_y[361];
static char reversi_user1[20];
static char reversi_user2[20];

static int reversi_played;

static int reversi_num_reverse_row(int side, int test_x, int test_y, int direction) {
	int x_change = 0;
	int y_change = 0;
	int counter = 0;
	int end = 0;
	int rtn_val = 0;

	if (direction==1) {
		x_change = -1;
		y_change = -1;
	} else if (direction==2) {
		x_change = 0;
		y_change = -1;
	} else if (direction==3) {
		x_change = 1;
		y_change = -1;
	} else if (direction==4) {
		x_change = 1;
		y_change = 0;
	} else if (direction==5) {
		x_change = 1;
		y_change = 1;
	} else if (direction==6) {
		x_change = 0;
		y_change = 1;
	} else if (direction==7) {
		x_change = -1;
		y_change = 1;
	} else if (direction==8) {
		x_change = -1;
		y_change = 0;
	}

	end = 0;
	test_x = test_x+x_change;
	test_y = test_y+y_change;

	while ((test_x >= 0 && test_x < reversi_boardsize) && (test_y >= 0 && test_y < reversi_boardsize)) {
//printf("DEBUG1: %d, %d\n", x, y);
		//still in reversi_board
		if (reversi_board[test_x][test_y]==side) {
			//same color to start
			end = 1;
			break; 
		} else if (reversi_board[test_x][test_y]==0) {
			//empty slot 
			break; 
		} else if (reversi_board[test_x][test_y]==9) {
			//crazy block
			break; 
		} else {
			//diff color to start
			counter++;
			test_x = test_x+x_change;
			test_y = test_y+y_change;
		}
	}

	if (end == 1) {
		rtn_val = counter;
	} else {
		rtn_val = 0;
	}
	return rtn_val;
}

static int reversi_num_reverse(int side, int x, int y) {
	int result = 0;
	int tmp = 0;
	int i;

	if (reversi_board[x][y] == 0) {
		for ( i = 8 ; i > 0; i--) {
			tmp = reversi_num_reverse_row(side, x, y, i);
			/*
			 * 1 2 3
			 * 8 X 4
			 * 7 6 5
			 */

			//printf("DEBUG %d %d\n", i, tmp);

			if (tmp >= 0) {
				result += tmp;
			} else {
				//error?
				result = -2;
				break;
			}
		}
	} else {
		result = -1;
	}
	return result;
}

// return 0:no valid move , 1:have valid move
static int reversi_any_valid_move(int side) {
	int i,j;
	for ( i = 0 ; i < reversi_boardsize ; i++) {
		for ( j = 0 ; j < reversi_boardsize ; j++) {
			if ( reversi_num_reverse(side, i, j)>0 ) {
				//have somewhere to play 
				return 1;
			}
		}
	}
	return 0;
}

/** 
return 
0:normal
1:user1 can't move, swap back user2 
2:user2 can't move, swap back user1
3:noone can more, drawGame
*/
static int reversi_next() {

	//note: need add log for pass also!

	if (reversi_now_side == 1) {
		if ( reversi_any_valid_move(1)==1 ) {
			//have somewhere to play 
			return 0;
		}
		if ( reversi_any_valid_move(2)==1 ) {
			reversi_log_x[reversi_count] = num_str3;
			reversi_log_y[reversi_count] = 0;
			reversi_count++;
			//have somewhere to play 
			reversi_now_side = 2;
			return 1;
		}
	}
	else if (reversi_now_side == 2) {
		if ( reversi_any_valid_move(2)==1 ) {
			//have somewhere to play 
			return 0;
		}
		if ( reversi_any_valid_move(1)==1 ) {
			reversi_log_x[reversi_count] = num_str3;
			reversi_log_y[reversi_count] = 99;
			reversi_count++;
			//have somewhere to play 
			reversi_now_side = 1;
			return 2;
		}
	}
	reversi_now_side = -1;
	return 3;
}

static int reversi_count_point(int side) {
	int i,j;
	int counter = 0;

	for ( i = 0 ; i < reversi_boardsize ; i++) {
		for ( j = 0 ; j < reversi_boardsize ; j++) {
			if ( reversi_board[i][j] == side ) {
				counter++;
			}
		}
	}

	return counter;
}

// return 0:not ended,1:user1 win,2:user2 wins, 3:drawGame
static int reversi_who_wins() {
	int count_user1 = 0;
	int count_user2 = 0;

	if ( (reversi_any_valid_move(1)==1) || (reversi_any_valid_move(2)==1) ) {
		//still have valid move
		return 0;
	} else {
		count_user1 = reversi_count_point(1);
		count_user2 = reversi_count_point(2);
		if (count_user1 > count_user2) {
			return 1;
		} else if (count_user1 < count_user2) {
			return 2;
		} else {
			return 3;
		}
	}
}

static void reversi_reverse_row(int side, int x, int y, int direction) {
	int x_change = 0;
	int y_change = 0;

	if (direction==1) {
		x_change = -1;
		y_change = -1;
	} else if (direction==2) {
		x_change = 0;
		y_change = -1;
	} else if (direction==3) {
		x_change = 1;
		y_change = -1;
	} else if (direction==4) {
		x_change = 1;
		y_change = 0;
	} else if (direction==5) {
		x_change = 1;
		y_change = 1;
	} else if (direction==6) {
		x_change = 0;
		y_change = 1;
	} else if (direction==7) {
		x_change = -1;
		y_change = 1;
	} else if (direction==8) {
		x_change = -1;
		y_change = 0;
	}

	//printf("gogo %d %d %d %d\n", side, x, y, direction);
	if (reversi_num_reverse_row(side, x, y, direction) > 0) {
		//printf("haha %d %d %d %d\n", side, x, y, direction);
		x = x+x_change;
		y = y+y_change;

		while ((x >= 0 && x < reversi_boardsize) && (y >= 0 && y < reversi_boardsize)) {
			//still in reversi_board
			if (reversi_board[x][y]==side) {
				//self
				break; 
			} else if (reversi_board[x][y]==0) {
				//empty slot 
				break; 
			} else if (reversi_board[x][y]==9) {
				//crazy block
				break; 
			} else {
				reversi_board[x][y]=side;
				x = x+x_change;
				y = y+y_change;
			}
		}
	}
}

static void reversi_reverse(int side, int x, int y) {
	int i;

	for ( i = 8 ; i > 0; i--) {
		reversi_reverse_row(side, x, y, i);
		/*
		 * 1 2 3
		 * 8 X 4
		 * 7 6 5
		 */

		//printf("DEBUG %d %d\n", i, tmp);
	}
}

static int reversi_play(int side, int in_x, int in_y) {
	int rtn_val = 0;

	if (reversi_board[in_x][in_y] == 0) {
		//is Empty
		if (reversi_num_reverse(side, in_x, in_y)<=0) {
			//nothing can reverse, invalid
			rtn_val = -2;
		} else {
			//sth can reverse, valid
			reversi_board[in_x][in_y] = side;
			reversi_reverse(side, in_x, in_y);

			reversi_log_x[reversi_count] = num_str[in_x][0];
			reversi_log_y[reversi_count] = in_y;
			reversi_count++;
			reversi_played++;
			if (side == 1) {
				strcpy(reversi_user1, currutmp->userid);
			} if (side == 2) {
				strcpy(reversi_user2, currutmp->userid);
			}
			if (side == 1) {
				reversi_now_side = 2;
			} else {
				reversi_now_side = 1;
			}
		}
	} else {
		rtn_val = -1;
	}
	return rtn_val;
}

static void reversi_init() {
	int i, j;
	for ( i = 0 ; i < 16; i++) {
		for ( j = 0 ; j < 16; j++) {
			reversi_board[i][j] = 0;
		}
	}

	if (reversi_mode == 0) {
		reversi_boardsize = 8;
		reversi_board[3][3] = 1;
		reversi_board[4][4] = 1;
		reversi_board[4][3] = 2;
		reversi_board[3][4] = 2;
	} else if (reversi_mode == 1) {
		reversi_boardsize = 8;
		reversi_board[3][3] = 1;
		reversi_board[4][4] = 2;
		reversi_board[4][3] = 1;
		reversi_board[3][4] = 2;
	}
}


static void reversi_indigestion(int i) {
	fprintf(stderr, "嚴重內傷 %d\n", i);
}

static int reversi_write_file(char *fpath, int *islocal) {
	/* struct tm  *ptime; */
	FILE   *fp = NULL;
	/* char ans[TTLEN], *msg; */
	int aborted = 0;
	/* , line = 0, checksum[3], sum = 0, po = y1; */
	int i;
	int i2;
	int j;
	int k;
	int log;
	int go_start;
	/* getdata(1, 0, msg, ans, 2, LCECHO); */

	if (!*fpath) {
		sethomepath(fpath, cuser->userid);
		strcpy(fpath, tempnam(fpath, "ve_"));
	}
	if ((fp = fopen(fpath, "w")) == NULL) {
		reversi_indigestion(5);
		abort_bbs(0);
	}
	reversi_write_header(fp);

	fprintf(fp, "  ");
	for (i=0; i<16; i++) {
		if (i<reversi_boardsize) {
			fprintf(fp, "%s", num_str2[i]);
		} else {
			fprintf(fp, "  ");
		}
	}
	fprintf(fp, "棋譜\n");
	
	for (i=0; i<=20; i++) {
		if (i<16) {
			if (i<reversi_boardsize) {
				if (i>reversi_boardsize - 10) {
					fprintf(fp, " ");
				}
				fprintf(fp, "%d", reversi_boardsize - i);
			} else {
				fprintf(fp, "  ");
			}

			for (j=0; j<20; j++) {
				reversi_freturn_grid(fp, j, i);
			}
		}
		if (i==1) {
			if (reversi_now_side == 1) {
				fprintf(fp, "  →");
			} else {
				fprintf(fp, "    ");
			}
			if (strcmp(reversi_user1, "???")==0) {
				fprintf(fp, "黑○：INSERT-COIN ");
			} else {
				fprintf(fp, "黑○：%s ", reversi_user1);
			}
		}
		if (i==2) {
			if (reversi_now_side == 2) {
				fprintf(fp, "  →");
			} else {
				fprintf(fp, "    ");
			}

			if (strcmp(reversi_user2, "???")==0) {
				fprintf(fp, "白●：INSERT-COIN ");
			} else {
				fprintf(fp, "白●：%s ", reversi_user2);
			}
		}
		if (i==4) {
/** Start 24-08-2004 */		
			if (reversi_now_side == 1) {
				fprintf(fp, "  黑方下子，現為第 %d 著", reversi_count);
			} else if (reversi_now_side == 2) {
				fprintf(fp, "  白方下子，現為第 %d 著", reversi_count);
			} else {
				fprintf(fp, "  此局結束，共下了 %d 著", reversi_count);
			}
/** End 24-08-2004 */
			
			
		}
		if (i==6) {
			fprintf(fp, "  ○  ●  ○  ●  ○  ●  ○  ●");
		}
		if (i==7) {
			go_start = 0;
			if (reversi_count > 80) {
				go_start = (reversi_count / 8 * 8) - 72;
				fprintf(fp, "  -(最頂為第 %d 著)---------------", go_start);
			} else {
				fprintf(fp, "  --------------------------------");
			}
		}
		if (i==18) {
			fprintf(fp, "  --------------------------------");
		}
		if ((i>7) && (i<18)) {
			i2 = i - 8;
			go_start = 0;
			if (reversi_count > 80) {
				go_start = (reversi_count / 8 * 8) - 72;
			}
			fprintf(fp, "  ");
			for (k=0; k<8; k++) {
				log = i2*8+k + go_start;
				if (log < reversi_count) {
/** START 24-08-2004 */
					if (reversi_log_y[log] == 99) {
						//pass
						fprintf(fp, "PS  ");
					} else {
						fprintf(fp, "%c%d", reversi_log_x[log], reversi_boardsize-reversi_log_y[log]);
						if (reversi_log_y[log]>reversi_boardsize - 10) {
							fprintf(fp, " ");
						}
						fprintf(fp, " ");
					}
/** End 24-08-2004 */					


				}
			}
		}
		fprintf(fp, "\n");
	}
	fclose(fp);
	return aborted;
}

void reversi_write_header(FILE * fp) {
	int result = 0;
	char   *ptr;
	struct {
		char author[IDLEN + 1];
		char board[IDLEN + 1];
		char title[66];
		time_t  date;	/* last post's date */
		int number;	/* post number */
	} postlog;

	fprintf(fp, "%s %s (%s)\n", str_author1, cuser->userid, cuser->username);

	memset(&postlog, 0, sizeof(postlog));
	strlcpy(postlog.author, cuser->userid, sizeof(postlog.author));
	strlcpy(postlog.board, currboard, sizeof(postlog.board));
	if (reversi_count > 1 && reversi_old_count != 0) {
		result = reversi_who_wins();
		if ( result==1 ) {
			snprintf(save_title, sizeof(save_title), "Re: [黑白] %s 勝 %s", reversi_user1, reversi_user2);
		} else if ( result==2 ) {
			snprintf(save_title, sizeof(save_title), "Re: [黑白] %s 負 %s", reversi_user1, reversi_user2);
		} else if ( result==3 ) {
			snprintf(save_title, sizeof(save_title), "Re: [黑白] %s 和 %s", reversi_user1, reversi_user2);
		} else {
			snprintf(save_title, sizeof(save_title), "Re: [黑白] %s 對 %s", reversi_user1, reversi_user2);
		}
	} else {
		snprintf(save_title, sizeof(save_title), "[黑白] %s 對 %s", reversi_user1, reversi_user2);
	}
	ptr = save_title;
	strncpy(postlog.title, ptr, 65);
	postlog.date = now;
	postlog.number = 1;
	append_record(".post", (fileheader_t *) & postlog, sizeof(postlog));
	save_title[72] = '\0';
	fprintf(fp, "標題: %s\n時間: %s\n", save_title, ctime(&now));
}

void reversi_freturn_grid(FILE *fp, int x, int y) {
	char k[3] = "□";
	char k2[3] = "";
	int placed = 0;

	strcpy(k, "□");
	if (x==0) {
		strcpy(k, "□");
	}
	if (x==reversi_boardsize-1) {
		strcpy(k, "□");
	}
	if (y==0) {
		strcpy(k, "□"); 
	}
	if (y==reversi_boardsize-1) {
		strcpy(k, "□");
	}
	if ((x==0) && (y==0)) {
		strcpy(k, "□");
	}
	if ((x==reversi_boardsize-1) && (y==0)) {
		strcpy(k, "□");
	}
	if ((x==reversi_boardsize-1) && (y==reversi_boardsize-1)) {
		strcpy(k, "□");
	}
	if ((x==0) && (y==reversi_boardsize-1)) {
		strcpy(k, "□");
	}

	if (x == reversi_boardsize) {
		if (y < reversi_boardsize) {
			if (y > reversi_boardsize - 10) {
				strcpy(k, " ");
			} else {
				strcpy(k, "");
			}
			sprintf(k2, "%d", reversi_boardsize - y);
			strcat(k, k2);
		} else {
			strcpy(k, "  ");
		}
	}
	if ((x > reversi_boardsize) || (y >= reversi_boardsize)) {
		strcpy(k, "  ");
	}
	if (x < reversi_boardsize) {
		if (y < reversi_boardsize) {
			placed = 0;
			if (reversi_count > 0) {
				if (num_str[x][0] == reversi_log_x[reversi_count - 1]) {
					if (y == reversi_log_y[reversi_count - 1]) {
						if (reversi_board[x][y] == 1) {
							fprintf(fp, "◇");
						}
						if (reversi_board[x][y] == 2) {
							fprintf(fp, "◆");
						}
						placed = 1;
					}
				}
			}
			if (placed == 0) {
				if (reversi_board[x][y] == 1) {
					fprintf(fp, "○");
				}
				if (reversi_board[x][y] == 2) {
					fprintf(fp, "●");
				}
			}
		}
	}
	if (reversi_board[x][y] == 0) {
		fprintf(fp, "%s", k);
	}
	return;
}

void reversi_return_grid(int x, int y) {
	char k[3] = "□";
	char k2[3];
	strcpy(k, "□");
	if (x==0) {
		strcpy(k, "□");
	}
	if (x==reversi_boardsize-1) {
		strcpy(k, "□");
	}
	if (y==0) {
		strcpy(k, "□");
	}
	if (y==reversi_boardsize-1) {
		strcpy(k, "□");
	}
	if ((x==0) && (y==0)) {
		strcpy(k, "□");
	}
	if ((x==reversi_boardsize-1) && (y==0)) {
		strcpy(k, "□");
	}
	if ((x==reversi_boardsize-1) && (y==reversi_boardsize-1)) {
		strcpy(k, "□");
	}
	if ((x==0) && (y==reversi_boardsize-1)) {
		strcpy(k, "□");
	}
	if (x == reversi_boardsize) {
		if (y < reversi_boardsize) {
			if (y > reversi_boardsize - 10) {
				strcpy(k, " "); 
			} else {
				strcpy(k, "");
			}
			sprintf(k2, "%d", reversi_boardsize - y);
			strcat(k, k2);
		} else {
			strcpy(k, "  ");
		}
	}
	if ((x > reversi_boardsize) || (y >= reversi_boardsize)) {
		strcpy(k, "  ");
	}
	if (x < reversi_boardsize) {
		if (y < reversi_boardsize) {
			if ((reversi_board[x][y] > 0) && (reversi_board[x][y] < 3)) {
				prints("\033[1;37m");
				if (reversi_count > 0) {
					if (num_str[x][0] == reversi_log_x[reversi_count - 1]) {
						if (y == reversi_log_y[reversi_count - 1]) {
							prints("\033[1;33m");
						}
					}
				}

				if (reversi_board[x][y] == 1) {
					prints("○");
				}
				if (reversi_board[x][y] == 2) {
					prints("●");
				}
			}
		}
	}
	if (reversi_board[x][y] == 0) {
		prints("\033[0m");
		prints(k);
	}
	return;
}


static void import_reversi() {
	FILE   *inf;
	char buf[256];
	char pi[10];
	int i;
	int j;
	int k;
	int k2;
	int cline = 0;
	int go_start;
	int dpoint = 0;

	pi[2] = '\0';
	if ((inf = fopen(quote_file, "r"))) {
		/* char   *ptr; */
		while (fgets(buf, 256, inf) && buf[0] != '\n');

		while (fgets(buf, 256, inf)) {
			if (cline > 0) {
				if (cline == 1) {
					pi[0] = buf[0];
					pi[1] = buf[1];
					pi[2] = '\0';
					reversi_boardsize = atoi(pi);
				}
				if (cline < 17) {
					for (i = 0; i<16; i++) {
						pi[0] = buf[2 + i*2];
						pi[1] = buf[3 + i*2];
						pi[2] = '\0';
						trim(pi);
						reversi_board[i][cline-1] = 0;

						/*  use else instead of if only */
						if (strcmp(pi, "○")==0) {
							reversi_board[i][cline-1] = 1;
						} else if (strcmp(pi, "●")==0) {
							reversi_board[i][cline-1] = 2;
						} else if (strcmp(pi, "◇")==0) {
							reversi_board[i][cline-1] = 1;
						} else if (strcmp(pi, "◆")==0) { 
							reversi_board[i][cline-1] = 2;
						}
					}
				}
				if ((cline == 2) || (cline == 3)) {
					for ( dpoint=52 ; !((buf[dpoint]==' ') || (buf[dpoint]=='\0')); dpoint++);
					for (j=0; j<dpoint-52; j++) {
						pi[j] = buf[52+j];
					}
					pi[dpoint-52] = '\0';
					if (strcmp(pi, "INSERT-COIN")==0) {
						strcpy(pi, "???");
					}
					if (cline == 2) {
						strcpy(reversi_user1, pi);
					}
					if (cline == 3) {
						strcpy(reversi_user2, pi);
					}
				}

				if (cline == 5) {
					pi[0] = buf[61];
					pi[1] = '\0';
					if (buf[62] != ' ') {
						pi[1] = buf[62];
						pi[2] = '\0';
						if (buf[63] != ' ') {
							pi[2] = buf[63];
							pi[3] = '\0';
						}
					}
					reversi_count = atoi(pi);
					reversi_old_count = reversi_count;
					for (k = 0; k<reversi_count; k++) {
						reversi_log_x[k] = 'H';
						reversi_log_y[k] = 8;
					}
					reversi_now_side = reversi_count % 2 + 1;
				}

				if ((cline > 8) && (cline < 16)) {
					go_start = 0;
					if (reversi_count > 80) { 
						go_start = (reversi_count / 8 * 8) - 72;
					}
					for (k=0; k<8; k++) {
						k2 = (cline - 9) * 8 + k + go_start;
						if (k2 < reversi_count) {
							reversi_log_x[k2] = buf[44 + k*4];
							if (buf[46 + k*4] == ' ') {
								pi[0] = buf[45 + k*4];
								pi[1] = '\0';
							} else {
								pi[0] = buf[45 + k*4];
								pi[1] = buf[46 + k*4];
								pi[2] = '\0';
							}
/** START 24-08-2004 */							
							if (pi[0]=='S') {
								//is pass
								reversi_log_x[k2] = num_str3;
								reversi_log_y[k2] = 99;
							} else {
								reversi_log_y[k2] = reversi_boardsize - atoi(pi);
							}
/** END 24-08-2004 */
						}
					}
				}
			}
			cline++;
		}
	}
}

void reversi_new_board() {
	int i;
	int j;
	for (i=0; i<16; i++) {
		for (j=0; j<16; j++) {
			reversi_board[i][j] = 0;
		}
	}
	reversi_mode = 0;
	reversi_init();
}

void reversi_movecur() {
	move(reversi_nowy + 3, reversi_nowx*2 + 4);
}

void reversi_drawline(int line) {
	int i = 0;
	int i2, log, k;
	int go_start;
	move(line, 0);
	clrtoeol();
	prints("  ");
	if (line == 0) {
		if (reversi_played > 1) {
			prints("注意: 你在這次編輯中下子多過一著");
		} else {
			prints("\033[33;44m   討論區五子棋                          ver 1.24 by phchui (bbs.hkday.net)   \033[0m");
		}
	}
	if (line == 2) {
		prints("  ");
		for (i=0; i<16; i++) {
			if (i < reversi_boardsize) {
				prints("%s", num_str2[i]);
			} else {
				prints("  ");
			}
		}
		prints("  ");
	}
	if ((line >= 3) && (line <=21)) {
		if (line - 3 < reversi_boardsize) {
			if (line > reversi_boardsize - 7) {
				prints(" "); 
			}
			prints("%d", 3 + reversi_boardsize - line);
		} else {
			prints("  ");
		}
		for (i=0; i<20; i++) {
			reversi_return_grid(i, line-3);
		}
		prints("\033[0m");
	}
	if (line == 4) {
		prints("  ");
		if (reversi_now_side == 1) {
			prints("→"); 
		} else {
			prints("  ");
		}

		if (strcmp(reversi_user1, "???")==0) {
			prints("黑○：INSERT-COIN "); 
		} else {
			prints("黑○：%s ", reversi_user1);
		}
	}
	if (line == 5) {
		prints("  ");
		if (reversi_now_side == 2) {
			prints("→"); 
		} else {
			prints("  ");
		}
		if (strcmp(reversi_user2, "???")==0) {
			prints("白●：INSERT-COIN ");
		} else {
			prints("白●：%s ", reversi_user2);
		}
	}
	if (line == 7) {
		prints("第 %d 著", reversi_count+1);
	}
	if (line == 8) {
/** Start 24-08-2004 */		
		if (reversi_now_side == 1) {
			prints("輪到黑方下子");
		} if (reversi_now_side == 2) {
			prints("輪到白方下子");
		} else {
			prints("此局結束");
		}
/** End 24-08-2004 */
	}
	if (line==10) {
		go_start = 0;
		if (reversi_count > 80) {
			go_start = (reversi_count / 8 * 8) - 72;
			prints("  -(最頂為第 %d 著)---------------", go_start);
		} else {
			prints("  --------------------------------");
		}
	}
	if (i==21) {
		prints("  --------------------------------");
	}

	if ((line>10) && (line<21)) {
		i2 = line - 11;
		go_start = 0;
		if (reversi_count > 80) {
			go_start = (reversi_count / 8 * 8) - 72;
		}

		prints("  ");
		for (k=0; k<8; k++) {
			log = i2*8+k + go_start;
			if (log < reversi_count) {
				
/** START 24-08-2004 */
				if (reversi_log_y[log] == 99) {
					//pass
					prints("PS  ");
				} else {
					prints("%c%d", reversi_log_x[log], reversi_boardsize-reversi_log_y[log]);
					if (reversi_log_y[log]>reversi_boardsize - 10) {
						prints(" "); 
					}
					prints(" ");
				}
/** End 24-08-2004 */									

			}
		}
	}
	if (line == 22) {
		if (reversi_count == 0) {
			prints("  前設佈置: [\033[1;33mM\033[0m] 調整棋盤 ");
			prints("[\033[1;33mA\033[0m] 放置黑子 ");
			prints("[\033[1;33mB\033[0m] 放置白子 ");
			prints("[\033[1;33mC\033[0m] 重設棋盤 ");
		}
	}
	if (line == 23) {
		prints("  按 [\033[1;32m2846\033[0m] 方向控制 ["
			"\033[1;32mSPACE\033[0m] ");
		if (reversi_played > 0) {
			prints("決定下子 ");
		} else {
			prints("下子並開始遊戲 ");
		}
		if (reversi_played > 0) {
			prints("[\033[1;32mS\033[0m] 儲存並退出 ");
		}
		prints("[\033[1;32mQ\033[0m] 取消並退出");
	}
	return;
}

void reversi_init_ai() {
	int i;
	int j;
	for (i=0; i<20; i++) {
		for (j=0; j<20; j++) {
			reversi_ai_board[i][j] = 0;
		}
	}
}

void put_reversi(int side) {
	int original;
	// int ki_pt;
	if (reversi_board[reversi_nowx][reversi_nowy] != 0) {
		return;
	}

	original = reversi_board[reversi_nowx][reversi_nowy];
	reversi_board[reversi_nowx][reversi_nowy] = side;

	if (reversi_nowx >= 0) {

		reversi_log_x[reversi_count] = num_str[reversi_nowx][0];
		reversi_log_y[reversi_count] = reversi_nowy;
		reversi_count++;
		reversi_played++;
		if (side == 1) {
			strcpy(reversi_user1, currutmp->userid);
		} if (side == 2) {
			strcpy(reversi_user2, currutmp->userid);
		}
		if (side == 1) {
			reversi_now_side = 2;
		} else {
			reversi_now_side = 1;
		}
	}
}

static void display_reversi() {
	int i;
	/* int j; */

	for (i=0; i<24; i++) {
		reversi_drawline(i);
/* 19┌┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┐19
18├┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┤18  → 黑○：UserA
17├┼○┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┤17 白●：UserB
16├┼┼＋┼┼┼┼┼＋┼┼┼┼┼＋┼┼┤16
15├┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┤15 第 5 著
14├┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┤14 輪到黑方下子
13├┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┤13
12├┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┤12
11├┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┤11 黑方得子：0
10├┼┼＋┼┼┼┼┼＋┼┼┼┼┼＋┼┼┤10 白方得子：0
9├┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┤ 9
8├┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┤ 8
7├┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┤ 7 黑方pass 0 次
6├┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┤ 6 白方pass 0 次
5├┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┤ 5
4├┼┼＋┼┼┼┼┼＋┼┼┼┼┼＋┼┼┤ 4
3├┼┼●┼┼┼┼┼┼┼┼┼┼┼┼◆┼┤ 3 計點法：空地減死子
2├┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┼┤ 2 黑讓 0 子，貼 3.5 目
1└┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┴┘ 1
ＡＢＣＤＥＦＧＨＪＫＬＭＮＯＰＱＲＳＴ*/
	}
}

static void display_reversi_win(int who_win) {
	if (who_win == 1) {
		prints("          黑○：%s 已經贏了", reversi_user1);
	} else if (who_win == 2) {
		prints("          白●：%s 已經贏了", reversi_user2);
	} else if (who_win == 3) {
		prints("          打成平手, 請開新局");
	} 
}


/* 主程式、鍵盤處理 */
int vedit_reversi(char *fpath, int saveheader, int *islocal) {
	int ch;
	int exit_flag = 0;
	int result = 0;
	int rtn_val = 0;

	reversi_boardsize = 8;
	reversi_nowx = 0;
	reversi_nowy = 0;
	reversi_now_side = 1;
	reversi_count = 0;
	reversi_old_count = 0;
	reversi_played   = 0;
	reversi_new_board();
	strcpy(reversi_user1, "???");
	strcpy(reversi_user2, "???");

	if (*quote_file) {
		import_reversi();
	}

	result = reversi_who_wins();

	clear();
	if (result == 0) {
		display_reversi();
	} else {
		exit_flag = 1;
		display_reversi_win(result);
	}

	while (exit_flag == 0) {
		reversi_movecur();
		oflush();
		ch = igetkey();

		switch (ch) {
			case 'M' :
			case 'm' :
				if (reversi_count ==0) {
					reversi_mode++;
					if (reversi_mode > 1) {
						reversi_mode = 0;
					}
					reversi_init();
					display_reversi();
				}
				break;
			case KEY_UP :
			case '8' :
				reversi_nowy--;
				if (reversi_nowy < 0) {
					reversi_nowy = reversi_boardsize-1;
				}
				break;
			case KEY_DOWN :
			case '2' :
				reversi_nowy++;
				if (reversi_nowy >= reversi_boardsize) {
					reversi_nowy = 0; 
				}
				break;
			case KEY_LEFT :
			case '4' :
				reversi_nowx--;
				if (reversi_nowx < 0) {
					reversi_nowx = reversi_boardsize-1;
				}
				break;
			case KEY_RIGHT :
			case '6' :
				reversi_nowx++;
				if (reversi_nowx >= reversi_boardsize) {
					reversi_nowx = 0;
				}
				break;
			case ' ' :
/**	Start 25-08-2004 */
				//only can play 1 per round
				if (reversi_played > 0) {
					break;
				}
/**	End 25-08-2004 */
				//put_reversi(reversi_now_side);
				rtn_val = reversi_play(reversi_now_side, reversi_nowx, reversi_nowy);
				display_reversi();
				break;
			case 'A':
			case 'a':
				if (reversi_count > 0) {
					break;
				}
				if (reversi_board[reversi_nowx][reversi_nowy] == 1) {
					reversi_board[reversi_nowx][reversi_nowy] = 0;
				} else {
					reversi_board[reversi_nowx][reversi_nowy] = 1;
				}
				reversi_drawline(reversi_nowy + 3);
				break;
			case 'B':
			case 'b':
				if (reversi_count > 0) {
					break;
				}
				if (reversi_board[reversi_nowx][reversi_nowy] == 2) {
					reversi_board[reversi_nowx][reversi_nowy] = 0;
				} else {
					reversi_board[reversi_nowx][reversi_nowy] = 2;
				}
				reversi_drawline(reversi_nowy + 3);
				break;
			case 'C':
			case 'c':
				if (reversi_count > 0) {
					break; 
				}
				reversi_new_board();
				display_reversi();
				break;
			case 'S':
			case 's':
				if (reversi_played > 0) {
					result = reversi_next();
/** start 25-04-2004 */					
					reversi_write_file(fpath, NULL);
					
					if (result == 1 ) {
						//black can't move, white con't
						clear();
						prints("          黑方無處下子, 白方繼續下子\n");
					} else if (result == 2 ) {
						//white can't move, black con't
						clear();
						prints("          白方無處下子, 黑方繼續下子\n");
					} else {
						result = reversi_who_wins();
						if (result != 0) {
							clear();
							display_reversi_win(result);
						}
					}
/** end 25-04-2004 */
					return 0;
				} else {
					move(0,0);
					clrtoeol();
					prints("你未下棋不能儲存");
				}
				break;
			case 'Q':
			case 'q':
				exit_flag = 1;
				return -1;
				break;
		}
	}
	return -1;
}