//----------------------------------------------------------------------------
//
// Name : A_Star_Heuristic_Cost::Relax_One_Cost_Grid
//
// Description: Sets a (relaxed) block value to the minimum (raw) value of
// itself and its direct neighbours.
//
// Parameters : a_Row : block row number
// a_Column : block column number
//
// Globals : -
//
// Returns : -
//
// Remark(s) : Assumes that input is valid.
//
//----------------------------------------------------------------------------
void A_Star_Heuristic_Cost::Relax_One_Cost_Grid
(
int a_Row,
int a_Column
)
{
int const radius = 1; // how direct a neighbour should be
int const ownIndex = a_Column + (a_Row * columns);
// Initialise with own value (just to have something)
double & relaxedMin = relaxed_min_movement_costs[ownIndex];
relaxedMin = raw_min_movement_costs[ownIndex];
for (int i = a_Row - radius; i <= a_Row + radius; ++i)
{
int row;
if (IsInRange(i, 0, rows, y_wrap, row))
{
for (int j = a_Column - radius; j <= a_Column + radius; ++j)
{
int column;
if (IsInRange(j, 0, columns, x_wrap, column))
{
double const & neighbourValue =
raw_min_movement_costs[column + (row * columns)];
if (neighbourValue < relaxedMin)
{
relaxedMin = neighbourValue;
}
}
}
}
}
}
bool Arcusical::IsAlphaNumeric(Windows::System::VirtualKey key) {
int val = (int)(key);
// Source of values: https://msdn.microsoft.com/en-us/library/windows/apps/windows.system.virtualkey.aspx
return IsInRange(val, 48, 57) || // Numbers
IsInRange(val, 65, 90) || // Letters
IsInRange(val, 96, 105); // Numpad
}
bool is_in_on(const vt& x, const vt& y = 0, const vt& z = 0) const {
return (IsInRange(this->get(_M_, _X_), x, this->get(_P_, _X_), _cc_)
&& ((Dim >= 2) ?
IsInRange(this->get(_M_, _Y_), y, this->get(_P_, _Y_),
_cc_) :
true)
&& ((Dim == 3) ?
IsInRange(this->get(_M_, _Z_), z, this->get(_P_, _Z_),
_cc_) :
true));
}
bool FloatingPointValidatorBase::DoValidateNumber(wxString * errMsg) const
{
wxTextEntry * const control = GetTextEntry();
if ( !control )
return false;
wxString s(control->GetValue());
wxChar thousandsSep;
if ( NumberFormatter::GetThousandsSeparatorIfUsed(&thousandsSep) )
s.Replace(wxString(thousandsSep), wxString());
if ( s.empty() )
{
if ( HasFlag(NUM_VAL_ZERO_AS_BLANK) )
return true; //Is blank, but allowed. Stop here
else
{
*errMsg = _("Empty value");
return false; //We can't do any checks with an empty string
}
}
LongestValueType value;
bool res = FromString(s, &value); // Can it be converted to a value?
if ( !res )
*errMsg = _("Value overflow");
else
{
res = ValidatePrecision(s);
if ( !res )
*errMsg = _("Too many decimal digits");
else
{
res = IsInRange(value);
if ( !res )
{
wxString strMin = wxString::Format(wxT("%f"), m_min);
wxString strMax = wxString::Format(wxT("%f"), m_max);
NumberFormatter::RemoveTrailingZeroes(strMin);
NumberFormatter::RemoveTrailingZeroes(strMax);
if (m_minSet && m_maxSet)
{
errMsg->Printf(_("Value not in range: %s to %s"),
strMin, strMax);
}
else if (m_minSet)
{
errMsg->Printf(_("Value must not be less than %s"), strMin);
}
else if (m_maxSet)
{
errMsg->Printf(_("Value must not be greather than %s"), strMax);
}
}
}
}
return res;
}
void CChatWnd::OnChatItalic()
{
if ( IsInRange( _T("i") ) )
InsertText( _T("[/i]") );
else
InsertText( _T("[i]") );
}
void CChatWnd::OnChatUnderline()
{
if ( IsInRange( _T("u") ) )
InsertText( _T("[/u]") );
else
InsertText( _T("[u]") );
}
void CChatWnd::OnChatBold()
{
if ( IsInRange( _T("b") ) )
InsertText( _T("[/b]") );
else
InsertText( _T("[b]") );
}
bool StressTest::GoToNextFile()
{
for (;;) {
while (filesToOpen.Count() > 0) {
// test next file
ScopedMem<TCHAR> path(filesToOpen.At(0));
filesToOpen.RemoveAt(0);
if (!IsInRange(fileRanges, ++fileIndex))
continue;
if (OpenFile(path))
return true;
}
if (dirsToVisit.Count() > 0) {
// test next directory
ScopedMem<TCHAR> path(dirsToVisit.At(0));
dirsToVisit.RemoveAt(0);
OpenDir(path);
continue;
}
if (--cycles <= 0)
return false;
// start next cycle
if (file::Exists(basePath))
filesToOpen.Append(str::Dup(basePath));
else
OpenDir(basePath);
}
}
UAnimSequenceBase * FAnimSegment::GetAnimationData(float PositionInTrack, float& PositionInAnim, float& Weight) const
{
if( IsInRange(PositionInTrack) )
{
if( AnimReference )
{
const float ValidPlayRate = GetValidPlayRate();
// this result position should be pure position within animation
float Delta = (PositionInTrack - StartPos);
// LoopingCount should not be zero, and it should not get here, but just in case
if (LoopingCount > 1)
{
// we need to consider looping count
float AnimPlayLength = (AnimEndTime - AnimStartTime) / FMath::Abs(ValidPlayRate);
Delta = FMath::Fmod(Delta, AnimPlayLength);
}
// no blending supported
Weight = 1.f;
if (ValidPlayRate > 0.f)
{
PositionInAnim = AnimStartTime + Delta * ValidPlayRate;
}
else
{
PositionInAnim = AnimEndTime + Delta * ValidPlayRate;
}
return AnimReference;
}
}
return NULL;
}
CVisDimIterator::CVisDimIterator(const CVisDim& refdim, int i0, int i1,
int i2, int i3)
: CVisDimIndex(i0, i1, i2, i3),
m_pdim(&refdim),
m_fAtEnd(false)
{
assert(IsInRange(*m_pdim));
}
CVisDimIterator& CVisDimIterator::operator=(const CVisDimIndex& refdimindex)
{
*((CVisDimIndex *) this) = refdimindex;
assert(IsInRange(*m_pdim));
return *this;
}
CVisDimIterator::CVisDimIterator(const CVisDim& refdim,
const CVisDimIndex& refdimindex)
: CVisDimIndex(refdimindex),
m_pdim(&refdim),
m_fAtEnd(false)
{
assert(IsInRange(*m_pdim));
}
TEST_F(RectDiff, Divide) {
// ランダムなテスト範囲
auto rd = getRand();
auto randI = rd.template getUniformF<int>();
constexpr int MaxRange = 100;
const Size size(randI({1, MaxRange}),
randI({1, MaxRange}));
bool imap[MaxRange*2][MaxRange*2];
const auto randX = rd.template getUniformF<int>({-size.width/2, size.width/2}),
randY = rd.template getUniformF<int>({-size.height/2, size.height/2});
constexpr int NItr = 0x100;
for(int i=0 ; i<NItr ; i++) {
std::memset(imap, 0, sizeof(imap));
// テスト範囲以下の矩形をランダムな位置に置く
const auto rect = RandomRect(randX, randY);
int area = 0;
ASSERT_NO_FATAL_FAILURE(
rect::DivideRect(
size,
rect,
[&size, &area, &imap](const Rect& g, const Rect& l){
ASSERT_NO_THROW(g.checkValidness());
ASSERT_NO_THROW(l.checkValidness());
// グローバルとローカル矩形の面積は同じ
ASSERT_EQ(g.area(), l.area());
// ローカル座標がテスト範囲を出ていないか
ASSERT_TRUE(IsInRange(l.x0, 0, size.width));
ASSERT_TRUE(IsInRange(l.x1, 0, size.width));
ASSERT_TRUE(IsInRange(l.y0, 0, size.height));
ASSERT_TRUE(IsInRange(l.y1, 0, size.height));
// 矩形を塗りつぶしていき、重なりや面積が違っていなければOK
for(int i=g.y0 ; i<g.y1 ; i++) {
for(int j=g.x0 ; j<g.x1 ; j++) {
auto& im = imap[i+MaxRange][j+MaxRange];
ASSERT_FALSE(im);
im = true;
}
}
area += g.area();
}
)
);
ASSERT_EQ(rect.area(), area);
}
}
Entity* Creature::Find_Target_Player(int range)
{
auto chunks = World::GetChunksAround(x, y);
for each (auto c in *chunks)
for each (Tile *t in c.second->data)
if (t->entity && dynamic_cast<Player*>(t->entity.get()) && IsInRange(*t->entity, range))
{
return &*t->entity;
}
return nullptr;
}
void ribi::DrawCanvas::DrawDot(const double x, const double y) noexcept
{
//Assume a dot has dimensions 1.0 x 1.0
//and x and y are exactly in the middle of this dot
const double xBegin = x - 0.5;
const double yBegin = y - 0.5;
const double fracLeft = std::ceil(xBegin) - xBegin;
const double fracTop = std::ceil(yBegin) - yBegin;
const int indexLeft = std::floor(xBegin);
const int indexTop = std::floor(yBegin);
if (IsInRange(indexLeft ,indexTop ))
m_canvas[indexTop ][indexLeft ] += (fracLeft * fracTop);
if (IsInRange(indexLeft+1,indexTop ))
m_canvas[indexTop ][indexLeft+1] += ((1.0-fracLeft) * fracTop);
if (IsInRange(indexLeft ,indexTop+1))
m_canvas[indexTop+1][indexLeft ] += (fracLeft * (1.0-fracTop));
if (IsInRange(indexLeft+1,indexTop+1))
m_canvas[indexTop+1][indexLeft+1] += ((1.0-fracLeft) * (1.0-fracTop));
m_signal_changed(this);
}
void BoxBrowser::ClearCache( bool full )
{
//RsxMem::PrintInfo( true );
u32 r1Low = 0xffffffff;
u32 r1High = 0xffffffff;
u32 r2Low = 0xffffffff;
u32 r2High = 0xffffffff;
std::map<u32, GuiImageAsync *> keepers;
if( !full )
{
r1Low = listIdx;
r1High = listIdx + NUM_BOXES;
if( r1High >= (u32)GameList::Count() )
{
r1High = GameList::Count() - 1;
r2Low = 0;
r2High = NUM_BOXES - ( r1High - r1Low );
}
}
else
{
needToUpdateBoxes = true;
}
if( coverImg.size() )
{
for( std::map<u32, GuiImageAsync *>::iterator i = coverImg.begin(), iEnd = coverImg.end(); i != iEnd; ++i )
{
if( full
|| ( !IsInRange( (*i).first, r1Low, r1High) && !IsInRange( (*i).first, r2Low, r2High) ) )
{
if( (*i).second )
delete (*i).second;
}
else
{
keepers[ (*i).first ] = (*i).second;
}
}
}
coverImg = keepers;
}
bool CStringConstraint::DoesTextMatch (const string& text)
{
string match = m_MatchText;
if (match.length() == 0) {
return true;
}
bool rval = false;
string tmp = text;
if (m_IgnoreSpace) {
NStr::ReplaceInPlace(match, " ", "");
NStr::ReplaceInPlace(tmp, " ", "");
}
if (m_IgnoreCase) {
NStr::ToLower(match);
NStr::ToLower(tmp);
}
vector<string> tokens;
if (m_MatchType == eMatchType_Equals)
tokens.push_back(match);
else
NStr::Split(match, ",; ", tokens);
ITERATE(vector<string>, it, tokens) {
switch (m_MatchType) {
case eMatchType_Contains:
rval |= (NStr::Find(tmp, *it) != string::npos);
break;
case eMatchType_Equals:
rval |= NStr::Equal(tmp, *it);
break;
case eMatchType_StartsWith:
rval |= NStr::StartsWith(tmp, *it);
break;
case eMatchType_EndsWith:
rval |= NStr::EndsWith(tmp, *it);
break;
case eMatchType_IsOneOf:
rval |= (IsInRange(*it, tmp) || NStr::Equal(*it, tmp));
break;
}
if (rval)
break;
}
if (m_NotPresent) {
rval = !rval;
}
return rval;
}
bool
wxFloatingPointValidatorBase::IsCharOk(const wxString& val,
int pos,
wxChar ch) const
{
// We may accept minus sign if we can represent negative numbers at all.
if ( ch == '-' )
return m_min < 0 && IsMinusOk(val, pos);
const wxChar separator = wxNumberFormatter::GetDecimalSeparator();
if ( ch == separator )
{
if ( val.find(separator) != wxString::npos )
{
// There is already a decimal separator, can't insert another one.
return false;
}
// Prepending a separator before the minus sign isn't allowed.
if ( pos == 0 && !val.empty() && val[0] == '-' )
return false;
// Otherwise always accept it, adding a decimal separator doesn't
// change the number value and, in particular, can't make it invalid.
// OTOH the checks below might not pass because strings like "." or
// "-." are not valid numbers so parsing them would fail, hence we need
// to treat it specially here.
return true;
}
// Must be a digit then.
if ( ch < '0' || ch > '9' )
return false;
// Check whether the value we'd obtain if we accepted this key is correct.
const wxString newval(GetValueAfterInsertingChar(val, pos, ch));
LongestValueType value;
if ( !FromString(newval, &value) )
return false;
// Also check that it doesn't have too many decimal digits.
const size_t posSep = newval.find(separator);
if ( posSep != wxString::npos && newval.length() - posSep - 1 > m_precision )
return false;
// Finally check whether it is in the range.
return IsInRange(value);
}
bool StressTest::GoToNextFile() {
for (;;) {
AutoFreeW nextFile(fileProvider->NextFile());
if (nextFile) {
if (!IsInRange(fileRanges, ++fileIndex))
continue;
if (OpenFile(nextFile))
return true;
continue;
}
if (--cycles <= 0)
return false;
fileProvider->Restart();
}
}
void CNumberEdit::ProcessTextChangingMessage()
{
CString csOrigText;
GetWindowText(csOrigText);
Default();
CString csNewText;
GetWindowText(csNewText);
if (!IsNumber(csNewText) || !IsInRange(_tstoi(csNewText)))
{
MessageBeep(-1);
SetWindowText(csOrigText);
}
}
//************************************************************************************
int CBCGPOutlineParser::GetNameOffset (const CString& strIn, int nStartFrom, int nSearchTo,
const BlockType* pBlockType, CObList& lstIgnore,
CString& strName)
{
ASSERT (nStartFrom >= 0);
ASSERT (nSearchTo >= 0);
ASSERT (pBlockType != NULL);
int nOffset = nStartFrom - 1;
const int nCharsMaxNum = 256;
nSearchTo = max (nSearchTo, nStartFrom - nCharsMaxNum);
LPCTSTR lpszDelimiters = _T(";{}");
const CStringList* pListKeywords = &(pBlockType->m_lstKeywords);
ASSERT_VALID (pListKeywords);
if (pListKeywords->GetCount () == 0)
{
// if no keywords then nameoffset = 0
nSearchTo = nStartFrom;
}
while (nOffset >= nSearchTo)
{
CString strWord;
nOffset = GetPrevWord (strIn, nOffset, nSearchTo, lpszDelimiters, strWord);
if (nOffset >= nSearchTo &&
!IsInRange (lstIgnore, nOffset, nOffset + strWord.GetLength ()))
{
// Compare strWord with keywords
if (pListKeywords->Find (strWord) != NULL)
{
strName = strWord;
return nStartFrom - nOffset;
}
else if (IsBlockName (strIn, strWord, nOffset, nStartFrom))
{
strName = strWord;
return nStartFrom - nOffset;
}
}
nOffset--;
}
strName = _T("");
return 0;
}
bool StressTest::GoToNextPage()
{
double pageRenderTime = currPageRenderTime.GetTimeInMs();
ScopedMem<TCHAR> s(str::Format(_T("Page %d rendered in %d milliseconds"), currPage, (int)pageRenderTime));
ShowNotification(win, s, true, false, NG_STRESS_TEST_BENCHMARK);
++currPage;
while (!IsInRange(pageRanges, currPage) && currPage <= win->dm->PageCount()) {
currPage++;
}
if (currPage > win->dm->PageCount()) {
if (GoToNextFile())
return true;
Finished(true);
return false;
}
win->dm->GoToPage(currPage, 0);
currPageRenderTime.Start();
// start text search when we're in the middle of the document, so that
// search thread touches both pages that were already rendered and not yet
// rendered
// TODO: it would be nice to also randomize search starting page but the
// current API doesn't make it easy
if (currPage == pageForSearchStart) {
// use text that is unlikely to be found, so that we search all pages
win::SetText(win->hwndFindBox, _T("!z_yt"));
FindTextOnThread(win);
}
if (1 == rand() % 3) {
ClientRect rect(win->hwndFrame);
int deltaX = (rand() % 40) - 23;
rect.dx += deltaX;
if (rect.dx < 300)
rect.dx += (abs(deltaX) * 3);
int deltaY = (rand() % 40) - 23;
rect.dy += deltaY;
if (rect.dy < 300)
rect.dy += (abs(deltaY) * 3);
SendMessage(win->hwndFrame, WM_SIZE, 0, MAKELONG(rect.dx, rect.dy));
}
return true;
}
bool IntegerValidatorBase::DoValidateNumber(wxString * errMsg) const
{
wxTextEntry * const control = GetTextEntry();
if ( !control )
return false;
wxString s(control->GetValue());
wxChar thousandsSep;
if ( NumberFormatter::GetThousandsSeparatorIfUsed(&thousandsSep) )
s.Replace(wxString(thousandsSep), wxString());
if ( s.empty() )
{
// Is blank, but allowed. Stop here
if ( HasFlag(NUM_VAL_ZERO_AS_BLANK) )
{
return true;
}
// We can't do any check with an empty string
else
{
*errMsg = _("Empty value");
return false;
}
}
// Can it be converted to a value?
LongestValueType value;
bool res = FromString(s, &value);
if ( !res )
*errMsg = _("Malformed number");
else
{
res = IsInRange(value);
if ( !res )
errMsg->Printf(_("Not in range %d to %d"),
(int) m_min, (int) m_max);
}
return res;
}
//************************************************************************************
int CBCGPOutlineParser::GetStartOffset (const CString& strIn, int nStartFrom, int nSearchTo, CObList& lstIgnore)
{
ASSERT (nStartFrom >= 0);
ASSERT (nSearchTo >= 0);
CString strDelimeters = _T(" \t\n");
int i = nStartFrom;
while (i > nSearchTo)
{
i--;
if (strDelimeters.Find (strIn[i]) == -1 &&
!IsInRange (lstIgnore, i, i))
{
nStartFrom = i + 1;
break;
}
}
return nStartFrom;
}
bool
PreReservedVirtualAllocWrapper::IsInRange(void * address)
{
if (!this->IsPreReservedRegionPresent())
{
return false;
}
bool isInRange = IsInRange(GetPreReservedStartAddress(), address);
#if DBG
if (isInRange)
{
//Check if the region is in MEM_COMMIT state.
MEMORY_BASIC_INFORMATION memBasicInfo;
size_t bytes = VirtualQuery(address, &memBasicInfo, sizeof(memBasicInfo));
if (bytes == 0)
{
return false;
}
AssertMsg(memBasicInfo.State == MEM_COMMIT, "Memory not committed? Checking for uncommitted address region?");
}
#endif
return isInRange;
}
bool
wxIntegerValidatorBase::IsCharOk(const wxString& val, int pos, wxChar ch) const
{
// We may accept minus sign if we can represent negative numbers at all.
if ( ch == '-' )
{
// Notice that entering '-' can make our value invalid, for example if
// we're limited to -5..15 range and the current value is 12, then the
// new value would be (invalid) -12. We consider it better to let the
// user do this because perhaps he is going to press Delete key next to
// make it -2 and forcing him to delete 1 first would be unnatural.
//
// TODO: It would be nice to indicate that the current control contents
// is invalid (if it's indeed going to be the case) once
// wxValidator supports doing this non-intrusively.
return m_min < 0 && IsMinusOk(val, pos);
}
// We only accept digits here (remember that '-' is taken care of by the
// base class already).
if ( ch < '0' || ch > '9' )
return false;
// And the value after insertion needs to be in the defined range.
LongestValueType value;
if ( !FromString(GetValueAfterInsertingChar(val, pos, ch), &value) )
return false;
wxString smin = ToString(m_min);
wxString smax = ToString(m_max);
if ( pos < (int) smin.Length() )
return true;
if ( pos < (int) smax.Length() - 1 )
return true;
return IsInRange(value);
}
bool GatherFoodAction::Execute(AGOAPAIController& controller)
{
// Check if the desired effects are already valid, if so, we're done
if (AreEffectsSatisfied(controller))
{
return true;
}
// Check if we have a target, if not, find one
if (ActionTarget == nullptr)
{
ActionTarget = (&controller)->FindNewResourceActor(EResourceType::Food);
}
if (ActionTarget == nullptr)
{
// No targets, we need to abort this action
// TODO: Abort code
return false;
}
// If we're not in range of the target, change to a move state
if (!IsInRange(controller))
{
(&controller)->SetMoveToStateWithTarget(ActionTarget->GetActorLocation());
return false;
}
// Otherwise, we're in range! Let's nuke the target
else
{
ActionTarget->Destroy();
ActionTarget = nullptr;
(&controller)->character->Stat_HasFood = true;
return true;
}
return false;
}
bool
OLCTriangle::FindClosingPairs(unsigned old_size)
{
if (predict) {
return closing_pairs.Insert(ClosingPair(0, n_points-1));
}
struct TracePointNode {
const TracePoint *point;
unsigned index;
};
struct TracePointNodeAccessor {
gcc_pure
int GetX(const TracePointNode &node) const {
return node.point->GetFlatLocation().x;
}
gcc_pure
int GetY(const TracePointNode &node) const {
return node.point->GetFlatLocation().y;
}
};
QuadTree<TracePointNode, TracePointNodeAccessor> search_point_tree;
for (unsigned i = old_size; i < n_points; ++i) {
TracePointNode node;
node.point = &GetPoint(i);
node.index = i;
search_point_tree.insert(node);
}
search_point_tree.Optimise();
bool new_pair = false;
for (unsigned i = old_size; i < n_points; ++i) {
TracePointNode point;
point.point = &GetPoint(i);
point.index = i;
const SearchPoint start = *point.point;
const unsigned max_range = trace_master.ProjectRange(start.GetLocation(), max_distance);
const unsigned half_max_range_sq = max_range * max_range / 2;
const int min_altitude = GetMinimumFinishAltitude(*point.point);
const int max_altitude = GetMaximumStartAltitude(*point.point);
unsigned last = 0, first = i;
const auto visitor = [this, i, start,
half_max_range_sq,
min_altitude, max_altitude,
&first, &last]
(const TracePointNode &node) {
const auto &dest = *node.point;
if (node.index + 2 < i &&
dest.GetIntegerAltitude() <= max_altitude &&
IsInRange(start, dest, half_max_range_sq, max_distance)) {
// point i is last point
first = std::min(node.index, first);
last = i;
} else if (node.index > i + 2 &&
dest.GetIntegerAltitude() >= min_altitude &&
IsInRange(start, dest, half_max_range_sq, max_distance)) {
// point i is first point
first = i;
last = std::max(node.index, last);
}
};
search_point_tree.VisitWithinRange(point, max_range, visitor);
if (last != 0 && closing_pairs.Insert(ClosingPair(first, last)))
new_pair = true;
}
return new_pair;
}
inline bool IsDecimalDigit(char c) {
return IsInRange(c, '0', '9');
}
// 二点の距離が指定範囲いないかどうか
bool IsInRange( const Vector2 &vecA, const Vector2 &vecB, const uint32_t &range )
{
return IsInRange( vecA, vecB, static_cast<float>(range) );
}
