mirror of
https://github.com/mangosfour/server.git
synced 2025-12-27 10:37:02 +00:00
[11659] Rewrite object pos selector.
* Instead coordinates use angle projections to expected pos distance circle. This let do mostly only angle comparison and then speedup checks. * Fixed some long existed bugs in algo and simplify code. Possible more work need.
This commit is contained in:
VladimirMangos
parent
e776dbbfc8
commit
15bb164d72
4 changed files with 292 additions and 294 deletions
|
|
@ -19,144 +19,253 @@
|
|||
#include "ObjectPosSelector.h"
|
||||
#include "Object.h"
|
||||
|
||||
ObjectPosSelector::ObjectPosSelector(float x,float y,float size,float dist)
|
||||
: m_center_x(x),m_center_y(y),m_size(size),m_dist(dist)
|
||||
ObjectPosSelector::ObjectPosSelector(float x, float y, float dist, float searcher_size) :
|
||||
m_centerX(x), m_centerY(y), m_searcherDist(dist), m_searcherSize(searcher_size)
|
||||
{
|
||||
// if size == 0, m_anglestep will become 0 -> freeze
|
||||
if(m_size == 0.0f)
|
||||
m_size = DEFAULT_WORLD_OBJECT_SIZE;
|
||||
if (m_searcherSize == 0.0f)
|
||||
m_searcherSize = DEFAULT_WORLD_OBJECT_SIZE;
|
||||
|
||||
m_anglestep = acos(m_dist/(m_dist+2*m_size));
|
||||
m_searcherHalfSize = asin(m_searcherSize/m_searcherDist);
|
||||
|
||||
m_nextUsedPos[USED_POS_PLUS] = m_UsedPosLists[USED_POS_PLUS].end();
|
||||
m_nextUsedPos[USED_POS_MINUS] = m_UsedPosLists[USED_POS_MINUS].end();
|
||||
|
||||
m_smallStepAngle[USED_POS_PLUS] = 0;
|
||||
m_smallStepAngle[USED_POS_MINUS] = 0;
|
||||
|
||||
m_smallStepOk[USED_POS_PLUS] = false;
|
||||
m_smallStepOk[USED_POS_MINUS] = false;
|
||||
|
||||
m_smallStepNextUsedPos[USED_POS_PLUS] = NULL;
|
||||
m_smallStepNextUsedPos[USED_POS_MINUS] = NULL;
|
||||
// Really init in InitilizeAngle
|
||||
m_nextUsedAreaItr[USED_POS_PLUS] = m_UsedAreaLists[USED_POS_PLUS].begin();
|
||||
m_nextUsedAreaItr[USED_POS_MINUS] = m_UsedAreaLists[USED_POS_MINUS].begin();
|
||||
m_nextUsedAreaStart[USED_POS_PLUS] = 0.0f;
|
||||
m_nextUsedAreaStart[USED_POS_MINUS] = 0.0f;
|
||||
m_stepAngle[USED_POS_PLUS] = 0.0f;
|
||||
m_stepAngle[USED_POS_MINUS] = 0.0f;
|
||||
}
|
||||
|
||||
ObjectPosSelector::UsedPosList::value_type const* ObjectPosSelector::nextUsedPos(UsedPosType uptype)
|
||||
/**
|
||||
* Add used area (circle) near target object excluded from possible searcher position
|
||||
*
|
||||
*
|
||||
* @param size Size of used circle
|
||||
* @param angle Angle of used circle center point from target-searcher line
|
||||
* @param dist Distance from target object center point to used circle center point
|
||||
*
|
||||
* Used circles data stored as projections to searcher dist size circle as angle coordinate and half angle size
|
||||
*/
|
||||
void ObjectPosSelector::AddUsedArea(float size, float angle, float dist)
|
||||
{
|
||||
UsedPosList::const_iterator itr = m_nextUsedPos[uptype];
|
||||
if(itr!=m_UsedPosLists[uptype].end())
|
||||
++itr;
|
||||
float sr_dist = size + m_searcherSize;
|
||||
|
||||
if(itr==m_UsedPosLists[uptype].end())
|
||||
{
|
||||
if(!m_UsedPosLists[~uptype].empty())
|
||||
return &*m_UsedPosLists[~uptype].rbegin();
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
// by Law of cosines, angle of searcher/used centers
|
||||
float sr_angle = acos((m_searcherDist * m_searcherDist + dist * dist - sr_dist * sr_dist) / (2 * m_searcherDist * dist));
|
||||
|
||||
if (angle >= 0)
|
||||
m_UsedAreaLists[USED_POS_PLUS].insert(UsedArea(angle, sr_angle));
|
||||
else
|
||||
return &*itr;
|
||||
m_UsedAreaLists[USED_POS_MINUS].insert(UsedArea(-angle, sr_angle));
|
||||
}
|
||||
|
||||
void ObjectPosSelector::AddUsedPos(float size,float angle,float dist)
|
||||
/**
|
||||
* Check searcher circle not intercepting with used circle
|
||||
*
|
||||
* @param usedArea Used circle as projection to searcher distance circle in angles form
|
||||
* @param side Side of used circle
|
||||
* @param angle Checked angle
|
||||
*
|
||||
* @return true, if used circle not intercepted with searcher circle in terms projection angles
|
||||
*/
|
||||
bool ObjectPosSelector::CheckAngle(UsedArea const& usedArea, UsedAreaSide side, float angle) const
|
||||
{
|
||||
if(angle>=0)
|
||||
m_UsedPosLists[USED_POS_PLUS].insert(UsedPosList::value_type(angle,UsedPos(1.0,size,dist)));
|
||||
else
|
||||
m_UsedPosLists[USED_POS_MINUS].insert(UsedPosList::value_type(-angle,UsedPos(-1.0,size,dist)));
|
||||
float used_angle = usedArea.first * SignOf(side);
|
||||
float used_offset = usedArea.second;
|
||||
|
||||
return fabs(used_angle - angle) > used_offset;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check searcher circle not intercepting with used circle at side (only start angle provided)
|
||||
*
|
||||
* @param side Side of used circle
|
||||
* @param angle Checked angle at side, positive always
|
||||
*
|
||||
* @return true, if used circle not intercepted with searcher circle in terms projection angles
|
||||
*/
|
||||
bool ObjectPosSelector::CheckSideAngle(UsedAreaSide side, float angle) const
|
||||
{
|
||||
return angle + m_searcherHalfSize < m_nextUsedAreaStart[side];
|
||||
}
|
||||
|
||||
/**
|
||||
* Check original (0.0f) angle fit to existed used area excludes
|
||||
*
|
||||
* @return true, if 0.0f angle with m_searcher_halfangle*2 angle size not intercept with used circles
|
||||
*/
|
||||
bool ObjectPosSelector::CheckOriginalAngle() const
|
||||
{
|
||||
// check first left/right used angles if exists
|
||||
return (m_UsedAreaLists[USED_POS_PLUS].empty() || CheckAngle(*m_UsedAreaLists[USED_POS_PLUS].begin(), USED_POS_PLUS, 0.0f)) &&
|
||||
(m_UsedAreaLists[USED_POS_MINUS].empty() || CheckAngle(*m_UsedAreaLists[USED_POS_MINUS].begin(), USED_POS_MINUS, 0.0f));
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize data for search angles starting from first possible angle at both sides
|
||||
*/
|
||||
void ObjectPosSelector::InitializeAngle()
|
||||
{
|
||||
m_nextUsedPos[USED_POS_PLUS] = m_UsedPosLists[USED_POS_PLUS].begin();
|
||||
m_nextUsedPos[USED_POS_MINUS] = m_UsedPosLists[USED_POS_MINUS].begin();
|
||||
|
||||
m_smallStepAngle[USED_POS_PLUS] = 0;
|
||||
m_smallStepAngle[USED_POS_MINUS] = 0;
|
||||
|
||||
m_smallStepOk[USED_POS_PLUS] = true;
|
||||
m_smallStepOk[USED_POS_MINUS] = true;
|
||||
InitializeAngle(USED_POS_PLUS);
|
||||
InitializeAngle(USED_POS_MINUS);
|
||||
}
|
||||
|
||||
bool ObjectPosSelector::FirstAngle(float& angle)
|
||||
/**
|
||||
* Initialize data for search angles starting from first possible angle at side
|
||||
*/
|
||||
void ObjectPosSelector::InitializeAngle(UsedAreaSide side)
|
||||
{
|
||||
if(m_UsedPosLists[USED_POS_PLUS].empty() && !m_UsedPosLists[USED_POS_MINUS].empty() )
|
||||
return NextAngleFor(*m_UsedPosLists[USED_POS_MINUS].begin(),1.0,USED_POS_PLUS,angle);
|
||||
else if(m_UsedPosLists[USED_POS_MINUS].empty() && !m_UsedPosLists[USED_POS_PLUS].empty() )
|
||||
return NextAngleFor(*m_UsedPosLists[USED_POS_PLUS].begin(),-1.0,USED_POS_MINUS,angle);
|
||||
m_nextUsedAreaItr[side] = m_UsedAreaLists[side].begin();
|
||||
UpdateNextAreaStart(side);
|
||||
|
||||
return false;
|
||||
// if another side not alow use 0.0f angle calculate possible value in 0..m_searcherHalfSize range
|
||||
if (!m_UsedAreaLists[~side].empty())
|
||||
{
|
||||
UsedArea const& otherArea = *m_UsedAreaLists[~side].begin();
|
||||
|
||||
// if other are near start
|
||||
if (otherArea.first < otherArea.second)
|
||||
m_stepAngle[side] = otherArea.second - otherArea.first;
|
||||
else
|
||||
m_stepAngle[side] = 0.0f;
|
||||
}
|
||||
else
|
||||
m_stepAngle[side] = 0.0f;
|
||||
}
|
||||
|
||||
/**
|
||||
* Update next used area start angle for current m_nextUsedAreaItr value at side
|
||||
*/
|
||||
void ObjectPosSelector::UpdateNextAreaStart(UsedAreaSide side)
|
||||
{
|
||||
// not last next area at side
|
||||
if (m_nextUsedAreaItr[side] != m_UsedAreaLists[side].end())
|
||||
{
|
||||
m_nextUsedAreaStart[side] = m_nextUsedAreaItr[side]->first - m_nextUsedAreaItr[side]->second + m_searcherHalfSize;
|
||||
return;
|
||||
}
|
||||
|
||||
// last area at side and not another side areas
|
||||
if (m_UsedAreaLists[~side].empty())
|
||||
{
|
||||
m_nextUsedAreaStart[side] = M_PI_F + m_searcherHalfSize + 0.01f;
|
||||
return;
|
||||
}
|
||||
|
||||
UsedArea const& lastArea = *m_UsedAreaLists[~side].rbegin();
|
||||
|
||||
// another side have used area near to end (near to PI)
|
||||
if (lastArea.first + lastArea.second > M_PI_F - m_searcherHalfSize)
|
||||
{
|
||||
m_nextUsedAreaStart[side] = M_PI_F + (M_PI_F - lastArea.first - lastArea.second) + m_searcherHalfSize;
|
||||
return;
|
||||
}
|
||||
|
||||
// last area and fail find any used area at another side, prepare fake data as stopper
|
||||
m_nextUsedAreaStart[side] = M_PI_F + m_searcherHalfSize + 0.01f;
|
||||
}
|
||||
|
||||
/**
|
||||
* Find next angle in free area
|
||||
*
|
||||
* @param angle Return at success found angle
|
||||
*
|
||||
* @return true, if angle found
|
||||
*/
|
||||
bool ObjectPosSelector::NextAngle(float& angle)
|
||||
{
|
||||
while(m_nextUsedPos[USED_POS_PLUS]!=m_UsedPosLists[USED_POS_PLUS].end() ||
|
||||
m_nextUsedPos[USED_POS_MINUS]!=m_UsedPosLists[USED_POS_MINUS].end() ||
|
||||
m_smallStepOk[USED_POS_PLUS] || m_smallStepOk[USED_POS_MINUS] )
|
||||
// loop until both side fail and leave 0..PI
|
||||
for(;;)
|
||||
{
|
||||
// calculate next possible angle
|
||||
if(NextPosibleAngle(angle))
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ObjectPosSelector::NextUsedAngle(float& angle)
|
||||
{
|
||||
while(m_nextUsedPos[USED_POS_PLUS]!=m_UsedPosLists[USED_POS_PLUS].end() ||
|
||||
m_nextUsedPos[USED_POS_MINUS]!=m_UsedPosLists[USED_POS_MINUS].end() )
|
||||
{
|
||||
// calculate next possible angle
|
||||
if(!NextPosibleAngle(angle))
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ObjectPosSelector::NextPosibleAngle( float& angle )
|
||||
{
|
||||
// ++ direction less updated
|
||||
if( m_nextUsedPos[USED_POS_PLUS]!=m_UsedPosLists[USED_POS_PLUS].end() &&
|
||||
(m_nextUsedPos[USED_POS_MINUS]==m_UsedPosLists[USED_POS_MINUS].end() || m_nextUsedPos[USED_POS_PLUS]->first <= m_nextUsedPos[USED_POS_MINUS]->first) )
|
||||
{
|
||||
bool ok;
|
||||
if(m_smallStepOk[USED_POS_PLUS])
|
||||
ok = NextSmallStepAngle(1.0,USED_POS_PLUS,angle);
|
||||
else
|
||||
ok = NextAngleFor(*m_nextUsedPos[USED_POS_PLUS],1.0,USED_POS_PLUS,angle);
|
||||
|
||||
if(!ok)
|
||||
++m_nextUsedPos[USED_POS_PLUS]; // increase. only at fail (original or checked)
|
||||
return ok;
|
||||
}
|
||||
// -- direction less updated
|
||||
else if( m_nextUsedPos[USED_POS_MINUS]!=m_UsedPosLists[USED_POS_MINUS].end())
|
||||
{
|
||||
bool ok;
|
||||
if(m_smallStepOk[USED_POS_MINUS])
|
||||
ok = NextSmallStepAngle(-1.0,USED_POS_MINUS,angle);
|
||||
else
|
||||
ok = NextAngleFor(*m_nextUsedPos[USED_POS_MINUS],-1.0,USED_POS_MINUS,angle);
|
||||
|
||||
if(!ok)
|
||||
++m_nextUsedPos[USED_POS_MINUS];
|
||||
return ok;
|
||||
}
|
||||
else // both list empty
|
||||
{
|
||||
if( m_smallStepOk[USED_POS_PLUS] && (!m_smallStepOk[USED_POS_MINUS] || m_smallStepAngle[USED_POS_PLUS] <= m_smallStepAngle[USED_POS_MINUS]) )
|
||||
// ++ direction less updated
|
||||
if (m_stepAngle[USED_POS_PLUS] < M_PI_F && m_stepAngle[USED_POS_PLUS] <= m_stepAngle[USED_POS_MINUS])
|
||||
{
|
||||
return NextSmallStepAngle(1.0,USED_POS_PLUS,angle);
|
||||
if (NextSideAngle(USED_POS_PLUS, angle))
|
||||
return true;
|
||||
}
|
||||
// -- direction less updated
|
||||
else if( m_smallStepOk[USED_POS_MINUS] )
|
||||
else if (m_stepAngle[USED_POS_MINUS] < M_PI_F)
|
||||
{
|
||||
return NextSmallStepAngle(-1.0,USED_POS_MINUS,angle);
|
||||
if (NextSideAngle(USED_POS_MINUS, angle))
|
||||
return true;
|
||||
}
|
||||
// both sides finishes
|
||||
else
|
||||
break;
|
||||
}
|
||||
|
||||
// no angles
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Find next angle at side
|
||||
*
|
||||
* @param side Side of angle
|
||||
* @param angle Return at success found angle
|
||||
*
|
||||
* @return true, if angle found
|
||||
*
|
||||
*/
|
||||
bool ObjectPosSelector::NextSideAngle(UsedAreaSide side, float &angle )
|
||||
{
|
||||
// next possible angle
|
||||
m_stepAngle[side] += (m_searcherHalfSize + 0.01);
|
||||
|
||||
// prevent jump to another side
|
||||
if (m_stepAngle[side] > M_PI_F)
|
||||
return false;
|
||||
|
||||
// update angle at attempt jump after next used area
|
||||
while (m_stepAngle[side] <= M_PI_F && m_stepAngle[side] + m_searcherHalfSize >= m_nextUsedAreaStart[side])
|
||||
{
|
||||
// no used area for pass
|
||||
if (m_nextUsedAreaItr[side] == m_UsedAreaLists[side].end())
|
||||
{
|
||||
m_stepAngle[side] = M_PI_F + m_searcherHalfSize;// prevent continue search at side
|
||||
return false;
|
||||
}
|
||||
|
||||
// angle set at first possible pos after passed m_nextUsedAreaItr
|
||||
m_stepAngle[side] = m_nextUsedAreaItr[side]->first + m_nextUsedAreaItr[side]->second;
|
||||
|
||||
++m_nextUsedAreaItr[side];
|
||||
UpdateNextAreaStart(side);
|
||||
}
|
||||
|
||||
angle = m_stepAngle[side] * SignOf(side);
|
||||
|
||||
// if next node not allow use selected angle, mark and fail
|
||||
return CheckSideAngle(side, m_stepAngle[side]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Find next angle in used area, that used if no angle found in free area with LoS
|
||||
*
|
||||
* @param angle Return at success found angle
|
||||
*
|
||||
* @return true, if angle found
|
||||
*/
|
||||
bool ObjectPosSelector::NextUsedAngle(float& angle)
|
||||
{
|
||||
if (m_nextUsedAreaItr[USED_POS_PLUS] == m_UsedAreaLists[USED_POS_PLUS].end() &&
|
||||
m_nextUsedAreaItr[USED_POS_MINUS] == m_UsedAreaLists[USED_POS_MINUS].end())
|
||||
return false;
|
||||
|
||||
// ++ direction less updated
|
||||
if (m_nextUsedAreaItr[USED_POS_PLUS] != m_UsedAreaLists[USED_POS_PLUS].end() &&
|
||||
(m_nextUsedAreaItr[USED_POS_MINUS] == m_UsedAreaLists[USED_POS_MINUS].end() ||
|
||||
m_nextUsedAreaItr[USED_POS_PLUS]->first <= m_nextUsedAreaItr[USED_POS_MINUS]->first))
|
||||
{
|
||||
angle = m_nextUsedAreaItr[USED_POS_PLUS]->first * SignOf(USED_POS_PLUS);
|
||||
++m_nextUsedAreaItr[USED_POS_PLUS];
|
||||
}
|
||||
else
|
||||
{
|
||||
angle = m_nextUsedAreaItr[USED_POS_MINUS]->first * SignOf(USED_POS_MINUS);
|
||||
++m_nextUsedAreaItr[USED_POS_MINUS];
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue