C++ MoveList::Size方法代码示例

    Result guessMove(const char* fen, int square, MoveList& mlist, int thinkTime)
	{
		Result r;
		r.error = -1;
        r.score = 0;

		squareT sq = square;

		Position pos;
		pos.ReadFromFEN(fen);

		pos.GenerateMoves(&mlist);
		mlist.SelectBySquare(sq);
		if (mlist.Size() == 0)
			return r;

        if (mlist.Size() > 1) {
			Engine * engine = new Engine();
            engine->SetSearchTime(thinkTime);
			engine->SetPosition(&pos);
            r.score = engine->Think(&mlist);
			delete engine;
		}

		simpleMoveT * sm = mlist.Get(0);
		ASSERT (sq == sm->from  ||  sq == sm->to);

		r.from = sm->from;
		r.to = sm->to;
		r.error = 0;
		return r;
	}

Move StrToMove(const std::string& str, Position& pos)
{
	for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
	{
		if (isdigit(*it) || *it == 'O')
			break;
		if (*it == ' ' || *it == 0)
			return 0;
	}

	MoveList mvlist;
	mvlist.GenAllMoves(pos);

	for (int n = 0; n < mvlist.Size(); ++n)
	{
		Move mv = mvlist[n].m_mv;
		if (MoveToStrLong(mv) == str)
			return mv;
	}

	for (int n = 0; n < mvlist.Size(); ++n)
	{
		Move mv = mvlist[n].m_mv;
		if (MoveToStrShort(mv, pos) == str)
			return mv;
	}

	return 0;
}

bool Position::IsGameOver(std::string& message)
{
  bool hasMoves = false;
  MoveList mvlist;
  mvlist.GenAllMoves(*this);
  for (int i = 0; i < mvlist.Size(); ++i)
  {
    if (MakeMove(mvlist[i].m_mv))
    {
      hasMoves = true;
      UnmakeMove();
      break;
    }
  }
  
  if (hasMoves == false)
  {
    if (InCheck())
      message = (m_side == WHITE)? "0-1 {Black mates}" : "1-0 {White mates}";
    else
      message = "1/2-1/2 {Draw: stalemate}";
    return true;
  }

  if (EstimateDraw(*this) == EVAL_THEORETICAL_DRAW)
  {
    message = "1/2-1/2 {Draw: material}";
    return true;
  }

  if (GetRepetitions() >= 3)
  {
    message = "1/2-1/2 {Draw: 3rd repetition}";
    return true;
  }

  return false;
}

    // Use chess engine to decide if (from1,to1) is better than (from2,to2) move
	//  it will start from the position given in fen and think for ms milliseconds
	//  0 is returned if the first move is better or 1 if the second is better
	//  -1 is returned on error
	int pickBest(const char* fen, int from1, int to1, int from2, int to2, int ms)
	{
		Position pos;
		pos.ReadFromFEN(fen);

		MoveList mlist;
		pos.GenerateMoves(&mlist);

		mlist.SelectBySquares(from1, to1, from2, to2);
		if (mlist.Size() == 2) {
			Engine * engine = new Engine();
			engine->SetSearchTime(ms);    // Do a "ms" millisecond search
			engine->SetPosition(&pos);
			engine->Think(&mlist);
			delete engine;
			simpleMoveT * sm = mlist.Get(0);
			if (sm->from == from1 && sm->to == to1)
				return 0;
			if (sm->from == from2 && sm->to == to2)
				return 1;
		}
		return -1;
	}

std::string MoveToStrShort(Move mv, Position& pos)
{
	if (mv == Move(E1, G1, KW) || mv == Move(E8, G8, KB))
		return "O-O";
	if (mv == Move(E1, C1, KW) || mv == Move(E8, C8, KB))
		return "O-O-O";

	PIECE piece = mv.Piece();
	FLD from = mv.From();
	FLD to = mv.To();
	PIECE captured = mv.Captured();
	PIECE promotion = mv.Promotion();
	std::string strFrom, strTo, strPiece, strCaptured, strPromotion;

	switch (piece)
	{
	case PW: case PB:
		if (captured)
			strFrom = FldToStr(from).substr(0, 1);
		break;
	case NW: case NB: strPiece = "N"; break;
	case BW: case BB: strPiece = "B"; break;
	case RW: case RB: strPiece = "R"; break;
	case QW: case QB: strPiece = "Q"; break;
	case KW: case KB: strPiece = "K"; break;
	default: break;
	}

	if (captured)
		strCaptured = "x";

	strTo = FldToStr(to);

	switch (promotion)
	{
	case QW: case QB: strPromotion = "=Q"; break;
	case RW: case RB: strPromotion = "=R"; break;
	case BW: case BB: strPromotion = "=B"; break;
	case NW: case NB: strPromotion = "=N"; break;
	default: break;
	}

	// resolve ambiguity

	int uniq_col = 1;
	int uniq_row = 1;
	bool ambiguity = false;

	int row0 = Row(from);
	int col0 = Col(from);

	MoveList mvlist;
	mvlist.GenAllMoves(pos);

	for (int i = 0; i < mvlist.Size(); ++i)
	{
		Move mvi = mvlist[i].m_mv;

		if (mvi.To() != to)
			continue;
		if (mvi.Piece() != piece)
			continue;
		if (mvi.From() == from)
			continue;
		if (!pos.MakeMove(mvi))
			continue;
		pos.UnmakeMove();

		ambiguity = true; // two or more pieces of the same type can move to field
		int row1 = Row(mvi.From());
		int col1 = Col(mvi.From());

		if (row0 == row1)
			uniq_row = 0;

		if (col0 == col1)
			uniq_col = 0;
	}

	if (ambiguity)
	{
		if (uniq_col)
			strFrom = FldToStr(from).substr(0, 1);
		else if (uniq_row)
			strFrom = FldToStr(from).substr(1, 1);
		else
			strFrom = FldToStr(from);
	}

	return strPiece + strFrom + strCaptured + strTo + strPromotion;
}