JBoolean
JXComposeRuleList::MatchesRule
(
const KeySym keySym,
JCharacter* buffer
)
{
itsInputSeq->AppendElement(keySym);
Rule target(itsInputSeq, XK_space);
JBoolean found;
const JIndex index =
itsRuleList->SearchSorted1(target, JOrderedSetT::kAnyMatch, &found);
if (found)
{
const Rule r = itsRuleList->GetElement(index);
buffer[0] = r.GetOutputCharacter();
ClearState();
return kJTrue; // process it (rule fired)
}
else if (itsRuleList->IndexValid(index))
{
const Rule r = itsRuleList->GetElement(index);
JBoolean isPrefix;
CompareRulesWithPrefix(target, r, &isPrefix);
if (isPrefix)
{
return kJFalse; // don't process it yet (expecting rule to fire)
}
}
ClearState();
return kJTrue; // process it (not an input sequence)
}
/// <summary>
/// Activates this button.
/// </summary>
void TaskButton::Activate() {
ActivateState(State::Active);
ClearState(State::Minimized);
if (mIsFlashing) {
ClearState(State::Flashing);
mWindow->ClearCallbackTimer(mFlashTimer);
mIsFlashing = false;
}
}
void TaskButton::ActivateState(State state) {
mPane->ActivateState(state);
if (state == State::Active) {
if (mFlashInterval) {
nCore::ClearInterval(mFlashInterval);
mFlashInterval = 0;
ClearState(State::Flashing);
}
ClearState(State::Minimized);
}
}
void PerconaFTIterator::JumpToLast()
{
ClearState();
if (NULL == m_cursor)
{
return;
}
int ret = 0;
if (m_iterate_upper_bound_key.GetType() > 0)
{
DoJump(m_iterate_upper_bound_key);
if (!m_valid)
{
CHECK_EXPR((ret = m_cursor->c_getf_last(m_cursor, 0, nil_callback, NULL)));
}
if (0 == ret)
{
Prev();
}
}
else
{
CHECK_EXPR((ret = m_cursor->c_getf_last(m_cursor, 0, nil_callback, NULL)));
if (ret != 0)
{
m_valid = false;
return;
}
}
}
nsresult
nsDocShellEnumerator::SetEnumDocShellType(int32_t aEnumerationItemType)
{
mDocShellType = aEnumerationItemType;
ClearState();
return NS_OK;
}
JXComposeRuleList::JXComposeRuleList
(
std::istream& input,
const JSize charCount,
JBoolean* isCharInWord,
JCharacter* diacriticalMap,
JIndex* diacriticalMarkType
)
{
itsRuleList = jnew JArray<Rule>(100);
assert( itsRuleList != NULL );
itsRuleList->SetCompareFunction(CompareRules);
itsInitialKeySymList = jnew JArray<KeySym>(10);
assert( itsInitialKeySymList != NULL );
itsInputSeq = jnew JArray<KeySym>;
assert( itsInputSeq != NULL );
ClearState();
JXComposeScanner scanner;
scanner.BuildRuleList(input, this, charCount, isCharInWord,
diacriticalMap, diacriticalMarkType);
}
LRESULT TaskButton::HandleMessage(HWND window, UINT msg, WPARAM wParam, LPARAM lParam, NPARAM) {
switch (msg) {
case WM_MOUSEMOVE:
ActivateState(State::Hover);
return 0;
case WM_MOUSELEAVE:
ClearState(State::Hover);
return 0;
case WM_TIMER:
if (wParam == mFlashInterval) {
mPane->ToggleState(State::Flashing);
}
return 0;
case WM_LBUTTONUP:
SelectTask();
return 0;
case WM_RBUTTONUP:
ShowContextMenu();
return 0;
case WM_MBUTTONUP:
OpenTaskProcess();
return 0;
}
return mEventHandler->HandleMessage(window, msg, wParam, lParam, this);
};
nsresult
nsDocShellEnumerator::SetEnumerationRootItem(
nsIDocShellTreeItem* aEnumerationRootItem)
{
mRootItem = do_GetWeakReference(aEnumerationRootItem);
ClearState();
return NS_OK;
}
void Creature::AIM_Update(const uint32 &diff)
{
switch( m_deathState )
{
case JUST_DIED:
{
SetUInt32Value(UNIT_NPC_FLAGS, 0);
m_deathState = CORPSE;
i_AI->UpdateAI(diff);
break;
}
case DEAD:
{
if( m_respawnTimer <= diff )
{
DEBUG_LOG("Respawning...");
SetUInt32Value(UNIT_FIELD_HEALTH, GetUInt32Value(UNIT_FIELD_MAXHEALTH));
m_deathState = ALIVE;
ClearState(ALL_STATE);
i_motionMaster.Clear();
MapManager::Instance().GetMap(GetMapId())->Add(this);
}
else
m_respawnTimer -= diff;
break;
}
case CORPSE:
{
if( m_deathTimer <= diff )
{
DEBUG_LOG("Removing corpse...");
ObjectAccessor::Instance().RemoveCreatureCorpseFromPlayerView(this);
setDeathState(DEAD);
m_respawnTimer = m_respawnDelay;
GetRespawnCoord(m_positionX, m_positionY, m_positionZ);
}
else
m_deathTimer -= diff;
break;
}
case ALIVE:
{
Unit::Update( diff );
i_AI->UpdateAI(diff);
i_motionMaster.UpdateMotion(diff);
break;
}
default:
break;
}
}
void PerconaFTIterator::Prev()
{
ClearState();
int ret = m_cursor->c_getf_prev(m_cursor, 0, nil_callback, NULL);
if (ret != 0)
{
m_valid = false;
return;
}
}
void PerconaFTIterator::Next()
{
ClearState();
int ret = m_cursor->c_getf_next(m_cursor, 0, nil_callback, NULL);
if (ret != 0)
{
m_valid = false;
return;
}
CheckBound();
}
NS_IMETHODIMP nsAccessibleTreeWalker::PushState()
{
// Duplicate mState and put right before end; reset mState; make mState the new end of the stack
WalkState* nextToLastState= new WalkState();
if (!nextToLastState)
return NS_ERROR_OUT_OF_MEMORY;
*nextToLastState = mState; // Deep copy - copy contents of struct to new state that will be added to end of our stack
ClearState();
mState.prevState = nextToLastState; // Link to previous state
return NS_OK;
}
static void GetState(RectArea *root, boolean *state) {
RectArea *current = root;
ClearState(state);
while (current)
{
WarnIfNonOptimal(¤t->rect);
WriteGeomToState(¤t->rect, state);
current = current->next;
}
}
void PerconaFTIterator::JumpToFirst()
{
ClearState();
if (NULL == m_cursor)
{
return;
}
int ret;
CHECK_EXPR((ret = m_cursor->c_getf_first(m_cursor, 0, nil_callback, NULL)));
if (ret != 0)
{
m_valid = false;
}
}
//-----------------------------------------------------------------------
void CSpectacularKill::End(bool bKillerDied/* = false*/)
{
CRY_ASSERT_MESSAGE(IsBusy(), "spectacular kill cannot be stopped if it is not in progress");
if (!IsBusy())
return;
ICooperativeAnimationManager* pCooperativeAnimationManager = gEnv->pGame->GetIGameFramework()->GetICooperativeAnimationManager();
CActor* pTarget = GetTarget();
CRY_ASSERT(pTarget);
if(pTarget)
{
pCooperativeAnimationManager->StopCooperativeAnimationOnActor(m_pOwner->GetAnimatedCharacter(), pTarget->GetAnimatedCharacter());
// Enable AI again (for what it's worth - this helps editor)
if (!pTarget->IsPlayer() && pTarget->GetEntity()->GetAI())
pTarget->GetEntity()->GetAI()->Event(AIEVENT_ENABLE, 0);
if (bKillerDied && (m_deathBlowState == eDBS_None) && static_cast<CPlayer*> (pTarget)->CanFall())
{
// Enable Fall n Play on target if killer dies before death blowing it
pTarget->Fall();
}
else if (m_deathBlowState != eDBS_Done)
{
DeathBlow(*pTarget); // Call this in case the notification from the animation system got skipped or missed for some reason
}
SActorStats* pTargetStats = pTarget->GetActorStats();
pTargetStats->spectacularKillPartner = 0;
}
else
{
pCooperativeAnimationManager->StopCooperativeAnimationOnActor(m_pOwner->GetAnimatedCharacter());
}
// Enable AI again (for what it's worth - this helps editor)
if (m_pOwner && m_pOwner->GetEntity()->GetAI())
m_pOwner->GetEntity()->GetAI()->Event(AIEVENT_ENABLE, 0);
ClearState();
assert(m_pOwner);
SActorStats* pStats = m_pOwner->GetActorStats();
if(pStats)
pStats->spectacularKillPartner = 0;
}
NS_IMETHODIMP nsAccessibleTreeWalker::PopState()
{
nsIFrame *frameParent = mState.frame? mState.frame->GetParent(): nsnull;
if (mState.prevState) {
WalkState *toBeDeleted = mState.prevState;
mState = *mState.prevState; // deep copy
mState.isHidden = PR_FALSE; // If we were in a child, the parent wasn't hidden
if (!mState.frame) {
mState.frame = frameParent;
}
delete toBeDeleted;
return NS_OK;
}
ClearState();
mState.frame = frameParent;
mState.isHidden = PR_FALSE;
return NS_ERROR_FAILURE;
}
void PerconaFTIterator::DoJump(const KeyObject& next)
{
ClearState();
if (NULL == m_cursor)
{
return;
}
PerconaFTLocalContext& local_ctx = g_local_ctx.GetValue();
Slice ks = local_ctx.GetSlice(next);
DBT key_slice = to_dbt(ks);
int ret = m_cursor->c_getf_set_range(m_cursor, DB_SET_RANGE, &key_slice, nil_callback, NULL);
if (ret != 0)
{
m_valid = false;
return;
}
}
// Highlights the current line according to the state requested;
// check to see if the node of type "state" is present;
// if it is, the node is formatted
void XHTMLHighlighter::HighlightLine(const QString &text, int state)
{
QRegularExpression left_bracket_regex = GetLeftBracketRegEx(state);
QRegularExpression right_bracket_regex = GetRightBracketRegEx(state);
int main_index = 0;
// We loop over the line several times
// because we could have several nodes on it
while (main_index < text.length()) {
int left_bracket_index = -1;
int left_bracket_len = 0;
int right_bracket_index = -1;
int right_bracket_len = 0;
if (!left_bracket_regex.pattern().isEmpty()) {
QRegularExpressionMatch left_bracket_match = left_bracket_regex.match(text, main_index);
if (left_bracket_match.hasMatch()) {
left_bracket_index = left_bracket_match.capturedStart();
left_bracket_len = left_bracket_match.capturedLength();
}
}
if (!right_bracket_regex.pattern().isEmpty()) {
QRegularExpressionMatch right_bracket_match = right_bracket_regex.match(text, main_index);
if (right_bracket_match.hasMatch()) {
right_bracket_index = right_bracket_match.capturedStart();
right_bracket_len = right_bracket_match.capturedLength();
}
}
// If we are not starting our state and our state is
// not already set, we don't format; see the four cases explanation below
if (left_bracket_index == -1 && !StateChecked(state)) {
return;
}
// Every node/state has a left "bracket", a right "bracket" and the inside body.
// This example uses HTML tags, but the principle is the same for every node/state.
// There are four possible cases:
// (1) <......> (both brackets on the same line; state starts and stops here)
// (2) <....... (only the left bracket; next line continues state)
// (3) .......> (only the right bracket; current line ends state)
// (4) ........ (no brackets; a line between (2) and (3))
// We also check the state because we don't want to start a new node
// if the current node of the same type hasn't finished
if (left_bracket_index != -1 && !StateChecked(state)) {
main_index = left_bracket_index + left_bracket_len;
// (1)
if (right_bracket_index != -1) {
main_index = right_bracket_index + right_bracket_len;
int length = right_bracket_index - left_bracket_index + right_bracket_len;
FormatBody(text, state, left_bracket_index, length);
// There's no point in setting the state here because the state
// starts and ends on this line.
}
// (2)
else {
int length = text.length() - left_bracket_index;
FormatBody(text, state, left_bracket_index, length);
main_index += length;
// Set the current state so the next line can continue
// with the formatting.
SetState(state);
}
} else {
// (3)
if (right_bracket_index != -1) {
main_index = right_bracket_index + right_bracket_len;
int length = right_bracket_index + right_bracket_len;
FormatBody(text, state, 0, length);
// Clear the current state because our state has just ended.
ClearState(state);
}
// (4)
else {
int length = text.length();
FormatBody(text, state, 0, length);
main_index += length;
}
}
}
}
//-----------------------------------------------------------------------
void CSpectacularKill::Reset()
{
ClearState();
}
StdStrBuf C4RTFFile::GetPlainText()
{
// clear any previous crap
ClearState();
// start with a fresh state
pState = new PropertyState();
pState->eState = psNormal;
StdStrBuf sResult;
// nothing to do for empty RTFs
if (sRTF.getSize()<=0) return sResult;
// parse through all chars
try
{
char c; size_t iPos = 0;
while (iPos < sRTF.getSize())
{
c = ((const char *) sRTF.getData())[iPos++];
// binary parsing?
if (pState->eState == psBinary)
{
if (!--pState->iHexBinCnt) pState->eState = psNormal;
ParseChar(sResult, c);
continue;
}
// normal parsing: Handle state blocks
switch (c)
{
case '{': PushState(); break;
case '}': PopState(); break;
case '\\':
ParseKeyword(sResult, iPos);
break;
case 0x0d: case 0x0a: // ignored chars
break;
default:
// regular char parsing
if (pState->eState == psNormal)
// normal mode
ParseChar(sResult, c);
else if (pState->eState == psHex)
ParseHexChar(sResult, c);
else
throw new ParserError("Invalid State");
break;
}
// next char
}
// all states must be closed in the end
if (pState->pNext) throw new ParserError("Block not closed");
}
catch (ParserError *pe)
{
// invalid RTF file: Display error message instead
sResult = "Invalid RTF file: ";
sResult.Append(pe->ErrorText);
delete pe;
}
// cleanup
ClearState();
// return result
return sResult;
}
void FD3D11DynamicRHI::InitD3DDevice()
{
check( IsInGameThread() );
// Wait for the rendering thread to go idle.
SCOPED_SUSPEND_RENDERING_THREAD(false);
// If the device we were using has been removed, release it and the resources we created for it.
if(bDeviceRemoved)
{
UE_LOG(LogD3D11RHI, Log, TEXT("bDeviceRemoved"));
check(Direct3DDevice);
HRESULT hRes = Direct3DDevice->GetDeviceRemovedReason();
const TCHAR* Reason = TEXT("?");
switch(hRes)
{
case DXGI_ERROR_DEVICE_HUNG: Reason = TEXT("HUNG"); break;
case DXGI_ERROR_DEVICE_REMOVED: Reason = TEXT("REMOVED"); break;
case DXGI_ERROR_DEVICE_RESET: Reason = TEXT("RESET"); break;
case DXGI_ERROR_DRIVER_INTERNAL_ERROR: Reason = TEXT("INTERNAL_ERROR"); break;
case DXGI_ERROR_INVALID_CALL: Reason = TEXT("INVALID_CALL"); break;
}
bDeviceRemoved = false;
// Cleanup the D3D device.
CleanupD3DDevice();
// We currently don't support removed devices because FTexture2DResource can't recreate its RHI resources from scratch.
// We would also need to recreate the viewport swap chains from scratch.
UE_LOG(LogD3D11RHI, Fatal, TEXT("The Direct3D 11 device that was being used has been removed (Error: %d '%s'). Please restart the game."), hRes, Reason);
}
// If we don't have a device yet, either because this is the first viewport, or the old device was removed, create a device.
if(!Direct3DDevice)
{
UE_LOG(LogD3D11RHI, Log, TEXT("!Direct3DDevice"));
check(!GIsRHIInitialized);
// Clear shadowed shader resources.
ClearState();
// Determine the adapter and device type to use.
TRefCountPtr<IDXGIAdapter> Adapter;
// In Direct3D 11, if you are trying to create a hardware or a software device, set pAdapter != NULL which constrains the other inputs to be:
// DriverType must be D3D_DRIVER_TYPE_UNKNOWN
// Software must be NULL.
D3D_DRIVER_TYPE DriverType = D3D_DRIVER_TYPE_UNKNOWN;
uint32 DeviceFlags = D3D11RHI_ShouldAllowAsyncResourceCreation() ? 0 : D3D11_CREATE_DEVICE_SINGLETHREADED;
// Use a debug device if specified on the command line.
const bool bWithD3DDebug = D3D11RHI_ShouldCreateWithD3DDebug();
if (bWithD3DDebug)
{
DeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
UE_LOG(LogD3D11RHI, Log, TEXT("InitD3DDevice: -D3DDebug = %s"), bWithD3DDebug ? TEXT("on") : TEXT("off"));
}
GTexturePoolSize = 0;
TRefCountPtr<IDXGIAdapter> EnumAdapter;
if(DXGIFactory1->EnumAdapters(ChosenAdapter,EnumAdapter.GetInitReference()) != DXGI_ERROR_NOT_FOUND)
{
if (EnumAdapter)// && EnumAdapter->CheckInterfaceSupport(__uuidof(ID3D11Device),NULL) == S_OK)
{
DXGI_ADAPTER_DESC AdapterDesc;
if (SUCCEEDED(EnumAdapter->GetDesc(&AdapterDesc)))
{
Adapter = EnumAdapter;
GRHIAdapterName = AdapterDesc.Description;
GRHIVendorId = AdapterDesc.VendorId;
// Issue: 32bit windows doesn't report 64bit value, we take what we get.
FD3D11GlobalStats::GDedicatedVideoMemory = int64(AdapterDesc.DedicatedVideoMemory);
FD3D11GlobalStats::GDedicatedSystemMemory = int64(AdapterDesc.DedicatedSystemMemory);
FD3D11GlobalStats::GSharedSystemMemory = int64(AdapterDesc.SharedSystemMemory);
// Total amount of system memory, clamped to 8 GB
int64 TotalPhysicalMemory = FMath::Min(int64(FPlatformMemory::GetConstants().TotalPhysicalGB), 8ll) * (1024ll * 1024ll * 1024ll);
// Consider 50% of the shared memory but max 25% of total system memory.
int64 ConsideredSharedSystemMemory = FMath::Min( FD3D11GlobalStats::GSharedSystemMemory / 2ll, TotalPhysicalMemory / 4ll );
FD3D11GlobalStats::GTotalGraphicsMemory = 0;
if ( IsRHIDeviceIntel() )
{
// It's all system memory.
FD3D11GlobalStats::GTotalGraphicsMemory = FD3D11GlobalStats::GDedicatedVideoMemory;
FD3D11GlobalStats::GTotalGraphicsMemory += FD3D11GlobalStats::GDedicatedSystemMemory;
FD3D11GlobalStats::GTotalGraphicsMemory += ConsideredSharedSystemMemory;
}
else if ( FD3D11GlobalStats::GDedicatedVideoMemory >= 200*1024*1024 )
{
// Use dedicated video memory, if it's more than 200 MB
FD3D11GlobalStats::GTotalGraphicsMemory = FD3D11GlobalStats::GDedicatedVideoMemory;
}
else if ( FD3D11GlobalStats::GDedicatedSystemMemory >= 200*1024*1024 )
{
// Use dedicated system memory, if it's more than 200 MB
FD3D11GlobalStats::GTotalGraphicsMemory = FD3D11GlobalStats::GDedicatedSystemMemory;
}
else if ( FD3D11GlobalStats::GSharedSystemMemory >= 400*1024*1024 )
{
// Use some shared system memory, if it's more than 400 MB
FD3D11GlobalStats::GTotalGraphicsMemory = ConsideredSharedSystemMemory;
}
else
{
// Otherwise consider 25% of total system memory for graphics.
FD3D11GlobalStats::GTotalGraphicsMemory = TotalPhysicalMemory / 4ll;
}
if ( sizeof(SIZE_T) < 8 )
{
// Clamp to 1 GB if we're less than 64-bit
FD3D11GlobalStats::GTotalGraphicsMemory = FMath::Min( FD3D11GlobalStats::GTotalGraphicsMemory, 1024ll * 1024ll * 1024ll );
}
else
{
// Clamp to 1.9 GB if we're 64-bit
FD3D11GlobalStats::GTotalGraphicsMemory = FMath::Min( FD3D11GlobalStats::GTotalGraphicsMemory, 1945ll * 1024ll * 1024ll );
}
if ( GPoolSizeVRAMPercentage > 0 )
{
float PoolSize = float(GPoolSizeVRAMPercentage) * 0.01f * float(FD3D11GlobalStats::GTotalGraphicsMemory);
// Truncate GTexturePoolSize to MB (but still counted in bytes)
GTexturePoolSize = int64(FGenericPlatformMath::TruncToFloat(PoolSize / 1024.0f / 1024.0f)) * 1024 * 1024;
UE_LOG(LogRHI,Log,TEXT("Texture pool is %llu MB (%d%% of %llu MB)"),
GTexturePoolSize / 1024 / 1024,
GPoolSizeVRAMPercentage,
FD3D11GlobalStats::GTotalGraphicsMemory / 1024 / 1024);
}
const bool bIsPerfHUD = !FCString::Stricmp(AdapterDesc.Description,TEXT("NVIDIA PerfHUD"));
if(bIsPerfHUD)
{
DriverType = D3D_DRIVER_TYPE_REFERENCE;
}
}
else
{
check(!"Internal error, GetDesc() failed but before it worked")
}
}
}
else
{
/// <summary>
/// Handles window messages for this button.
/// </summary>
LRESULT WINAPI TaskButton::HandleMessage(HWND window, UINT message, WPARAM wParam, LPARAM lParam, LPVOID) {
switch (message) {
case WM_LBUTTONUP:
{
if (IsIconic(mWatchedWindow)) {
BringWindowToTop(mWatchedWindow);
PostMessage(mWatchedWindow, WM_SYSCOMMAND, SC_RESTORE, 0);
SetForegroundWindow(mWatchedWindow);
if (gActiveWindowTracking != FALSE) {
MoveMouseToWindow();
}
} else if (GetForegroundWindow() == mWatchedWindow) {
PostMessage(mWatchedWindow, WM_SYSCOMMAND, SC_MINIMIZE, 0);
ActivateState(State::Minimized);
} else {
SetForegroundWindow(mWatchedWindow);
if (gActiveWindowTracking != FALSE) {
MoveMouseToWindow();
}
}
((Taskbar*)mParent)->HideThumbnail();
}
return 0;
case WM_RBUTTONUP:
{
SetWindowPos(mWatchedWindow, HWND_TOP, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);
ShowMenu();
}
return 0;
case WM_MOUSEMOVE:
{
if (!mMouseIsOver) {
mMouseIsOver = true;
ActivateState(State::Hover);
RECT r;
mWindow->GetScreenRect(&r);
((Taskbar*)mParent)->ShowThumbnail(mWatchedWindow, &r);
}
}
return 0;
case WM_MOUSELEAVE:
{
mMouseIsOver = false;
ClearState(State::Hover);
((Taskbar*)mParent)->HideThumbnail();
}
return 0;
case WM_TIMER:
{
if (wParam == mFlashTimer) {
if (mIsFlashing) {
ToggleState(State::Flashing);
} else {
mWindow->ClearCallbackTimer(mFlashTimer);
}
}
}
return 0;
default:
return DefWindowProc(window, message, wParam, lParam);
}
}
CScriptState::~CScriptState()
{
if(m_pState) {
ClearState();
}
}
nsresult nsDocShellEnumerator::SetEnumerationRootItem(nsIDocShellTreeItem * aEnumerationRootItem)
{
mRootItem = aEnumerationRootItem;
ClearState();
return NS_OK;
}
void Win::Hide()
{
::ShowWindow(handle, SW_HIDE);
ClearState(S_VISIBLE);
};
C4RTFFile::~C4RTFFile()
{
ClearState();
}
SOUNDFILTER::SOUNDFILTER() :
order(0)
{
ClearState();
}
void IterativeDeepener::Search(const IDSParams& ids_params, Move* best_move,
int* best_move_score,
SearchStats* id_search_stats) {
std::ostream& out = ids_params.thinking_output ? std::cout : nullstream;
ClearState();
StopWatch stop_watch;
stop_watch.Start();
movegen_->GenerateMoves(&root_move_array_);
out << "# Number of moves at root: " << root_move_array_.size() << std::endl;
// No moves to make. Just return by setting invalid move. This can happen if
// Search() is called after game ends.
if (root_move_array_.size() == 0) {
*best_move = Move();
*best_move_score = INF;
return;
}
// Caller provided move ordering and pruning takes priority over move orderer.
if (ids_params.pruned_ordered_moves.size()) {
root_move_array_ = ids_params.pruned_ordered_moves;
} else if (extensions_->move_orderer) {
extensions_->move_orderer->Order(&root_move_array_);
}
assert(root_move_array_.size() > 0);
out << "# Number of root moves being searched: " << root_move_array_.size()
<< std::endl;
// If there is only one move to be made, make it without hesitation as search
// won't yield anything new.
if (root_move_array_.size() == 1) {
*best_move = root_move_array_.get(0);
*best_move_score = INF;
return;
}
// Iterative deepening starts here.
for (unsigned depth = 1; depth <= ids_params.search_depth; ++depth) {
// Do not use transposition table moves at the root if ordered/pruned
// movelist is passed by the caller as we expect input ordering to be of
// highest quality. Also, this avoids transposition table moves that are
// not in the list to be brought to the front.
if (ids_params.pruned_ordered_moves.size() == 0) {
TranspositionTableEntry* tentry = transpos_->Get(board_->ZobristKey());
if (tentry && tentry->best_move.is_valid()) {
root_move_array_.PushToFront(tentry->best_move);
}
} else if (!iteration_stats_.empty()) {
root_move_array_.PushToFront(iteration_stats_.back().best_move);
}
// This will return immediately when timer expires but updates the
// iteration_stats_ nevertheless. Results from the last iteration are
// acceptable only if search of at least the first root move subtree was
// completed. Due to the move-ordering done above, the first root move that
// is searched is guaranteed to be the best known move before beginning of
// this iteration. So, if a different best move is found before timer
// expiry, it is at least better than the previously known best move
// (though it might not be the overall best move at this depth because all
// the root moves might not be covered).
FindBestMove(depth);
double elapsed_time = stop_watch.ElapsedTime();
const IterationStat& last_istat = iteration_stats_.back();
// If FindMove could not complete at least the first root move subtree
// completely, don't report stats or update best_move as the results are
// likely to be incorrect.
if (timer_->Lapsed() && last_istat.root_moves_covered == 0) {
break;
}
// Update best_move and stats.
*best_move = last_istat.best_move;
*best_move_score = last_istat.score;
id_search_stats->nodes_searched += last_istat.search_stats.nodes_searched;
id_search_stats->nodes_researched +=
last_istat.search_stats.nodes_researched;
id_search_stats->nodes_evaluated += last_istat.search_stats.nodes_evaluated;
id_search_stats->search_depth = last_istat.depth;
// XBoard style thinking output.
if (ids_params.thinking_output) {
char output[256];
snprintf(output, 256, "%2d\t%5d\t%5d\t%10d\t%s", depth, last_istat.score,
int(elapsed_time), id_search_stats->nodes_evaluated,
PV(*best_move).c_str());
std::cout << output << std::endl;
}
// Don't go any deeper if a win is confirmed or timer has lapsed.
if (last_istat.score == WIN || timer_->Lapsed()) {
break;
}
}
stop_watch.Stop();
out << "# Time taken for ID search: " << stop_watch.ElapsedTime() << " centis"
<< std::endl;
}
bool CScriptState::ResetState()
{
ClearState();
return InitState();
}
/// <summary>
/// Deactivates this button.
/// </summary>
void TaskButton::Deactivate() {
ClearState(State::Active);
}
