ObjectPosSelector Struct Reference

#include <ObjectPosSelector.h>

Classes
struct	UsedPos

Public Types
typedef std::multimap< float, UsedPos >	UsedPosList

Public Member Functions
	ObjectPosSelector (float x, float y, float size, float dist)
void	AddUsedPos (float size, float angle, float dist)
void	InitializeAngle ()
bool	FirstAngle (float &angle)
bool	NextAngle (float &angle)
bool	NextUsedAngle (float &angle)
bool	NextPosibleAngle (float &angle)
bool	CheckAngle (UsedPosList::value_type const &nextUsedPos, float sign, float angle) const
bool	CheckOriginal () const
bool	IsNonBalanced () const
bool	NextAngleFor (UsedPosList::value_type const &usedPos, float sign, UsedPosType uptype, float &angle)
bool	NextSmallStepAngle (float sign, UsedPosType uptype, float &angle)
UsedPosList::value_type const *	nextUsedPos (UsedPosType uptype)
float	GetAngle (UsedPos const &usedPos) const

Public Attributes
float	m_center_x
float	m_center_y
float	m_size
float	m_dist
float	m_anglestep
UsedPosList	m_UsedPosLists [2]
UsedPosList::const_iterator	m_nextUsedPos [2]
float	m_smallStepAngle [2]
bool	m_smallStepOk [2]
UsedPosList::value_type const *	m_smallStepNextUsedPos [2]

Member Typedef Documentation

typedef std::multimap<float, UsedPos> ObjectPosSelector::UsedPosList

Constructor & Destructor Documentation

ObjectPosSelector::ObjectPosSelector	(	float	x,
		float	y,
		float	size,
		float	dist
	)

: m_center_x(x), m_center_y(y), m_size(size), m_dist(dist)
{
 m_anglestep = std::acos(m_dist/(m_dist+2*m_size));

 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;
}

Here is the call graph for this function:

Member Function Documentation

void ObjectPosSelector::AddUsedPos	(	float	size,
		float	angle,
		float	dist
	)

{
 if (angle >= 0)
 m_UsedPosLists[USED_POS_PLUS].insert(UsedPosList::value_type(angle, UsedPos(1.0f, size, dist)));
 else
 m_UsedPosLists[USED_POS_MINUS].insert(UsedPosList::value_type(-angle, UsedPos(-1.0f, size, dist)));
}

bool ObjectPosSelector::CheckAngle ( UsedPosList::value_type const &  nextUsedPos, float  sign, float  angle  ) const

inline

 {
 float angle_step2 = GetAngle(nextUsedPos.second);

 float next_angle = nextUsedPos.first;
 if (nextUsedPos.second.sign * sign < 0) // last node from diff. list (-pi+alpha)
 next_angle = 2 * float(M_PI) - next_angle; // move to positive

 return std::fabs(angle) + angle_step2 <= next_angle;
 }

bool ObjectPosSelector::CheckOriginal ( ) const

inline

 {
 return (m_UsedPosLists[USED_POS_PLUS].empty() || CheckAngle(*m_UsedPosLists[USED_POS_PLUS].begin(), 1.0f, 0)) &&
 (m_UsedPosLists[USED_POS_MINUS].empty() || CheckAngle(*m_UsedPosLists[USED_POS_MINUS].begin(), -1.0f, 0));
 }

bool ObjectPosSelector::FirstAngle

(

float &

angle

)

{
 if (m_UsedPosLists[USED_POS_PLUS].empty() && !m_UsedPosLists[USED_POS_MINUS].empty())
 return NextAngleFor(*m_UsedPosLists[USED_POS_MINUS].begin(), 1.0f, 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.0f, USED_POS_MINUS, angle);

 return false;
}

Here is the call graph for this function:

float ObjectPosSelector::GetAngle ( UsedPos const &  usedPos ) const

inline

{ return std::acos(m_dist/(usedPos.dist+usedPos.size+m_size)); }

Here is the call graph for this function:

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;
}

bool ObjectPosSelector::IsNonBalanced ( ) const

inline

{ return m_UsedPosLists[USED_POS_PLUS].empty() != m_UsedPosLists[USED_POS_MINUS].empty(); }

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] )
 {
 // calculate next possible angle
 if (NextPosibleAngle(angle))
 return true;
 }

 return false;
}

Here is the call graph for this function:

bool ObjectPosSelector::NextAngleFor ( UsedPosList::value_type const &  usedPos, float  sign, UsedPosType  uptype, float &  angle  )

inline

 {
 float angle_step = GetAngle(usedPos.second);

 // next possible angle
 angle = usedPos.first * usedPos.second.sign + angle_step * sign;

 UsedPosList::value_type const* nextNode = nextUsedPos(uptype);
 if (nextNode)
 {
 // if next node permit use selected angle, then do it
 if (!CheckAngle(*nextNode, sign, angle))
 {
 m_smallStepOk[uptype] = false;
 return false;
 }
 }

 // possible more points
 m_smallStepOk[uptype] = true;
 m_smallStepAngle[uptype] = angle;
 m_smallStepNextUsedPos[uptype] = nextNode;

 return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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.0f, USED_POS_PLUS, angle);
 else
 ok = NextAngleFor(*m_nextUsedPos[USED_POS_PLUS], 1.0f, 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.0f, USED_POS_MINUS, angle);
 else
 ok = NextAngleFor(*m_nextUsedPos[USED_POS_MINUS], -1.0f, 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]))
 return NextSmallStepAngle(1.0f, USED_POS_PLUS, angle);
 // -- direction less updated
 else if (m_smallStepOk[USED_POS_MINUS])
 return NextSmallStepAngle(-1.0f, USED_POS_MINUS, angle);
 }

 // no angles
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool ObjectPosSelector::NextSmallStepAngle ( float  sign, UsedPosType  uptype, float &  angle  )

inline

 {
 // next possible angle
 angle = m_smallStepAngle[uptype] + m_anglestep * sign;

 if (std::fabs(angle) > float(M_PI))
 {
 m_smallStepOk[uptype] = false;
 return false;
 }

 if (m_smallStepNextUsedPos[uptype])
 {
 if (std::fabs(angle) >= m_smallStepNextUsedPos[uptype]->first)
 {
 m_smallStepOk[uptype] = false;
 return false;
 }

 // if next node permit use selected angle, then do it
 if (!CheckAngle(*m_smallStepNextUsedPos[uptype], sign, angle))
 {
 m_smallStepOk[uptype] = false;
 return false;
 }
 }

 // possible more points
 m_smallStepAngle[uptype] = angle;
 return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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;
}

Here is the call graph for this function:

ObjectPosSelector::UsedPosList::value_type const * ObjectPosSelector::nextUsedPos

(

UsedPosType

uptype

)

{
 UsedPosList::const_iterator itr = m_nextUsedPos[uptype];
 if (itr!=m_UsedPosLists[uptype].end())
 ++itr;

 if (itr==m_UsedPosLists[uptype].end())
 {
 if (!m_UsedPosLists[~uptype].empty())
 return &*m_UsedPosLists[~uptype].rbegin();
 else
 return NULL;
 }
 else
 return &*itr;
}

Member Data Documentation

float ObjectPosSelector::m_anglestep

float ObjectPosSelector::m_center_x

float ObjectPosSelector::m_center_y

float ObjectPosSelector::m_dist

UsedPosList::const_iterator ObjectPosSelector::m_nextUsedPos[2]

float ObjectPosSelector::m_size

float ObjectPosSelector::m_smallStepAngle[2]

UsedPosList::value_type const* ObjectPosSelector::m_smallStepNextUsedPos[2]

bool ObjectPosSelector::m_smallStepOk[2]

UsedPosList ObjectPosSelector::m_UsedPosLists[2]

---

The documentation for this struct was generated from the following files:

• src/server/game/Entities/Object/ObjectPosSelector.h
• src/server/game/Entities/Object/ObjectPosSelector.cpp