Position.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "Position.h"
#include "ByteBuffer.h"
#include "DB2Stores.h"
#include "GridDefines.h"
#include "World.h"
#include <G3D/g3dmath.h>
#include <sstream>
 
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));
}
 
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());
}
 
bool Position::IsPositionValid() const
{
 return Trinity::IsValidMapCoord(m_positionX, m_positionY, m_positionZ, m_orientation);
}
 
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());
}
 
Position Position::GetPositionWithOffset(Position const& offset) const
{
 Position ret(*this);
 ret.RelocateOffset(offset);
 return ret;
}
 
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;
}
 
bool Position::IsWithinDoubleVerticalCylinder(Position const* center, float radius, float height) const
{
 float verticalDelta = GetPositionZ() - center->GetPositionZ();
 return IsInDist2d(center, radius) && std::abs(verticalDelta) <= height;
}
 
bool Position::HasInArc(float arc, Position const* obj, float border) 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));
}
 
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;
}
 
std::string Position::ToString() const
{
 std::stringstream sstr;
 sstr << "X: " << m_positionX << " Y: " << m_positionY << " Z: " << m_positionZ << " O: " << m_orientation;
 return sstr.str();
}
 
float Position::NormalizeOrientation(float o)
{
 // 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));
}
 
ByteBuffer& operator<<(ByteBuffer& buf, Position::ConstStreamer<Position::XY> const& streamer)
{
 buf << streamer.Pos->GetPositionX();
 buf << streamer.Pos->GetPositionY();
 return buf;
}
 
ByteBuffer& operator>>(ByteBuffer& buf, Position::Streamer<Position::XY> const& streamer)
{
 float x, y;
 buf >> x >> y;
 streamer.Pos->Relocate(x, y);
 return buf;
}
 
ByteBuffer& operator<<(ByteBuffer& buf, Position::ConstStreamer<Position::XYZ> const& streamer)
{
 buf << streamer.Pos->GetPositionX();
 buf << streamer.Pos->GetPositionY();
 buf << streamer.Pos->GetPositionZ();
 return buf;
}
 
ByteBuffer& operator>>(ByteBuffer& buf, Position::Streamer<Position::XYZ> const& streamer)
{
 float x, y, z;
 buf >> x >> y >> z;
 streamer.Pos->Relocate(x, y, z);
 return buf;
}
 
ByteBuffer& operator<<(ByteBuffer& buf, Position::ConstStreamer<Position::XYZO> const& streamer)
{
 buf << streamer.Pos->GetPositionX();
 buf << streamer.Pos->GetPositionY();
 buf << streamer.Pos->GetPositionZ();
 buf << streamer.Pos->GetOrientation();
 return buf;
}
 
ByteBuffer& operator>>(ByteBuffer& buf, Position::Streamer<Position::XYZO> const& streamer)
{
 float x, y, z, o;
 buf >> x >> y >> z >> o;
 streamer.Pos->Relocate(x, y, z, o);
 return buf;
}
 
ByteBuffer& operator<<(ByteBuffer& buf, Position::ConstStreamer<Position::PackedXYZ> const& streamer)
{
 buf.appendPackXYZ(streamer.Pos->GetPositionX(), streamer.Pos->GetPositionY(), streamer.Pos->GetPositionZ());
 return buf;
}
 
std::string WorldLocation::GetDebugInfo() const
{
 std::stringstream sstr;
 MapEntry const* mapEntry = sMapStore.LookupEntry(m_mapId);
 sstr << "MapID: " << m_mapId << " Map name: '" << (mapEntry ? mapEntry->MapName[sWorld->GetDefaultDbcLocale()] : "<not found>") <<"' " << Position::ToString();
 return sstr.str();
}