C++ Moves::push_back方法代码示例

 Moves valid_moves() const {
   int i = space_index();
   int row = i / 4;
   int col = i % 4;
   Moves cand;
   if (row != 0)
     cand.push_back('U');
   if (row != 3)
     cand.push_back('D');
   if (col != 0)
     cand.push_back('L');
   if (col != 3)
     cand.push_back('R');
   return cand;
 }

Moves MoveGenerator::generateOpening(const Board& board) const
{
	Moves result;
	if(board.getIdleCount() == 0)
	{
		QMessageBox::critical(0, "error", "idle == 0");
		return result;
	}
	for(int i=0; i<23; ++i)
	{
		if(board.isEmpty(i))
		{
			Board next = board.makeChild();  // a clone
			next.setManAt(i, board.getSelfColor());
			if(next.closeMill(i))
			{
				Moves removeMoves = generateRemove(next, board.getOpponentColor());  // remove 1 opponent chessman
				copy(removeMoves.begin(), removeMoves.end(), back_inserter(result));
			}
			else
				result.push_back(next);
		}
	}
	return result;
}

const ConnectThree::Move ConnectThree::CheckTwoOther(const std::bitset<3>& is_player_human) const
{
  const Moves moves(GetAllPossibleMoves());

  const int nMoves = moves.size();
  if (nMoves==0) return CreateInvalidMove();
  {
    //Get anti-human moves
    Moves v;
    BOOST_FOREACH(const Move& m, moves)
    {
      assert(CanDoMove(m));
      //Player is human
      if (is_player_human[boost::tuples::get<2>(m)])
        v.push_back(m);
    }
    //If there are anti-player moves, choose one at random
    if (!v.empty())
    {
      const Move m = v[std::rand() % v.size()];
      assert(CanDoMove(m));
      return
        boost::tuples::make_tuple(
          boost::tuples::get<0>(m),
          boost::tuples::get<1>(m),
          boost::tuples::get<2>(m));
    }
  }

Moves BoardC4::get_possible_moves(Token player) const {
	Moves moves;

	for (Size column=0; column<width; column++) {
		if (tokens[column]<=token_for_columns[column]) moves.push_back(new MoveC4(player,column));
	}

	return moves;
}

/*-----------------------------------------------------------------------------*/
void MoveKif::AddBranch(Moves* parent, const MoveKif& move)
{
	this->branches_.emplace_back(new Moves());

	Moves* moves = this->branches_.back().get();

	moves->set_parent(parent);
	moves->push_back(move);
}

void build_path(ull_t v, const Searched & searched, Moves & steps) {
  Searched::const_iterator it = searched.find(v);
  while (it != searched.end()) {
    const State & s = it->second;
    steps.push_back(s.step);
    it = searched.find(s.parent);
  }
  //pop up the first step, which must be 0, rather than one of U,D,L,R
  steps.pop_back();
  reverse(steps.begin(), steps.end());
}

Moves MoveGenerator::generateRemove(const Board& old, QChar color) const
{
	Moves result;
	for(int i=0; i<23; ++i)
	{
		if(old.getManAt(i) == color)
		{
			if(!old.closeMill(i))
			{
				// DO NOT use old.makeChild
				// next is a semi-finished product of a move
				Board next = old;
				next.setManAt(i, 'x');
				result.push_back(next);
			}
		}
	}
	if(result.empty())      // no possible remove
		result.push_back(old);
	return result;
}

Moves MoveGenerator::generateHopping(const Board& board) const
{
	Moves result;
	for(int from=0; from<23; ++from)
		if(board.getManAt(from) == board.getSelfColor())
		{
			for(int to=0; to<23; ++to)
				if(board.isEmpty(to))
				{
					Board next = board.makeChild();
					next.move(from, to);
					if(next.closeMill(to))
					{
						Moves removeMoves = generateRemove(next, board.getOpponentColor());
						copy(removeMoves.begin(), removeMoves.end(), back_inserter(result));
					}
					else
						result.push_back(next);
				}
		}
	return result;
}

Moves MoveGenerator::generateMove(const Board& board) const
{
	Moves result;
	for(int from=0; from<23; ++from)
		if(board.getManAt(from) == board.getSelfColor())
		{
			Neighbors neighbors = Board::getNeighbors(from);
			for(Neighbors::iterator it = neighbors.begin(); it != neighbors.end(); ++it)
				if(board.isEmpty(*it))
				{
					Board next = board.makeChild();
					next.move(from, *it);
					if(next.closeMill(*it))
					{
						Moves removeMoves = generateRemove(next, board.getOpponentColor());
						copy(removeMoves.begin(), removeMoves.end(), back_inserter(result));
					}
					else
						result.push_back(next);
				}
		}
		return result;
}