//*********************************************************
bool Turn(QueueType & pQueue, VecSetType & squadSetVec, MapSquadType & squadMap, ArsenalType & arsenal){
bool over= false;
Player * p;
p= pQueue.front();
pQueue.pop();
p->ResetMomentum();
if( p->IsHuman())
{
HumanTurn(squadMap, arsenal, p);
}
else
{
BugTurn(squadMap, arsenal, p);
}
pQueue.push(p);
DeletePlayers(pQueue, squadSetVec, squadMap);
over= CheckOver(squadSetVec);
return over;
}
unsigned UnwrappedLineFormatter::analyzeSolutionSpace(LineState &InitialState,
bool DryRun) {
std::set<LineState *, CompareLineStatePointers> Seen;
// Increasing count of \c StateNode items we have created. This is used to
// create a deterministic order independent of the container.
unsigned Count = 0;
QueueType Queue;
// Insert start element into queue.
StateNode *Node =
new (Allocator.Allocate()) StateNode(InitialState, false, nullptr);
Queue.push(QueueItem(OrderedPenalty(0, Count), Node));
++Count;
unsigned Penalty = 0;
// While not empty, take first element and follow edges.
while (!Queue.empty()) {
Penalty = Queue.top().first.first;
StateNode *Node = Queue.top().second;
if (!Node->State.NextToken) {
DEBUG(llvm::dbgs() << "\n---\nPenalty for line: " << Penalty << "\n");
break;
}
Queue.pop();
// Cut off the analysis of certain solutions if the analysis gets too
// complex. See description of IgnoreStackForComparison.
if (Count > 10000)
Node->State.IgnoreStackForComparison = true;
if (!Seen.insert(&Node->State).second)
// State already examined with lower penalty.
continue;
FormatDecision LastFormat = Node->State.NextToken->Decision;
if (LastFormat == FD_Unformatted || LastFormat == FD_Continue)
addNextStateToQueue(Penalty, Node, /*NewLine=*/false, &Count, &Queue);
if (LastFormat == FD_Unformatted || LastFormat == FD_Break)
addNextStateToQueue(Penalty, Node, /*NewLine=*/true, &Count, &Queue);
}
if (Queue.empty()) {
// We were unable to find a solution, do nothing.
// FIXME: Add diagnostic?
DEBUG(llvm::dbgs() << "Could not find a solution.\n");
return 0;
}
// Reconstruct the solution.
if (!DryRun)
reconstructPath(InitialState, Queue.top().second);
DEBUG(llvm::dbgs() << "Total number of analyzed states: " << Count << "\n");
DEBUG(llvm::dbgs() << "---\n");
return Penalty;
}
//*********************************************************
void End(QueueType & pQueue, ArsenalType & arsenal, MapSquadType & squadMap, VecSetType & squadSetVec){
GameOver(pQueue, squadSetVec, squadMap, arsenal);
int qSize= pQueue.size();
Player * p;
for (int i= 0; i < qSize; i++)
{
p= pQueue.front();
pQueue.pop();
delete p;
}
return;
}
void PrioritizedSweeping<M>::batchUpdateQ() {
for ( unsigned i = 0; i < N; ++i ) {
if ( queue_.empty() ) return;
// The state we extract has been processed already
// So it is the future we have to backtrack from.
size_t s1;
std::tie(std::ignore, s1) = queue_.top();
queue_.pop();
queueHandles_.erase(s1);
for ( size_t s = 0; s < S; ++s )
for ( size_t a = 0; a < A; ++a )
if ( checkDifferentSmall(model_.getTransitionProbability(s,a,s1), 0.0) )
stepUpdateQ(s, a);
}
}
//*********************************************************
bool DeletePlayers(QueueType & pQueue, VecSetType & squadSetVec, MapSquadType & squadMap){
Player * p;
int qSize= pQueue.size();
bool del= false;
for (int i= 0; i < qSize; i++)
{
p= pQueue.front();
pQueue.pop();
if (p->IsDead())
{
if (squadSetVec[squadMap[p->Name()]].count(p->Name()))
{
squadSetVec[squadMap[p->Name()]].erase(p->Name());
del= true;
}
//PrintVectorOfSquads(cout , squadSetVec);
}
pQueue.push(p);
}
return del;
}
void spsc_queue_avail_test_run(QueueType & q)
{
BOOST_REQUIRE_EQUAL( q.write_available(), 16 );
BOOST_REQUIRE_EQUAL( q.read_available(), 0 );
for (size_t i = 0; i != 8; ++i) {
BOOST_REQUIRE_EQUAL( q.write_available(), 16 - i );
BOOST_REQUIRE_EQUAL( q.read_available(), i );
q.push( 1 );
}
// empty queue
int dummy;
while (q.pop(dummy))
{}
for (size_t i = 0; i != 16; ++i) {
BOOST_REQUIRE_EQUAL( q.write_available(), 16 - i );
BOOST_REQUIRE_EQUAL( q.read_available(), i );
q.push( 1 );
}
}