Position Struct Reference

#include <Position.h>

Classes
struct	ConstStreamer
struct	Streamer

Public Member Functions
	Position (float x=0, float y=0, float z=0, float o=0)
bool	operator== (Position const &a) const
bool	operator!= (Position const &a) const
void	Relocate (float x, float y)
void	Relocate (float x, float y, float z)
void	Relocate (float x, float y, float z, float o)
void	Relocate (Position const &pos)
void	Relocate (Position const *pos)
void	RelocateOffset (Position const &offset)
void	SetOrientation (float orientation)
float	GetPositionX () const
float	GetPositionY () const
float	GetPositionZ () const
float	GetOrientation () const
void	GetPosition (float &x, float &y) const
void	GetPosition (float &x, float &y, float &z) const
void	GetPosition (float &x, float &y, float &z, float &o) const
Position	GetPosition () const
Streamer< XY >	PositionXYStream ()
ConstStreamer< XY >	PositionXYStream () const
Streamer< XYZ >	PositionXYZStream ()
ConstStreamer< XYZ >	PositionXYZStream () const
Streamer< XYZO >	PositionXYZOStream ()
ConstStreamer< XYZO >	PositionXYZOStream () const
Streamer< PackedXYZ >	PositionPackedXYZStream ()
ConstStreamer< PackedXYZ >	PositionPackedXYZStream () const
bool	IsPositionValid () const
float	GetExactDist2dSq (const float x, const float y) const
float	GetExactDist2dSq (Position const &pos) const
float	GetExactDist2dSq (Position const *pos) const
float	GetExactDist2d (const float x, const float y) const
float	GetExactDist2d (Position const &pos) const
float	GetExactDist2d (Position const *pos) const
float	GetExactDistSq (float x, float y, float z) const
float	GetExactDistSq (Position const &pos) const
float	GetExactDistSq (Position const *pos) const
float	GetExactDist (float x, float y, float z) const
float	GetExactDist (Position const &pos) const
float	GetExactDist (Position const *pos) const
void	GetPositionOffsetTo (Position const &endPos, Position &retOffset) const
Position	GetPositionWithOffset (Position const &offset) const
float	GetAbsoluteAngle (float x, float y) const
float	GetAbsoluteAngle (Position const &pos) const
float	GetAbsoluteAngle (Position const *pos) const
float	ToAbsoluteAngle (float relAngle) const
float	ToRelativeAngle (float absAngle) const
float	GetRelativeAngle (float x, float y) const
float	GetRelativeAngle (Position const &pos) const
float	GetRelativeAngle (Position const *pos) const
bool	IsInDist2d (float x, float y, float dist) const
bool	IsInDist2d (Position const *pos, float dist) const
bool	IsInDist (float x, float y, float z, float dist) const
bool	IsInDist (Position const &pos, float dist) const
bool	IsInDist (Position const *pos, float dist) const
bool	IsWithinBox (Position const &center, float xradius, float yradius, float zradius) const
bool	IsWithinDoubleVerticalCylinder (Position const *center, float radius, float height) const
bool	HasInArc (float arcangle, Position const *pos, float border=2.0f) const
bool	HasInLine (Position const *pos, float objSize, float width) const
std::string	ToString () const

Static Public Member Functions
static float	NormalizeOrientation (float o)

Public Attributes
float	m_positionX
float	m_positionY
float	m_positionZ

Private Attributes
float	m_orientation

Constructor & Destructor Documentation

Position()

Position::Position ( float  x = 0, float  y = 0, float  z = 0, float  o = 0  )

inline

 : m_positionX(x), m_positionY(y), m_positionZ(z), m_orientation(NormalizeOrientation(o)) { }

Member Function Documentation

GetAbsoluteAngle() [1/3]

float Position::GetAbsoluteAngle ( float  x, float  y  ) const

inline

 {
 float dx = x - m_positionX;
 float dy = y - m_positionY;
 return NormalizeOrientation(std::atan2(dy, dx));
 }

Here is the caller graph for this function:

GetAbsoluteAngle() [2/3]

float Position::GetAbsoluteAngle ( Position const &  pos ) const

inline

{ return GetAbsoluteAngle(pos.m_positionX, pos.m_positionY); }

Here is the call graph for this function:

Here is the caller graph for this function:

GetAbsoluteAngle() [3/3]

float Position::GetAbsoluteAngle ( Position const *  pos ) const

inline

{ return GetAbsoluteAngle(*pos); }

Here is the call graph for this function:

Here is the caller graph for this function:

GetExactDist() [1/3]

float Position::GetExactDist ( float  x, float  y, float  z  ) const

inline

{ return std::sqrt(GetExactDistSq(x, y, z)); }

Here is the caller graph for this function:

GetExactDist() [2/3]

float Position::GetExactDist ( Position const &  pos ) const

inline

{ return GetExactDist(pos.m_positionX, pos.m_positionY, pos.m_positionZ); }

Here is the call graph for this function:

Here is the caller graph for this function:

GetExactDist() [3/3]

float Position::GetExactDist ( Position const *  pos ) const

inline

{ return GetExactDist(*pos); }

Here is the call graph for this function:

Here is the caller graph for this function:

GetExactDist2d() [1/3]

float Position::GetExactDist2d ( const float  x, const float  y  ) const

inline

{ return std::sqrt(GetExactDist2dSq(x, y)); }

Here is the caller graph for this function:

GetExactDist2d() [2/3]

float Position::GetExactDist2d ( Position const &  pos ) const

inline

{ return GetExactDist2d(pos.m_positionX, pos.m_positionY); }

Here is the call graph for this function:

Here is the caller graph for this function:

GetExactDist2d() [3/3]

float Position::GetExactDist2d ( Position const *  pos ) const

inline

{ return GetExactDist2d(*pos); }

Here is the call graph for this function:

Here is the caller graph for this function:

GetExactDist2dSq() [1/3]

float Position::GetExactDist2dSq ( const float  x, const float  y  ) const

inline

 {
 float dx = x - m_positionX;
 float dy = y - m_positionY;
 return dx*dx + dy*dy;
 }

Here is the caller graph for this function:

GetExactDist2dSq() [2/3]

float Position::GetExactDist2dSq ( Position const &  pos ) const

inline

{ return GetExactDist2dSq(pos.m_positionX, pos.m_positionY); }

Here is the call graph for this function:

Here is the caller graph for this function:

GetExactDist2dSq() [3/3]

float Position::GetExactDist2dSq ( Position const *  pos ) const

inline

{ return GetExactDist2dSq(*pos); }

Here is the call graph for this function:

Here is the caller graph for this function:

GetExactDistSq() [1/3]

float Position::GetExactDistSq ( float  x, float  y, float  z  ) const

inline

 {
 float dz = z - m_positionZ;
 return GetExactDist2dSq(x, y) + dz*dz;
 }

Here is the caller graph for this function:

GetExactDistSq() [2/3]

float Position::GetExactDistSq ( Position const &  pos ) const

inline

{ return GetExactDistSq(pos.m_positionX, pos.m_positionY, pos.m_positionZ); }

Here is the call graph for this function:

Here is the caller graph for this function:

GetExactDistSq() [3/3]

float Position::GetExactDistSq ( Position const *  pos ) const

inline

{ return GetExactDistSq(*pos); }

Here is the call graph for this function:

Here is the caller graph for this function:

GetOrientation()

float Position::GetOrientation ( ) const

inline

{ return m_orientation; }

GetPosition() [1/4]

Position Position::GetPosition ( ) const

inline

{ return *this; }

Here is the caller graph for this function:

GetPosition() [2/4]

void Position::GetPosition ( float &  x, float &  y  ) const

inline

{ x = m_positionX; y = m_positionY; }

GetPosition() [3/4]

void Position::GetPosition ( float &  x, float &  y, float &  z  ) const

inline

{ GetPosition(x, y); z = m_positionZ; }

Here is the call graph for this function:

Here is the caller graph for this function:

GetPosition() [4/4]

void Position::GetPosition ( float &  x, float &  y, float &  z, float &  o  ) const

inline

{ GetPosition(x, y, z); o = m_orientation; }

Here is the call graph for this function:

Here is the caller graph for this function:

GetPositionOffsetTo()

void Position::GetPositionOffsetTo	(	Position const &	endPos,
		Position &	retOffset
	)		const

{
 float dx = endPos.GetPositionX() - GetPositionX();
 float dy = endPos.GetPositionY() - GetPositionY();
 
 retOffset.m_positionX = dx * std::cos(GetOrientation()) + dy * std::sin(GetOrientation());
 retOffset.m_positionY = dy * std::cos(GetOrientation()) - dx * std::sin(GetOrientation());
 retOffset.m_positionZ = endPos.GetPositionZ() - GetPositionZ();
 retOffset.SetOrientation(endPos.GetOrientation() - GetOrientation());
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetPositionWithOffset()

Position Position::GetPositionWithOffset

(

Position const &

offset

)

const

{
 Position ret(*this);
 ret.RelocateOffset(offset);
 return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetPositionX()

float Position::GetPositionX ( ) const

inline

{ return m_positionX; }

GetPositionY()

float Position::GetPositionY ( ) const

inline

{ return m_positionY; }

GetPositionZ()

float Position::GetPositionZ ( ) const

inline

{ return m_positionZ; }

GetRelativeAngle() [1/3]

float Position::GetRelativeAngle ( float  x, float  y  ) const

inline

{ return ToRelativeAngle(GetAbsoluteAngle(x, y)); }

Here is the caller graph for this function:

GetRelativeAngle() [2/3]

float Position::GetRelativeAngle ( Position const &  pos ) const

inline

{ return ToRelativeAngle(GetAbsoluteAngle(pos)); }

GetRelativeAngle() [3/3]

float Position::GetRelativeAngle ( Position const *  pos ) const

inline

{ return ToRelativeAngle(GetAbsoluteAngle(pos)); }

HasInArc()

bool Position::HasInArc	(	float	arcangle,
		Position const *	pos,
		float	border = 2.0f
	)		const

{
 // always have self in arc
 if (obj == this)
 return true;
 
 // move arc to range 0.. 2*pi
 arc = NormalizeOrientation(arc);
 
 // move angle to range -pi ... +pi
 float angle = GetRelativeAngle(obj);
 if (angle > float(M_PI))
 angle -= 2.0f * float(M_PI);
 
 float lborder = -1 * (arc / border); // in range -pi..0
 float rborder = (arc / border); // in range 0..pi
 return ((angle >= lborder) && (angle <= rborder));
}

Here is the call graph for this function:

Here is the caller graph for this function:

HasInLine()

bool Position::HasInLine	(	Position const *	pos,
		float	objSize,
		float	width
	)		const

{
 if (!HasInArc(float(M_PI), pos, 2.0f))
 return false;
 
 width += objSize;
 float angle = GetRelativeAngle(pos);
 return std::fabs(std::sin(angle)) * GetExactDist2d(pos->GetPositionX(), pos->GetPositionY()) < width;
}

Here is the call graph for this function:

Here is the caller graph for this function:

IsInDist() [1/3]

bool Position::IsInDist ( float  x, float  y, float  z, float  dist  ) const

inline

{ return GetExactDistSq(x, y, z) < dist * dist; }

Here is the caller graph for this function:

IsInDist() [2/3]

bool Position::IsInDist ( Position const &  pos, float  dist  ) const

inline

{ return GetExactDistSq(pos) < dist * dist; }

IsInDist() [3/3]

bool Position::IsInDist ( Position const *  pos, float  dist  ) const

inline

{ return GetExactDistSq(pos) < dist * dist; }

IsInDist2d() [1/2]

bool Position::IsInDist2d ( float  x, float  y, float  dist  ) const

inline

{ return GetExactDist2dSq(x, y) < dist * dist; }

Here is the caller graph for this function:

IsInDist2d() [2/2]

bool Position::IsInDist2d ( Position const *  pos, float  dist  ) const

inline

{ return GetExactDist2dSq(pos) < dist * dist; }

IsPositionValid()

bool Position::IsPositionValid

(

)

const

{
 return Trinity::IsValidMapCoord(m_positionX, m_positionY, m_positionZ, m_orientation);
}

Here is the call graph for this function:

Here is the caller graph for this function:

IsWithinBox()

bool Position::IsWithinBox	(	Position const &	center,
		float	xradius,
		float	yradius,
		float	zradius
	)		const

{
 // rotate the WorldObject position instead of rotating the whole cube, that way we can make a simplified
 // is-in-cube check and we have to calculate only one point instead of 4
 
 // 2PI = 360*, keep in mind that ingame orientation is counter-clockwise
 double rotation = 2 * M_PI - center.GetOrientation();
 double sinVal = std::sin(rotation);
 double cosVal = std::cos(rotation);
 
 float BoxDistX = GetPositionX() - center.GetPositionX();
 float BoxDistY = GetPositionY() - center.GetPositionY();
 
 float rotX = float(center.GetPositionX() + BoxDistX * cosVal - BoxDistY*sinVal);
 float rotY = float(center.GetPositionY() + BoxDistY * cosVal + BoxDistX*sinVal);
 
 // box edges are parallel to coordiante axis, so we can treat every dimension independently :D
 float dz = GetPositionZ() - center.GetPositionZ();
 float dx = rotX - center.GetPositionX();
 float dy = rotY - center.GetPositionY();
 if ((std::fabs(dx) > xradius) ||
 (std::fabs(dy) > yradius) ||
 (std::fabs(dz) > zradius))
 return false;
 
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

IsWithinDoubleVerticalCylinder()

bool Position::IsWithinDoubleVerticalCylinder	(	Position const *	center,
		float	radius,
		float	height
	)		const

{
 float verticalDelta = GetPositionZ() - center->GetPositionZ();
 return IsInDist2d(center, radius) && std::abs(verticalDelta) <= height;
}

Here is the call graph for this function:

Here is the caller graph for this function:

NormalizeOrientation()

float Position::NormalizeOrientation ( float  o )

static

{
 // fmod only supports positive numbers. Thus we have
 // to emulate negative numbers
 if (o < 0)
 {
 float mod = o *-1;
 mod = std::fmod(mod, 2.0f * static_cast<float>(M_PI));
 mod = -mod + 2.0f * static_cast<float>(M_PI);
 return mod;
 }
 return std::fmod(o, 2.0f * static_cast<float>(M_PI));
}

Here is the caller graph for this function:

operator!=()

bool Position::operator!= ( Position const &  a ) const

inline

{ return !(operator==(a)); }

Here is the call graph for this function:

operator==()

bool Position::operator==

(

Position const &

a

)

const

{
 return (G3D::fuzzyEq(a.m_positionX, m_positionX) &&
 G3D::fuzzyEq(a.m_positionY, m_positionY) &&
 G3D::fuzzyEq(a.m_positionZ, m_positionZ) &&
 G3D::fuzzyEq(a.m_orientation, m_orientation));
}

PositionPackedXYZStream() [1/2]

Streamer< PackedXYZ > Position::PositionPackedXYZStream ( )

inline

{ return Streamer<PackedXYZ>(*this); }

PositionPackedXYZStream() [2/2]

ConstStreamer< PackedXYZ > Position::PositionPackedXYZStream ( ) const

inline

{ return ConstStreamer<PackedXYZ>(*this); }

PositionXYStream() [1/2]

Streamer< XY > Position::PositionXYStream ( )

inline

{ return Streamer<XY>(*this); }

PositionXYStream() [2/2]

ConstStreamer< XY > Position::PositionXYStream ( ) const

inline

{ return ConstStreamer<XY>(*this); }

PositionXYZOStream() [1/2]

Streamer< XYZO > Position::PositionXYZOStream ( )

inline

{ return Streamer<XYZO>(*this); }

Here is the caller graph for this function:

PositionXYZOStream() [2/2]

ConstStreamer< XYZO > Position::PositionXYZOStream ( ) const

inline

{ return ConstStreamer<XYZO>(*this); }

PositionXYZStream() [1/2]

Streamer< XYZ > Position::PositionXYZStream ( )

inline

{ return Streamer<XYZ>(*this); }

Here is the caller graph for this function:

PositionXYZStream() [2/2]

ConstStreamer< XYZ > Position::PositionXYZStream ( ) const

inline

{ return ConstStreamer<XYZ>(*this); }

Relocate() [1/5]

void Position::Relocate ( float  x, float  y  )

inline

{ m_positionX = x; m_positionY = y; }

Here is the caller graph for this function:

Relocate() [2/5]

void Position::Relocate ( float  x, float  y, float  z  )

inline

{ Relocate(x, y); m_positionZ = z; }

Here is the call graph for this function:

Here is the caller graph for this function:

Relocate() [3/5]

void Position::Relocate ( float  x, float  y, float  z, float  o  )

inline

{ Relocate(x, y, z); SetOrientation(o); }

Here is the call graph for this function:

Here is the caller graph for this function:

Relocate() [4/5]

void Position::Relocate ( Position const &  pos )

inline

{ *this = pos; }

Relocate() [5/5]

void Position::Relocate ( Position const *  pos )

inline

{ *this = *pos; }

RelocateOffset()

void Position::RelocateOffset

(

Position const &

offset

)

{
 m_positionX = GetPositionX() + (offset.GetPositionX() * std::cos(GetOrientation()) + offset.GetPositionY() * std::sin(GetOrientation() + float(M_PI)));
 m_positionY = GetPositionY() + (offset.GetPositionY() * std::cos(GetOrientation()) + offset.GetPositionX() * std::sin(GetOrientation()));
 m_positionZ = GetPositionZ() + offset.GetPositionZ();
 SetOrientation(GetOrientation() + offset.GetOrientation());
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetOrientation()

void Position::SetOrientation ( float  orientation )

inline

 {
 m_orientation = NormalizeOrientation(orientation);
 }

Here is the caller graph for this function:

ToAbsoluteAngle()

float Position::ToAbsoluteAngle ( float  relAngle ) const

inline

{ return NormalizeOrientation(relAngle + m_orientation); }

Here is the caller graph for this function:

ToRelativeAngle()

float Position::ToRelativeAngle ( float  absAngle ) const

inline

{ return NormalizeOrientation(absAngle - m_orientation); }

ToString()

std::string Position::ToString

(

)

const

{
 std::stringstream sstr;
 sstr << "X: " << m_positionX << " Y: " << m_positionY << " Z: " << m_positionZ << " O: " << m_orientation;
 return sstr.str();
}

Here is the caller graph for this function:

Member Data Documentation

m_orientation

float Position::m_orientation

private

m_positionX

float Position::m_positionX

m_positionY

float Position::m_positionY

m_positionZ

float Position::m_positionZ

---

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

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