bool ProofUtil::ShrinkProof(bitset_t& proof, const StoneBoard& board,
HexColor loser, const ICEngine& ice)
{
StoneBoard brd(board.Width(), board.Height());
PatternState pastate(brd);
Groups groups;
// Give loser all cells outside proof
bitset_t cells_outside_proof = (~proof & brd.Const().GetCells());
brd.AddColor(loser, cells_outside_proof);
// Give winner only his stones inside proof;
HexColor winner = !loser;
brd.AddColor(winner, board.GetPlayed(winner) & proof);
pastate.Update();
GroupBuilder::Build(brd, groups);
// Compute fillin and remove captured cells from the proof
InferiorCells inf;
ice.ComputeFillin(loser, groups, pastate, inf,
HexColorSetUtil::Only(loser));
HexAssert(inf.Captured(winner).none());
bitset_t filled = inf.Dead() | inf.Captured(loser);
bitset_t shrunk_proof = proof - filled;
bool shrunkTheProof = shrunk_proof.count() < proof.count();
proof = shrunk_proof;
return shrunkTheProof;
}
void GroupBuilder::Build(const StoneBoard& brd, Groups& groups)
{
bitset_t visited;
groups.m_brd = const_cast<StoneBoard*>(&brd);
groups.m_groups.clear();
groups.m_group_index.resize(FIRST_INVALID);
for (BoardIterator p(brd.Const().EdgesAndInterior()); p; ++p)
{
if (visited.test(*p))
continue;
bitset_t nbs, members;
HexColor color = brd.GetColor(*p);
Flow(brd, *p, color, members, nbs);
HexAssert((visited & members).none());
visited |= members;
for (BitsetIterator m(members); m; ++m)
groups.m_group_index[*m] = groups.m_groups.size();
groups.m_groups.push_back(Group(&groups, color, *p, members, nbs));
}
for (std::size_t i = 0; i < groups.m_groups.size(); ++i)
{
Group& g = groups.m_groups[i];
g.m_nbs = groups.CaptainizeBitset(g.m_nbs);
for (BitsetIterator p(g.m_nbs); p; ++p)
g.m_nbs_index.push_back(groups.m_group_index[*p]);
}
}
bool GameUtil::SequenceFromPosition(const Game& game, const StoneBoard& pos,
MoveSequence& seq)
{
if (game.Board().Const() != pos.Const())
return false;
StoneBoard cur(pos);
cur.StartNewGame();
if (cur == pos)
{
seq = game.History();
return true;
}
const MoveSequence& history = game.History();
for (MoveSequence::const_iterator it = history.begin();
it != history.end(); ++it)
{
const Move& move = *it;
cur.PlayMove(move.Color(), move.Point());
if (cur == pos)
{
LogInfo() << "Position matched!\n";
seq.assign(++it, history.end());
return true;
}
}
return false;
}
/** Selects random move among the empty cells on the board. */
HexPoint MoHexPlayoutPolicy::GenerateRandomMove(const StoneBoard& brd)
{
HexPoint ret = INVALID_POINT;
while (true)
{
BenzeneAssert(!m_moves.empty());
ret = m_moves.back();
m_moves.pop_back();
if (brd.IsEmpty(ret))
break;
}
return ret;
}
HexPoint MoHexPlayoutPolicy::GenerateResponseMove(HexColor toPlay,
HexPoint lastMove,
const StoneBoard& brd)
{
std::size_t num = m_response[toPlay][lastMove].size();
if (num > m_shared->Config().responseThreshold)
{
HexPoint move = m_response[toPlay][lastMove][m_random.Int(num)];
if (brd.IsEmpty(move))
return move;
}
return INVALID_POINT;
}
void MoHexPlayoutPolicy::InitializeForPlayout(const StoneBoard& brd)
{
m_weights[0].Clear();
m_weights[1].Clear();
for (BitsetIterator it(brd.GetEmpty()); it; ++it)
{
m_weights[0][*it] =
m_globalPatterns.GammaFromKeysBoth(m_board.Keys(*it), BLACK);
m_weights[1][*it] =
m_globalPatterns.GammaFromKeysBoth(m_board.Keys(*it), WHITE);
}
m_weights[0].Build();
m_weights[1].Build();
}
void YSgUtil::SetPositionInNode(SgNode* node, const StoneBoard& brd,
HexColor color)
{
int height = brd.Height();
SgVector<SgPoint> blist = YSgUtil::BitsetToSgVector(brd.GetBlack()
& brd.Const().GetCells(), height);
SgVector<SgPoint> wlist = YSgUtil::BitsetToSgVector(brd.GetWhite()
& brd.Const().GetCells(), height);
SgVector<SgPoint> elist = YSgUtil::BitsetToSgVector(brd.GetEmpty()
& brd.Const().GetCells(), height);
SgPropPlayer* pprop = new SgPropPlayer(SG_PROP_PLAYER);
SgPropAddStone* bprop = new SgPropAddStone(SG_PROP_ADD_BLACK);
SgPropAddStone* wprop = new SgPropAddStone(SG_PROP_ADD_WHITE);
SgPropAddStone* eprop = new SgPropAddStone(SG_PROP_ADD_EMPTY);
pprop->SetValue(YSgUtil::HexColorToSgColor(color));
bprop->SetValue(blist);
wprop->SetValue(wlist);
eprop->SetValue(elist);
node->Add(pprop);
node->Add(bprop);
node->Add(wprop);
node->Add(eprop);
}
void MoHexPlayoutPolicy::InitializeForPlayout(const StoneBoard& brd)
{
BitsetUtil::BitsetToVector(brd.GetEmpty(), m_moves);
ShuffleVector(m_moves, m_random);
}
inline HexUctStoneData::HexUctStoneData(const StoneBoard& brd)
: black(brd.GetBlack()),
white(brd.GetWhite()),
played(brd.GetPlayed())
{
}
inline void HexState::UndoMove(HexPoint move)
{
m_brd.UndoMove(move);
FlipColorToPlay();
}
inline void HexState::PlayMove(HexPoint move)
{
m_brd.PlayMove(m_toPlay, move);
FlipColorToPlay();
}
inline SgHashCode HexState::Hash() const
{
return m_brd.Hash(m_toPlay);
}
inline HexState::HexState(unsigned size)
: m_brd(size),
m_toPlay(m_brd.WhoseTurn())
{
}
