Merge branch 'master' of github.com:TrinityCore/TrinityCore into 4.3.4

This commit is contained in:
Shauren committed 2013-06-18 21:04:31 +02:00
commit f517467817
116 files changed
+7709 -3082

No files matched your search

-1
View File
@@ -10,7 +10,6 @@
# NOTE: Do not use glob here, it would include files we don't want
set(ace_STAT_SRCS
PrecompiledHeaders/WinAcePCH.cpp
ACE.cpp
ACE_crc32.cpp
ACE_crc_ccitt.cpp
@@ -1,2 +1,3 @@
#include "WinAcePCH.h"
+25 -2
View File
@@ -19,18 +19,41 @@
#ifndef DETOURALLOCATOR_H
#define DETOURALLOCATOR_H
/// Provides hint values to the memory allocator on how long the
/// memory is expected to be used.
enum dtAllocHint
{
DT_ALLOC_PERM, // Memory persist after a function call.
DT_ALLOC_TEMP // Memory used temporarily within a function.
DT_ALLOC_PERM, ///< Memory persist after a function call.
DT_ALLOC_TEMP ///< Memory used temporarily within a function.
};
/// A memory allocation function.
// @param[in] size The size, in bytes of memory, to allocate.
// @param[in] rcAllocHint A hint to the allocator on how long the memory is expected to be in use.
// @return A pointer to the beginning of the allocated memory block, or null if the allocation failed.
/// @see dtAllocSetCustom
typedef void* (dtAllocFunc)(int size, dtAllocHint hint);
/// A memory deallocation function.
/// @param[in] ptr A pointer to a memory block previously allocated using #dtAllocFunc.
/// @see dtAllocSetCustom
typedef void (dtFreeFunc)(void* ptr);
/// Sets the base custom allocation functions to be used by Detour.
/// @param[in] allocFunc The memory allocation function to be used by #dtAlloc
/// @param[in] freeFunc The memory de-allocation function to be used by #dtFree
void dtAllocSetCustom(dtAllocFunc *allocFunc, dtFreeFunc *freeFunc);
/// Allocates a memory block.
/// @param[in] size The size, in bytes of memory, to allocate.
/// @param[in] hint A hint to the allocator on how long the memory is expected to be in use.
/// @return A pointer to the beginning of the allocated memory block, or null if the allocation failed.
/// @see dtFree
void* dtAlloc(int size, dtAllocHint hint);
/// Deallocates a memory block.
/// @param[in] ptr A pointer to a memory block previously allocated using #dtAlloc.
/// @see dtAlloc
void dtFree(void* ptr);
#endif
+1 -1
View File
@@ -24,7 +24,7 @@
#ifdef NDEBUG
// From http://cnicholson.net/2009/02/stupid-c-tricks-adventures-in-assert/
# define dtAssert(x) do { (void)sizeof(x); } while(__LINE__==-1,false)
# define dtAssert(x) do { (void)sizeof(x); } while((void)(__LINE__==-1),false)
#else
# include <assert.h>
# define dtAssert assert
@@ -238,6 +238,9 @@ bool dtClosestHeightPointTriangle(const float* p, const float* a, const float* b
return false;
}
/// @par
///
/// All points are projected onto the xz-plane, so the y-values are ignored.
bool dtPointInPolygon(const float* pt, const float* verts, const int nverts)
{
// TODO: Replace pnpoly with triArea2D tests?
@@ -291,6 +294,9 @@ inline bool overlapRange(const float amin, const float amax,
return ((amin+eps) > bmax || (amax-eps) < bmin) ? false : true;
}
/// @par
///
/// All vertices are projected onto the xz-plane, so the y-values are ignored.
bool dtOverlapPolyPoly2D(const float* polya, const int npolya,
const float* polyb, const int npolyb)
{
@@ -327,3 +333,61 @@ bool dtOverlapPolyPoly2D(const float* polya, const int npolya,
return true;
}
// Returns a random point in a convex polygon.
// Adapted from Graphics Gems article.
void dtRandomPointInConvexPoly(const float* pts, const int npts, float* areas,
const float s, const float t, float* out)
{
// Calc triangle araes
float areasum = 0.0f;
for (int i = 2; i < npts; i++) {
areas[i] = dtTriArea2D(&pts[0], &pts[(i-1)*3], &pts[i*3]);
areasum += dtMax(0.001f, areas[i]);
}
// Find sub triangle weighted by area.
const float thr = s*areasum;
float acc = 0.0f;
float u = 0.0f;
int tri = 0;
for (int i = 2; i < npts; i++) {
const float dacc = areas[i];
if (thr >= acc && thr < (acc+dacc))
{
u = (thr - acc) / dacc;
tri = i;
break;
}
acc += dacc;
}
float v = dtSqrt(t);
const float a = 1 - v;
const float b = (1 - u) * v;
const float c = u * v;
const float* pa = &pts[0];
const float* pb = &pts[(tri-1)*3];
const float* pc = &pts[tri*3];
out[0] = a*pa[0] + b*pb[0] + c*pc[0];
out[1] = a*pa[1] + b*pb[1] + c*pc[1];
out[2] = a*pa[2] + b*pb[2] + c*pc[2];
}
inline float vperpXZ(const float* a, const float* b) { return a[0]*b[2] - a[2]*b[0]; }
bool dtIntersectSegSeg2D(const float* ap, const float* aq,
const float* bp, const float* bq,
float& s, float& t)
{
float u[3], v[3], w[3];
dtVsub(u,aq,ap);
dtVsub(v,bq,bp);
dtVsub(w,ap,bp);
float d = vperpXZ(u,v);
if (fabsf(d) < 1e-6f) return false;
s = vperpXZ(v,w) / d;
t = vperpXZ(u,w) / d;
return true;
}
+325 -43
View File
@@ -19,15 +19,66 @@
#ifndef DETOURCOMMON_H
#define DETOURCOMMON_H
/**
@defgroup detour Detour
Members in this module are used to create, manipulate, and query navigation
meshes.
@note This is a summary list of members. Use the index or search
feature to find minor members.
*/
/// @name General helper functions
/// @{
/// Swaps the values of the two parameters.
/// @param[in,out] a Value A
/// @param[in,out] b Value B
template<class T> inline void dtSwap(T& a, T& b) { T t = a; a = b; b = t; }
/// Returns the minimum of two values.
/// @param[in] a Value A
/// @param[in] b Value B
/// @return The minimum of the two values.
template<class T> inline T dtMin(T a, T b) { return a < b ? a : b; }
/// Returns the maximum of two values.
/// @param[in] a Value A
/// @param[in] b Value B
/// @return The maximum of the two values.
template<class T> inline T dtMax(T a, T b) { return a > b ? a : b; }
/// Returns the absolute value.
/// @param[in] a The value.
/// @return The absolute value of the specified value.
template<class T> inline T dtAbs(T a) { return a < 0 ? -a : a; }
/// Returns the square of the value.
/// @param[in] a The value.
/// @return The square of the value.
template<class T> inline T dtSqr(T a) { return a*a; }
/// Clamps the value to the specified range.
/// @param[in] v The value to clamp.
/// @param[in] mn The minimum permitted return value.
/// @param[in] mx The maximum permitted return value.
/// @return The value, clamped to the specified range.
template<class T> inline T dtClamp(T v, T mn, T mx) { return v < mn ? mn : (v > mx ? mx : v); }
/// Returns the square root of the value.
/// @param[in] x The value.
/// @return The square root of the vlaue.
float dtSqrt(float x);
/// @}
/// @name Vector helper functions.
/// @{
/// Derives the cross product of two vectors. (@p v1 x @p v2)
/// @param[out] dest The cross product. [(x, y, z)]
/// @param[in] v1 A Vector [(x, y, z)]
/// @param[in] v2 A vector [(x, y, z)]
inline void dtVcross(float* dest, const float* v1, const float* v2)
{
dest[0] = v1[1]*v2[2] - v1[2]*v2[1];
@@ -35,11 +86,20 @@ inline void dtVcross(float* dest, const float* v1, const float* v2)
dest[2] = v1[0]*v2[1] - v1[1]*v2[0];
}
/// Derives the dot product of two vectors. (@p v1 . @p v2)
/// @param[in] v1 A Vector [(x, y, z)]
/// @param[in] v2 A vector [(x, y, z)]
/// @return The dot product.
inline float dtVdot(const float* v1, const float* v2)
{
return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2];
}
/// Performs a scaled vector addition. (@p v1 + (@p v2 * @p s))
/// @param[out] dest The result vector. [(x, y, z)]
/// @param[in] v1 The base vector. [(x, y, z)]
/// @param[in] v2 The vector to scale and add to @p v1. [(x, y, z)]
/// @param[in] s The amount to scale @p v2 by before adding to @p v1.
inline void dtVmad(float* dest, const float* v1, const float* v2, const float s)
{
dest[0] = v1[0]+v2[0]*s;
@@ -47,6 +107,11 @@ inline void dtVmad(float* dest, const float* v1, const float* v2, const float s)
dest[2] = v1[2]+v2[2]*s;
}
/// Performs a linear interpolation between two vectors. (@p v1 toward @p v2)
/// @param[out] dest The result vector. [(x, y, x)]
/// @param[in] v1 The starting vector.
/// @param[in] v2 The destination vector.
/// @param[in] t The interpolation factor. [Limits: 0 <= value <= 1.0]
inline void dtVlerp(float* dest, const float* v1, const float* v2, const float t)
{
dest[0] = v1[0]+(v2[0]-v1[0])*t;
@@ -54,6 +119,10 @@ inline void dtVlerp(float* dest, const float* v1, const float* v2, const float t
dest[2] = v1[2]+(v2[2]-v1[2])*t;
}
/// Performs a vector addition. (@p v1 + @p v2)
/// @param[out] dest The result vector. [(x, y, z)]
/// @param[in] v1 The base vector. [(x, y, z)]
/// @param[in] v2 The vector to add to @p v1. [(x, y, z)]
inline void dtVadd(float* dest, const float* v1, const float* v2)
{
dest[0] = v1[0]+v2[0];
@@ -61,6 +130,10 @@ inline void dtVadd(float* dest, const float* v1, const float* v2)
dest[2] = v1[2]+v2[2];
}
/// Performs a vector subtraction. (@p v1 - @p v2)
/// @param[out] dest The result vector. [(x, y, z)]
/// @param[in] v1 The base vector. [(x, y, z)]
/// @param[in] v2 The vector to subtract from @p v1. [(x, y, z)]
inline void dtVsub(float* dest, const float* v1, const float* v2)
{
dest[0] = v1[0]-v2[0];
@@ -68,6 +141,10 @@ inline void dtVsub(float* dest, const float* v1, const float* v2)
dest[2] = v1[2]-v2[2];
}
/// Scales the vector by the specified value. (@p v * @p t)
/// @param[out] dest The result vector. [(x, y, z)]
/// @param[in] v The vector to scale. [(x, y, z)]
/// @param[in] t The scaling factor.
inline void dtVscale(float* dest, const float* v, const float t)
{
dest[0] = v[0]*t;
@@ -75,6 +152,9 @@ inline void dtVscale(float* dest, const float* v, const float t)
dest[2] = v[2]*t;
}
/// Selects the minimum value of each element from the specified vectors.
/// @param[in,out] mn A vector. (Will be updated with the result.) [(x, y, z)]
/// @param[in] v A vector. [(x, y, z)]
inline void dtVmin(float* mn, const float* v)
{
mn[0] = dtMin(mn[0], v[0]);
@@ -82,6 +162,9 @@ inline void dtVmin(float* mn, const float* v)
mn[2] = dtMin(mn[2], v[2]);
}
/// Selects the maximum value of each element from the specified vectors.
/// @param[in,out] mx A vector. (Will be updated with the result.) [(x, y, z)]
/// @param[in] v A vector. [(x, y, z)]
inline void dtVmax(float* mx, const float* v)
{
mx[0] = dtMax(mx[0], v[0]);
@@ -89,11 +172,19 @@ inline void dtVmax(float* mx, const float* v)
mx[2] = dtMax(mx[2], v[2]);
}
/// Sets the vector elements to the specified values.
/// @param[out] dest The result vector. [(x, y, z)]
/// @param[in] x The x-value of the vector.
/// @param[in] y The y-value of the vector.
/// @param[in] z The z-value of the vector.
inline void dtVset(float* dest, const float x, const float y, const float z)
{
dest[0] = x; dest[1] = y; dest[2] = z;
}
/// Performs a vector copy.
/// @param[out] dest The result. [(x, y, z)]
/// @param[in] a The vector to copy. [(x, y, z)]
inline void dtVcopy(float* dest, const float* a)
{
dest[0] = a[0];
@@ -101,16 +192,26 @@ inline void dtVcopy(float* dest, const float* a)
dest[2] = a[2];
}
/// Derives the scalar length of the vector.
/// @param[in] v The vector. [(x, y, z)]
/// @return The scalar length of the vector.
inline float dtVlen(const float* v)
{
return dtSqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
}
/// Derives the square of the scalar length of the vector. (len * len)
/// @param[in] v The vector. [(x, y, z)]
/// @return The square of the scalar length of the vector.
inline float dtVlenSqr(const float* v)
{
return v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
}
/// Returns the distance between two points.
/// @param[in] v1 A point. [(x, y, z)]
/// @param[in] v2 A point. [(x, y, z)]
/// @return The distance between the two points.
inline float dtVdist(const float* v1, const float* v2)
{
const float dx = v2[0] - v1[0];
@@ -119,6 +220,10 @@ inline float dtVdist(const float* v1, const float* v2)
return dtSqrt(dx*dx + dy*dy + dz*dz);
}
/// Returns the square of the distance between two points.
/// @param[in] v1 A point. [(x, y, z)]
/// @param[in] v2 A point. [(x, y, z)]
/// @return The square of the distance between the two points.
inline float dtVdistSqr(const float* v1, const float* v2)
{
const float dx = v2[0] - v1[0];
@@ -127,6 +232,12 @@ inline float dtVdistSqr(const float* v1, const float* v2)
return dx*dx + dy*dy + dz*dz;
}
/// Derives the distance between the specified points on the xz-plane.
/// @param[in] v1 A point. [(x, y, z)]
/// @param[in] v2 A point. [(x, y, z)]
/// @return The distance between the point on the xz-plane.
///
/// The vectors are projected onto the xz-plane, so the y-values are ignored.
inline float dtVdist2D(const float* v1, const float* v2)
{
const float dx = v2[0] - v1[0];
@@ -134,6 +245,10 @@ inline float dtVdist2D(const float* v1, const float* v2)
return dtSqrt(dx*dx + dz*dz);
}
/// Derives the square of the distance between the specified points on the xz-plane.
/// @param[in] v1 A point. [(x, y, z)]
/// @param[in] v2 A point. [(x, y, z)]
/// @return The square of the distance between the point on the xz-plane.
inline float dtVdist2DSqr(const float* v1, const float* v2)
{
const float dx = v2[0] - v1[0];
@@ -141,6 +256,8 @@ inline float dtVdist2DSqr(const float* v1, const float* v2)
return dx*dx + dz*dz;
}
/// Normalizes the vector.
/// @param[in,out] v The vector to normalize. [(x, y, z)]
inline void dtVnormalize(float* v)
{
float d = 1.0f / dtSqrt(dtSqr(v[0]) + dtSqr(v[1]) + dtSqr(v[2]));
@@ -149,6 +266,13 @@ inline void dtVnormalize(float* v)
v[2] *= d;
}
/// Performs a 'sloppy' colocation check of the specified points.
/// @param[in] p0 A point. [(x, y, z)]
/// @param[in] p1 A point. [(x, y, z)]
/// @return True if the points are considered to be at the same location.
///
/// Basically, this function will return true if the specified points are
/// close enough to eachother to be considered colocated.
inline bool dtVequal(const float* p0, const float* p1)
{
static const float thr = dtSqr(1.0f/16384.0f);
@@ -156,6 +280,138 @@ inline bool dtVequal(const float* p0, const float* p1)
return d < thr;
}
/// Derives the dot product of two vectors on the xz-plane. (@p u . @p v)
/// @param[in] u A vector [(x, y, z)]
/// @param[in] v A vector [(x, y, z)]
/// @return The dot product on the xz-plane.
///
/// The vectors are projected onto the xz-plane, so the y-values are ignored.
inline float dtVdot2D(const float* u, const float* v)
{
return u[0]*v[0] + u[2]*v[2];
}
/// Derives the xz-plane 2D perp product of the two vectors. (uz*vx - ux*vz)
/// @param[in] u The LHV vector [(x, y, z)]
/// @param[in] v The RHV vector [(x, y, z)]
/// @return The dot product on the xz-plane.
///
/// The vectors are projected onto the xz-plane, so the y-values are ignored.
inline float dtVperp2D(const float* u, const float* v)
{
return u[2]*v[0] - u[0]*v[2];
}
/// @}
/// @name Computational geometry helper functions.
/// @{
/// Derives the signed xz-plane area of the triangle ABC, or the relationship of line AB to point C.
/// @param[in] a Vertex A. [(x, y, z)]
/// @param[in] b Vertex B. [(x, y, z)]
/// @param[in] c Vertex C. [(x, y, z)]
/// @return The signed xz-plane area of the triangle.
inline float dtTriArea2D(const float* a, const float* b, const float* c)
{
const float abx = b[0] - a[0];
const float abz = b[2] - a[2];
const float acx = c[0] - a[0];
const float acz = c[2] - a[2];
return acx*abz - abx*acz;
}
/// Determines if two axis-aligned bounding boxes overlap.
/// @param[in] amin Minimum bounds of box A. [(x, y, z)]
/// @param[in] amax Maximum bounds of box A. [(x, y, z)]
/// @param[in] bmin Minimum bounds of box B. [(x, y, z)]
/// @param[in] bmax Maximum bounds of box B. [(x, y, z)]
/// @return True if the two AABB's overlap.
/// @see dtOverlapBounds
inline bool dtOverlapQuantBounds(const unsigned short amin[3], const unsigned short amax[3],
const unsigned short bmin[3], const unsigned short bmax[3])
{
bool overlap = true;
overlap = (amin[0] > bmax[0] || amax[0] < bmin[0]) ? false : overlap;
overlap = (amin[1] > bmax[1] || amax[1] < bmin[1]) ? false : overlap;
overlap = (amin[2] > bmax[2] || amax[2] < bmin[2]) ? false : overlap;
return overlap;
}
/// Determines if two axis-aligned bounding boxes overlap.
/// @param[in] amin Minimum bounds of box A. [(x, y, z)]
/// @param[in] amax Maximum bounds of box A. [(x, y, z)]
/// @param[in] bmin Minimum bounds of box B. [(x, y, z)]
/// @param[in] bmax Maximum bounds of box B. [(x, y, z)]
/// @return True if the two AABB's overlap.
/// @see dtOverlapQuantBounds
inline bool dtOverlapBounds(const float* amin, const float* amax,
const float* bmin, const float* bmax)
{
bool overlap = true;
overlap = (amin[0] > bmax[0] || amax[0] < bmin[0]) ? false : overlap;
overlap = (amin[1] > bmax[1] || amax[1] < bmin[1]) ? false : overlap;
overlap = (amin[2] > bmax[2] || amax[2] < bmin[2]) ? false : overlap;
return overlap;
}
/// Derives the closest point on a triangle from the specified reference point.
/// @param[out] closest The closest point on the triangle.
/// @param[in] p The reference point from which to test. [(x, y, z)]
/// @param[in] a Vertex A of triangle ABC. [(x, y, z)]
/// @param[in] b Vertex B of triangle ABC. [(x, y, z)]
/// @param[in] c Vertex C of triangle ABC. [(x, y, z)]
void dtClosestPtPointTriangle(float* closest, const float* p,
const float* a, const float* b, const float* c);
/// Derives the y-axis height of the closest point on the triangle from the specified reference point.
/// @param[in] p The reference point from which to test. [(x, y, z)]
/// @param[in] a Vertex A of triangle ABC. [(x, y, z)]
/// @param[in] b Vertex B of triangle ABC. [(x, y, z)]
/// @param[in] c Vertex C of triangle ABC. [(x, y, z)]
/// @param[out] h The resulting height.
bool dtClosestHeightPointTriangle(const float* p, const float* a, const float* b, const float* c, float& h);
bool dtIntersectSegmentPoly2D(const float* p0, const float* p1,
const float* verts, int nverts,
float& tmin, float& tmax,
int& segMin, int& segMax);
bool dtIntersectSegSeg2D(const float* ap, const float* aq,
const float* bp, const float* bq,
float& s, float& t);
/// Determines if the specified point is inside the convex polygon on the xz-plane.
/// @param[in] pt The point to check. [(x, y, z)]
/// @param[in] verts The polygon vertices. [(x, y, z) * @p nverts]
/// @param[in] nverts The number of vertices. [Limit: >= 3]
/// @return True if the point is inside the polygon.
bool dtPointInPolygon(const float* pt, const float* verts, const int nverts);
bool dtDistancePtPolyEdgesSqr(const float* pt, const float* verts, const int nverts,
float* ed, float* et);
float dtDistancePtSegSqr2D(const float* pt, const float* p, const float* q, float& t);
/// Derives the centroid of a convex polygon.
/// @param[out] tc The centroid of the polgyon. [(x, y, z)]
/// @param[in] idx The polygon indices. [(vertIndex) * @p nidx]
/// @param[in] nidx The number of indices in the polygon. [Limit: >= 3]
/// @param[in] verts The polygon vertices. [(x, y, z) * vertCount]
void dtCalcPolyCenter(float* tc, const unsigned short* idx, int nidx, const float* verts);
/// Determines if the two convex polygons overlap on the xz-plane.
/// @param[in] polya Polygon A vertices. [(x, y, z) * @p npolya]
/// @param[in] npolya The number of vertices in polygon A.
/// @param[in] polyb Polygon B vertices. [(x, y, z) * @p npolyb]
/// @param[in] npolyb The number of vertices in polygon B.
/// @return True if the two polygons overlap.
bool dtOverlapPolyPoly2D(const float* polya, const int npolya,
const float* polyb, const int npolyb);
/// @}
/// @name Miscellanious functions.
/// @{
inline unsigned int dtNextPow2(unsigned int v)
{
v--;
@@ -184,65 +440,91 @@ inline int dtAlign4(int x) { return (x+3) & ~3; }
inline int dtOppositeTile(int side) { return (side+4) & 0x7; }
inline float dtVdot2D(const float* u, const float* v)
inline void dtSwapByte(unsigned char* a, unsigned char* b)
{
return u[0]*v[0] + u[2]*v[2];
unsigned char tmp = *a;
*a = *b;
*b = tmp;
}
inline float dtVperp2D(const float* u, const float* v)
inline void dtSwapEndian(unsigned short* v)
{
return u[2]*v[0] - u[0]*v[2];
unsigned char* x = (unsigned char*)v;
dtSwapByte(x+0, x+1);
}
inline float dtTriArea2D(const float* a, const float* b, const float* c)
inline void dtSwapEndian(short* v)
{
const float abx = b[0] - a[0];
const float abz = b[2] - a[2];
const float acx = c[0] - a[0];
const float acz = c[2] - a[2];
return acx*abz - abx*acz;
unsigned char* x = (unsigned char*)v;
dtSwapByte(x+0, x+1);
}
inline bool dtOverlapQuantBounds(const unsigned short amin[3], const unsigned short amax[3],
const unsigned short bmin[3], const unsigned short bmax[3])
inline void dtSwapEndian(unsigned int* v)
{
bool overlap = true;
overlap = (amin[0] > bmax[0] || amax[0] < bmin[0]) ? false : overlap;
overlap = (amin[1] > bmax[1] || amax[1] < bmin[1]) ? false : overlap;
overlap = (amin[2] > bmax[2] || amax[2] < bmin[2]) ? false : overlap;
return overlap;
unsigned char* x = (unsigned char*)v;
dtSwapByte(x+0, x+3); dtSwapByte(x+1, x+2);
}
inline bool dtOverlapBounds(const float* amin, const float* amax,
const float* bmin, const float* bmax)
inline void dtSwapEndian(int* v)
{
bool overlap = true;
overlap = (amin[0] > bmax[0] || amax[0] < bmin[0]) ? false : overlap;
overlap = (amin[1] > bmax[1] || amax[1] < bmin[1]) ? false : overlap;
overlap = (amin[2] > bmax[2] || amax[2] < bmin[2]) ? false : overlap;
return overlap;
unsigned char* x = (unsigned char*)v;
dtSwapByte(x+0, x+3); dtSwapByte(x+1, x+2);
}
void dtClosestPtPointTriangle(float* closest, const float* p,
const float* a, const float* b, const float* c);
inline void dtSwapEndian(float* v)
{
unsigned char* x = (unsigned char*)v;
dtSwapByte(x+0, x+3); dtSwapByte(x+1, x+2);
}
bool dtClosestHeightPointTriangle(const float* p, const float* a, const float* b, const float* c, float& h);
void dtRandomPointInConvexPoly(const float* pts, const int npts, float* areas,
const float s, const float t, float* out);
bool dtIntersectSegmentPoly2D(const float* p0, const float* p1,
const float* verts, int nverts,
float& tmin, float& tmax,
int& segMin, int& segMax);
bool dtPointInPolygon(const float* pt, const float* verts, const int nverts);
bool dtDistancePtPolyEdgesSqr(const float* pt, const float* verts, const int nverts,
float* ed, float* et);
float dtDistancePtSegSqr2D(const float* pt, const float* p, const float* q, float& t);
void dtCalcPolyCenter(float* tc, const unsigned short* idx, int nidx, const float* verts);
bool dtOverlapPolyPoly2D(const float* polya, const int npolya,
const float* polyb, const int npolyb);
/// @}
#endif // DETOURCOMMON_H
///////////////////////////////////////////////////////////////////////////
// This section contains detailed documentation for members that don't have
// a source file. It reduces clutter in the main section of the header.
/**
@fn float dtTriArea2D(const float* a, const float* b, const float* c)
@par
The vertices are projected onto the xz-plane, so the y-values are ignored.
This is a low cost function than can be used for various purposes. Its main purpose
is for point/line relationship testing.
In all cases: A value of zero indicates that all vertices are collinear or represent the same point.
(On the xz-plane.)
When used for point/line relationship tests, AB usually represents a line against which
the C point is to be tested. In this case:
A positive value indicates that point C is to the left of line AB, looking from A toward B.<br/>
A negative value indicates that point C is to the right of lineAB, looking from A toward B.
When used for evaluating a triangle:
The absolute value of the return value is two times the area of the triangle when it is
projected onto the xz-plane.
A positive return value indicates:
<ul>
<li>The vertices are wrapped in the normal Detour wrap direction.</li>
<li>The triangle's 3D face normal is in the general up direction.</li>
</ul>
A negative return value indicates:
<ul>
<li>The vertices are reverse wrapped. (Wrapped opposite the normal Detour wrap direction.)</li>
<li>The triangle's 3D face normal is in the general down direction.</li>
</ul>
*/
File diff suppressed because it is too large. Load diff
+505 -223
View File
@@ -20,9 +20,12 @@
#define DETOURNAVMESH_H
#include "DetourAlloc.h"
#include "DetourStatus.h"
// Edited by TC
#if defined(WIN32) && !defined(__MINGW32__)
typedef unsigned __int64 uint64;
typedef unsigned __int64 uint64;
#else
#include <stdint.h>
#ifndef uint64_t
@@ -30,312 +33,473 @@
#include <linux/types.h>
#endif
#endif
typedef uint64_t uint64;
#endif
typedef uint64_t uint64;
#endif
// Note: If you want to use 64-bit refs, change the types of both dtPolyRef & dtTileRef.
// It is also recommended to change dtHashRef() to proper 64-bit hash too.
// Reference to navigation polygon.
typedef uint64 dtPolyRef;
// Reference to navigation mesh tile.
typedef uint64 dtTileRef;
// Maximum number of vertices per navigation polygon.
static const int DT_VERTS_PER_POLYGON = 6;
static const int DT_NAVMESH_MAGIC = 'D'<<24 | 'N'<<16 | 'A'<<8 | 'V'; //'DNAV';
static const int DT_NAVMESH_VERSION = 6;
static const int DT_NAVMESH_STATE_MAGIC = 'D'<<24 | 'N'<<16 | 'M'<<8 | 'S'; //'DNMS';
static const int DT_NAVMESH_STATE_VERSION = 1;
static const unsigned short DT_EXT_LINK = 0x8000;
static const unsigned int DT_NULL_LINK = 0xffffffff;
static const unsigned int DT_OFFMESH_CON_BIDIR = 1;
static const int DT_MAX_AREAS = 64;
// It is also recommended that you change dtHashRef() to a proper 64-bit hash.
// Edited by TC
// We cannot have over 31 bits for either tile nor poly
// without changing polyCount to use 64bits too.
static const int STATIC_SALT_BITS = 12;
static const int STATIC_TILE_BITS = 21;
static const int STATIC_POLY_BITS = 31;
// we cannot have over 31 bits for either tile nor poly
// without changing polyCount to use 64bits too.
static const int STATIC_POLY_BITS = 31;
// Flags for addTile
/// A handle to a polygon within a navigation mesh tile.
/// @ingroup detour
typedef uint64 dtPolyRef; // Edited by TC
/// A handle to a tile within a navigation mesh.
/// @ingroup detour
typedef uint64 dtTileRef; // Edited by TC
/// The maximum number of vertices per navigation polygon.
/// @ingroup detour
static const int DT_VERTS_PER_POLYGON = 6;
/// @{
/// @name Tile Serialization Constants
/// These constants are used to detect whether a navigation tile's data
/// and state format is compatible with the current build.
///
/// A magic number used to detect compatibility of navigation tile data.
static const int DT_NAVMESH_MAGIC = 'D'<<24 | 'N'<<16 | 'A'<<8 | 'V';
/// A version number used to detect compatibility of navigation tile data.
static const int DT_NAVMESH_VERSION = 7;
/// A magic number used to detect the compatibility of navigation tile states.
static const int DT_NAVMESH_STATE_MAGIC = 'D'<<24 | 'N'<<16 | 'M'<<8 | 'S';
/// A version number used to detect compatibility of navigation tile states.
static const int DT_NAVMESH_STATE_VERSION = 1;
/// @}
/// A flag that indicates that an entity links to an external entity.
/// (E.g. A polygon edge is a portal that links to another polygon.)
static const unsigned short DT_EXT_LINK = 0x8000;
/// A value that indicates the entity does not link to anything.
static const unsigned int DT_NULL_LINK = 0xffffffff;
/// A flag that indicates that an off-mesh connection can be traversed in both directions. (Is bidirectional.)
static const unsigned int DT_OFFMESH_CON_BIDIR = 1;
/// The maximum number of user defined area ids.
/// @ingroup detour
static const int DT_MAX_AREAS = 64;
/// Tile flags used for various functions and fields.
/// For an example, see dtNavMesh::addTile().
enum dtTileFlags
{
DT_TILE_FREE_DATA = 0x01, // Navmesh owns the tile memory and should free it.
/// The navigation mesh owns the tile memory and is responsible for freeing it.
DT_TILE_FREE_DATA = 0x01,
};
// Flags returned by findStraightPath().
/// Vertex flags returned by dtNavMeshQuery::findStraightPath.
enum dtStraightPathFlags
{
DT_STRAIGHTPATH_START = 0x01, // The vertex is the start position.
DT_STRAIGHTPATH_END = 0x02, // The vertex is the end position.
DT_STRAIGHTPATH_OFFMESH_CONNECTION = 0x04, // The vertex is start of an off-mesh link.
DT_STRAIGHTPATH_START = 0x01, ///< The vertex is the start position in the path.
DT_STRAIGHTPATH_END = 0x02, ///< The vertex is the end position in the path.
DT_STRAIGHTPATH_OFFMESH_CONNECTION = 0x04, ///< The vertex is the start of an off-mesh connection.
};
// Flags describing polygon properties.
/// Options for dtNavMeshQuery::findStraightPath.
enum dtStraightPathOptions
{
DT_STRAIGHTPATH_AREA_CROSSINGS = 0x01, ///< Add a vertex at every polygon edge crossing where area changes.
DT_STRAIGHTPATH_ALL_CROSSINGS = 0x02, ///< Add a vertex at every polygon edge crossing.
};
/// Flags representing the type of a navigation mesh polygon.
enum dtPolyTypes
{
DT_POLYTYPE_GROUND = 0, // Regular ground polygons.
DT_POLYTYPE_OFFMESH_CONNECTION = 1, // Off-mesh connections.
};
enum dtStatus
{
DT_FAILURE = 0, // Operation failed.
DT_FAILURE_DATA_MAGIC,
DT_FAILURE_DATA_VERSION,
DT_FAILURE_OUT_OF_MEMORY,
DT_SUCCESS, // Operation succeed.
DT_IN_PROGRESS, // Operation still in progress.
/// The polygon is a standard convex polygon that is part of the surface of the mesh.
DT_POLYTYPE_GROUND = 0,
/// The polygon is an off-mesh connection consisting of two vertices.
DT_POLYTYPE_OFFMESH_CONNECTION = 1,
};
// Structure describing the navigation polygon data.
/// Defines a polyogn within a dtMeshTile object.
/// @ingroup detour
struct dtPoly
{
unsigned int firstLink; // Index to first link in linked list.
unsigned short verts[DT_VERTS_PER_POLYGON]; // Indices to vertices of the poly.
unsigned short neis[DT_VERTS_PER_POLYGON]; // Refs to neighbours of the poly.
unsigned short flags; // Flags (see dtPolyFlags).
unsigned char vertCount; // Number of vertices.
unsigned char areaAndtype; // Bit packed: Area ID of the polygon, and Polygon type, see dtPolyTypes..
/// Index to first link in linked list. (Or #DT_NULL_LINK if there is no link.)
unsigned int firstLink;
/// The indices of the polygon's vertices.
/// The actual vertices are located in dtMeshTile::verts.
unsigned short verts[DT_VERTS_PER_POLYGON];
/// Packed data representing neighbor polygons references and flags for each edge.
unsigned short neis[DT_VERTS_PER_POLYGON];
/// The user defined polygon flags.
unsigned short flags;
/// The number of vertices in the polygon.
unsigned char vertCount;
/// The bit packed area id and polygon type.
/// @note Use the structure's set and get methods to acess this value.
unsigned char areaAndtype;
/// Sets the user defined area id. [Limit: < #DT_MAX_AREAS]
inline void setArea(unsigned char a) { areaAndtype = (areaAndtype & 0xc0) | (a & 0x3f); }
/// Sets the polygon type. (See: #dtPolyTypes.)
inline void setType(unsigned char t) { areaAndtype = (areaAndtype & 0x3f) | (t << 6); }
/// Gets the user defined area id.
inline unsigned char getArea() const { return areaAndtype & 0x3f; }
/// Gets the polygon type. (See: #dtPolyTypes)
inline unsigned char getType() const { return areaAndtype >> 6; }
};
// Stucture describing polygon detail triangles.
/// Defines the location of detail sub-mesh data within a dtMeshTile.
struct dtPolyDetail
{
unsigned int vertBase; // Offset to detail vertex array.
unsigned int triBase; // Offset to detail triangle array.
unsigned char vertCount; // Number of vertices in the detail mesh.
unsigned char triCount; // Number of triangles.
unsigned int vertBase; ///< The offset of the vertices in the dtMeshTile::detailVerts array.
unsigned int triBase; ///< The offset of the triangles in the dtMeshTile::detailTris array.
unsigned char vertCount; ///< The number of vertices in the sub-mesh.
unsigned char triCount; ///< The number of triangles in the sub-mesh.
};
// Stucture describing a link to another polygon.
/// Defines a link between polygons.
/// @note This structure is rarely if ever used by the end user.
/// @see dtMeshTile
struct dtLink
{
dtPolyRef ref; // Neighbour reference.
unsigned int next; // Index to next link.
unsigned char edge; // Index to polygon edge which owns this link.
unsigned char side; // If boundary link, defines on which side the link is.
unsigned char bmin, bmax; // If boundary link, defines the sub edge area.
dtPolyRef ref; ///< Neighbour reference. (The neighbor that is linked to.)
unsigned int next; ///< Index of the next link.
unsigned char edge; ///< Index of the polygon edge that owns this link.
unsigned char side; ///< If a boundary link, defines on which side the link is.
unsigned char bmin; ///< If a boundary link, defines the minimum sub-edge area.
unsigned char bmax; ///< If a boundary link, defines the maximum sub-edge area.
};
/// Bounding volume node.
/// @note This structure is rarely if ever used by the end user.
/// @see dtMeshTile
struct dtBVNode
{
unsigned short bmin[3], bmax[3]; // BVnode bounds
int i; // Index to item or if negative, escape index.
unsigned short bmin[3]; ///< Minimum bounds of the node's AABB. [(x, y, z)]
unsigned short bmax[3]; ///< Maximum bounds of the node's AABB. [(x, y, z)]
int i; ///< The node's index. (Negative for escape sequence.)
};
/// Defines an navigation mesh off-mesh connection within a dtMeshTile object.
/// An off-mesh connection is a user defined traversable connection made up to two vertices.
struct dtOffMeshConnection
{
float pos[6]; // Both end point locations.
float rad; // Link connection radius.
unsigned short poly; // Poly Id
unsigned char flags; // Link flags
unsigned char side; // End point side.
unsigned int userId; // User ID to identify this connection.
/// The endpoints of the connection. [(ax, ay, az, bx, by, bz)]
float pos[6];
/// The radius of the endpoints. [Limit: >= 0]
float rad;
/// The polygon reference of the connection within the tile.
unsigned short poly;
/// Link flags.
/// @note These are not the connection's user defined flags. Those are assigned via the
/// connection's dtPoly definition. These are link flags used for internal purposes.
unsigned char flags;
/// End point side.
unsigned char side;
/// The id of the offmesh connection. (User assigned when the navigation mesh is built.)
unsigned int userId;
};
/// Provides high level information related to a dtMeshTile object.
/// @ingroup detour
struct dtMeshHeader
{
int magic; // Magic number, used to identify the data.
int version; // Data version number.
int x, y; // Location of the time on the grid.
unsigned int userId; // User ID of the tile.
int polyCount; // Number of polygons in the tile.
int vertCount; // Number of vertices in the tile.
int maxLinkCount; // Number of allocated links.
int detailMeshCount; // Number of detail meshes.
int detailVertCount; // Number of detail vertices.
int detailTriCount; // Number of detail triangles.
int bvNodeCount; // Number of BVtree nodes.
int offMeshConCount; // Number of Off-Mesh links.
int offMeshBase; // Index to first polygon which is Off-Mesh link.
float walkableHeight; // Height of the agent.
float walkableRadius; // Radius of the agent
float walkableClimb; // Max climb height of the agent.
float bmin[3], bmax[3]; // Bounding box of the tile.
float bvQuantFactor; // BVtree quantization factor (world to bvnode coords)
int magic; ///< Tile magic number. (Used to identify the data format.)
int version; ///< Tile data format version number.
int x; ///< The x-position of the tile within the dtNavMesh tile grid. (x, y, layer)
int y; ///< The y-position of the tile within the dtNavMesh tile grid. (x, y, layer)
int layer; ///< The layer of the tile within the dtNavMesh tile grid. (x, y, layer)
unsigned int userId; ///< The user defined id of the tile.
int polyCount; ///< The number of polygons in the tile.
int vertCount; ///< The number of vertices in the tile.
int maxLinkCount; ///< The number of allocated links.
int detailMeshCount; ///< The number of sub-meshes in the detail mesh.
/// The number of unique vertices in the detail mesh. (In addition to the polygon vertices.)
int detailVertCount;
int detailTriCount; ///< The number of triangles in the detail mesh.
int bvNodeCount; ///< The number of bounding volume nodes. (Zero if bounding volumes are disabled.)
int offMeshConCount; ///< The number of off-mesh connections.
int offMeshBase; ///< The index of the first polygon which is an off-mesh connection.
float walkableHeight; ///< The height of the agents using the tile.
float walkableRadius; ///< The radius of the agents using the tile.
float walkableClimb; ///< The maximum climb height of the agents using the tile.
float bmin[3]; ///< The minimum bounds of the tile's AABB. [(x, y, z)]
float bmax[3]; ///< The maximum bounds of the tile's AABB. [(x, y, z)]
/// The bounding volume quantization factor.
float bvQuantFactor;
};
/// Defines a navigation mesh tile.
/// @ingroup detour
struct dtMeshTile
{
unsigned int salt; // Counter describing modifications to the tile.
unsigned int salt; ///< Counter describing modifications to the tile.
unsigned int linksFreeList; // Index to next free link.
dtMeshHeader* header; // Pointer to tile header.
dtPoly* polys; // Pointer to the polygons (will be updated when tile is added).
float* verts; // Pointer to the vertices (will be updated when tile added).
dtLink* links; // Pointer to the links (will be updated when tile added).
dtPolyDetail* detailMeshes; // Pointer to detail meshes (will be updated when tile added).
float* detailVerts; // Pointer to detail vertices (will be updated when tile added).
unsigned char* detailTris; // Pointer to detail triangles (will be updated when tile added).
dtBVNode* bvTree; // Pointer to BVtree nodes (will be updated when tile added).
dtOffMeshConnection* offMeshCons; // Pointer to Off-Mesh links. (will be updated when tile added).
unsigned int linksFreeList; ///< Index to the next free link.
dtMeshHeader* header; ///< The tile header.
dtPoly* polys; ///< The tile polygons. [Size: dtMeshHeader::polyCount]
float* verts; ///< The tile vertices. [Size: dtMeshHeader::vertCount]
dtLink* links; ///< The tile links. [Size: dtMeshHeader::maxLinkCount]
dtPolyDetail* detailMeshes; ///< The tile's detail sub-meshes. [Size: dtMeshHeader::detailMeshCount]
/// The detail mesh's unique vertices. [(x, y, z) * dtMeshHeader::detailVertCount]
float* detailVerts;
/// The detail mesh's triangles. [(vertA, vertB, vertC) * dtMeshHeader::detailTriCount]
unsigned char* detailTris;
/// The tile bounding volume nodes. [Size: dtMeshHeader::bvNodeCount]
/// (Will be null if bounding volumes are disabled.)
dtBVNode* bvTree;
dtOffMeshConnection* offMeshCons; ///< The tile off-mesh connections. [Size: dtMeshHeader::offMeshConCount]
unsigned char* data; // Pointer to tile data.
int dataSize; // Size of the tile data.
int flags; // Tile flags, see dtTileFlags.
dtMeshTile* next; // Next free tile or, next tile in spatial grid.
unsigned char* data; ///< The tile data. (Not directly accessed under normal situations.)
int dataSize; ///< Size of the tile data.
int flags; ///< Tile flags. (See: #dtTileFlags)
dtMeshTile* next; ///< The next free tile, or the next tile in the spatial grid.
};
/// Configuration parameters used to define multi-tile navigation meshes.
/// The values are used to allocate space during the initialization of a navigation mesh.
/// @see dtNavMesh::init()
/// @ingroup detour
struct dtNavMeshParams
{
float orig[3]; // Origin of the nav mesh tile space.
float tileWidth, tileHeight; // Width and height of each tile.
int maxTiles; // Maximum number of tiles the navmesh can contain.
int maxPolys; // Maximum number of polygons each tile can contain.
float orig[3]; ///< The world space origin of the navigation mesh's tile space. [(x, y, z)]
float tileWidth; ///< The width of each tile. (Along the x-axis.)
float tileHeight; ///< The height of each tile. (Along the z-axis.)
int maxTiles; ///< The maximum number of tiles the navigation mesh can contain.
int maxPolys; ///< The maximum number of polygons each tile can contain.
};
/// A navigation mesh based on tiles of convex polygons.
/// @ingroup detour
class dtNavMesh
{
public:
dtNavMesh();
~dtNavMesh();
// Initializes the nav mesh for tiled use.
// Params:
// params - (in) navmesh initialization params, see dtNavMeshParams.
// Returns: True if succeed, else false.
/// @{
/// @name Initialization and Tile Management
/// Initializes the navigation mesh for tiled use.
/// @param[in] params Initialization parameters.
/// @return The status flags for the operation.
dtStatus init(const dtNavMeshParams* params);
// Initializes the nav mesh for single tile use.
// Params:
// data - (in) Data of the new tile mesh.
// dataSize - (in) Data size of the new tile mesh.
// flags - (in) Tile flags, see dtTileFlags.
// Returns: True if succeed, else false.
/// Initializes the navigation mesh for single tile use.
/// @param[in] data Data of the new tile. (See: #dtCreateNavMeshData)
/// @param[in] dataSize The data size of the new tile.
/// @param[in] flags The tile flags. (See: #dtTileFlags)
/// @return The status flags for the operation.
/// @see dtCreateNavMeshData
dtStatus init(unsigned char* data, const int dataSize, const int flags);
// Returns pointer to navmesh initialization params.
/// The navigation mesh initialization params.
const dtNavMeshParams* getParams() const;
// Adds new tile into the navmesh.
// The add will fail if the data is in wrong format,
// there is not enough tiles left, or if there is a tile already at the location.
// Params:
// data - (in) Data of the new tile mesh.
// dataSize - (in) Data size of the new tile mesh.
// flags - (in) Tile flags, see dtTileFlags.
// lastRef - (in,optional) Last tile ref, the tile will be restored so that
// the reference (as well as poly references) will be the same. Default: 0.
// result - (out,optional) tile ref if the tile was succesfully added.
/// Adds a tile to the navigation mesh.
/// @param[in] data Data for the new tile mesh. (See: #dtCreateNavMeshData)
/// @param[in] dataSize Data size of the new tile mesh.
/// @param[in] flags Tile flags. (See: #dtTileFlags)
/// @param[in] lastRef The desired reference for the tile. (When reloading a tile.) [opt] [Default: 0]
/// @param[out] result The tile reference. (If the tile was succesfully added.) [opt]
/// @return The status flags for the operation.
dtStatus addTile(unsigned char* data, int dataSize, int flags, dtTileRef lastRef, dtTileRef* result);
// Removes specified tile.
// Params:
// ref - (in) Reference to the tile to remove.
// data - (out) Data associated with deleted tile.
// dataSize - (out) Size of the data associated with deleted tile.
/// Removes the specified tile from the navigation mesh.
/// @param[in] ref The reference of the tile to remove.
/// @param[out] data Data associated with deleted tile.
/// @param[out] dataSize Size of the data associated with deleted tile.
/// @return The status flags for the operation.
dtStatus removeTile(dtTileRef ref, unsigned char** data, int* dataSize);
// Calculates tile location based in input world position.
// Params:
// pos - (in) world position of the query.
// tx - (out) tile x location.
// ty - (out) tile y location.
/// @}
/// @{
/// @name Query Functions
/// Calculates the tile grid location for the specified world position.
/// @param[in] pos The world position for the query. [(x, y, z)]
/// @param[out] tx The tile's x-location. (x, y)
/// @param[out] ty The tile's y-location. (x, y)
void calcTileLoc(const float* pos, int* tx, int* ty) const;
// Returns pointer to tile at specified location.
// Params:
// x,y - (in) Location of the tile to get.
// Returns: pointer to tile if tile exists or 0 tile does not exists.
const dtMeshTile* getTileAt(int x, int y) const;
/// Gets the tile at the specified grid location.
/// @param[in] x The tile's x-location. (x, y, layer)
/// @param[in] y The tile's y-location. (x, y, layer)
/// @param[in] layer The tile's layer. (x, y, layer)
/// @return The tile, or null if the tile does not exist.
const dtMeshTile* getTileAt(const int x, const int y, const int layer) const;
// Returns reference to tile at specified location.
// Params:
// x,y - (in) Location of the tile to get.
// Returns: reference to tile if tile exists or 0 tile does not exists.
dtTileRef getTileRefAt(int x, int y) const;
/// Gets all tiles at the specified grid location. (All layers.)
/// @param[in] x The tile's x-location. (x, y)
/// @param[in] y The tile's y-location. (x, y)
/// @param[out] tiles A pointer to an array of tiles that will hold the result.
/// @param[in] maxTiles The maximum tiles the tiles parameter can hold.
/// @return The number of tiles returned in the tiles array.
int getTilesAt(const int x, const int y,
dtMeshTile const** tiles, const int maxTiles) const;
// Returns tile references of a tile based on tile pointer.
/// Gets the tile reference for the tile at specified grid location.
/// @param[in] x The tile's x-location. (x, y, layer)
/// @param[in] y The tile's y-location. (x, y, layer)
/// @param[in] layer The tile's layer. (x, y, layer)
/// @return The tile reference of the tile, or 0 if there is none.
dtTileRef getTileRefAt(int x, int y, int layer) const;
/// Gets the tile reference for the specified tile.
/// @param[in] tile The tile.
/// @return The tile reference of the tile.
dtTileRef getTileRef(const dtMeshTile* tile) const;
// Returns tile based on references.
/// Gets the tile for the specified tile reference.
/// @param[in] ref The tile reference of the tile to retrieve.
/// @return The tile for the specified reference, or null if the
/// reference is invalid.
const dtMeshTile* getTileByRef(dtTileRef ref) const;
// Returns max number of tiles.
/// The maximum number of tiles supported by the navigation mesh.
/// @return The maximum number of tiles supported by the navigation mesh.
int getMaxTiles() const;
// Returns pointer to tile in the tile array.
// Params:
// i - (in) Index to the tile to retrieve, max index is getMaxTiles()-1.
// Returns: Pointer to specified tile.
/// Gets the tile at the specified index.
/// @param[in] i The tile index. [Limit: 0 >= index < #getMaxTiles()]
/// @return The tile at the specified index.
const dtMeshTile* getTile(int i) const;
// Returns pointer to tile and polygon pointed by the polygon reference.
// Params:
// ref - (in) reference to a polygon.
// tile - (out) pointer to the tile containing the polygon.
// poly - (out) pointer to the polygon.
/// Gets the tile and polygon for the specified polygon reference.
/// @param[in] ref The reference for the a polygon.
/// @param[out] tile The tile containing the polygon.
/// @param[out] poly The polygon.
/// @return The status flags for the operation.
dtStatus getTileAndPolyByRef(const dtPolyRef ref, const dtMeshTile** tile, const dtPoly** poly) const;
// Returns pointer to tile and polygon pointed by the polygon reference.
// Note: this function does not check if 'ref' s valid, and is thus faster. Use only with valid refs!
// Params:
// ref - (in) reference to a polygon.
// tile - (out) pointer to the tile containing the polygon.
// poly - (out) pointer to the polygon.
/// Returns the tile and polygon for the specified polygon reference.
/// @param[in] ref A known valid reference for a polygon.
/// @param[out] tile The tile containing the polygon.
/// @param[out] poly The polygon.
void getTileAndPolyByRefUnsafe(const dtPolyRef ref, const dtMeshTile** tile, const dtPoly** poly) const;
// Returns true if polygon reference points to valid data.
/// Checks the validity of a polygon reference.
/// @param[in] ref The polygon reference to check.
/// @return True if polygon reference is valid for the navigation mesh.
bool isValidPolyRef(dtPolyRef ref) const;
// Returns base poly id for specified tile, polygon refs can be deducted from this.
/// Gets the polygon reference for the tile's base polygon.
/// @param[in] tile The tile.
/// @return The polygon reference for the base polygon in the specified tile.
dtPolyRef getPolyRefBase(const dtMeshTile* tile) const;
// Returns start and end location of an off-mesh link polygon.
// Params:
// prevRef - (in) ref to the polygon before the link (used to select direction).
// polyRef - (in) ref to the off-mesh link polygon.
// startPos[3] - (out) start point of the link.
// endPos[3] - (out) end point of the link.
// Returns: true if link is found.
/// Gets the endpoints for an off-mesh connection, ordered by "direction of travel".
/// @param[in] prevRef The reference of the polygon before the connection.
/// @param[in] polyRef The reference of the off-mesh connection polygon.
/// @param[out] startPos The start position of the off-mesh connection. [(x, y, z)]
/// @param[out] endPos The end position of the off-mesh connection. [(x, y, z)]
/// @return The status flags for the operation.
dtStatus getOffMeshConnectionPolyEndPoints(dtPolyRef prevRef, dtPolyRef polyRef, float* startPos, float* endPos) const;
// Returns pointer to off-mesh connection based on polyref, or null if ref not valid.
/// Gets the specified off-mesh connection.
/// @param[in] ref The polygon reference of the off-mesh connection.
/// @return The specified off-mesh connection, or null if the polygon reference is not valid.
const dtOffMeshConnection* getOffMeshConnectionByRef(dtPolyRef ref) const;
// Sets polygon flags.
/// @}
/// @{
/// @name State Management
/// These functions do not effect #dtTileRef or #dtPolyRef's.
/// Sets the user defined flags for the specified polygon.
/// @param[in] ref The polygon reference.
/// @param[in] flags The new flags for the polygon.
/// @return The status flags for the operation.
dtStatus setPolyFlags(dtPolyRef ref, unsigned short flags);
// Return polygon flags.
/// Gets the user defined flags for the specified polygon.
/// @param[in] ref The polygon reference.
/// @param[out] resultFlags The polygon flags.
/// @return The status flags for the operation.
dtStatus getPolyFlags(dtPolyRef ref, unsigned short* resultFlags) const;
// Set polygon type.
/// Sets the user defined area for the specified polygon.
/// @param[in] ref The polygon reference.
/// @param[in] area The new area id for the polygon. [Limit: < #DT_MAX_AREAS]
/// @return The status flags for the operation.
dtStatus setPolyArea(dtPolyRef ref, unsigned char area);
// Return polygon area type.
/// Gets the user defined area for the specified polygon.
/// @param[in] ref The polygon reference.
/// @param[out] resultArea The area id for the polygon.
/// @return The status flags for the operation.
dtStatus getPolyArea(dtPolyRef ref, unsigned char* resultArea) const;
// Returns number of bytes required to store tile state.
/// Gets the size of the buffer required by #storeTileState to store the specified tile's state.
/// @param[in] tile The tile.
/// @return The size of the buffer required to store the state.
int getTileStateSize(const dtMeshTile* tile) const;
// Stores tile state to buffer.
/// Stores the non-structural state of the tile in the specified buffer. (Flags, area ids, etc.)
/// @param[in] tile The tile.
/// @param[out] data The buffer to store the tile's state in.
/// @param[in] maxDataSize The size of the data buffer. [Limit: >= #getTileStateSize]
/// @return The status flags for the operation.
dtStatus storeTileState(const dtMeshTile* tile, unsigned char* data, const int maxDataSize) const;
// Restores tile state.
/// Restores the state of the tile.
/// @param[in] tile The tile.
/// @param[in] data The new state. (Obtained from #storeTileState.)
/// @param[in] maxDataSize The size of the state within the data buffer.
/// @return The status flags for the operation.
dtStatus restoreTileState(dtMeshTile* tile, const unsigned char* data, const int maxDataSize);
/// @}
// Encodes a tile id.
/// @{
/// @name Encoding and Decoding
/// These functions are generally meant for internal use only.
/// Derives a standard polygon reference.
/// @note This function is generally meant for internal use only.
/// @param[in] salt The tile's salt value.
/// @param[in] it The index of the tile.
/// @param[in] ip The index of the polygon within the tile.
inline dtPolyRef encodePolyId(unsigned int salt, unsigned int it, unsigned int ip) const
{
return ((dtPolyRef)salt << (m_polyBits+m_tileBits)) | ((dtPolyRef)it << m_polyBits) | (dtPolyRef)ip;
}
// Decodes a tile id.
/// Decodes a standard polygon reference.
/// @note This function is generally meant for internal use only.
/// @param[in] ref The polygon reference to decode.
/// @param[out] salt The tile's salt value.
/// @param[out] it The index of the tile.
/// @param[out] ip The index of the polygon within the tile.
/// @see #encodePolyId
inline void decodePolyId(dtPolyRef ref, unsigned int& salt, unsigned int& it, unsigned int& ip) const
{
const dtPolyRef saltMask = ((dtPolyRef)1<<m_saltBits)-1;
@@ -346,83 +510,201 @@ public:
ip = (unsigned int)(ref & polyMask);
}
// Decodes a tile salt.
/// Extracts a tile's salt value from the specified polygon reference.
/// @note This function is generally meant for internal use only.
/// @param[in] ref The polygon reference.
/// @see #encodePolyId
inline unsigned int decodePolyIdSalt(dtPolyRef ref) const
{
const dtPolyRef saltMask = ((dtPolyRef)1<<m_saltBits)-1;
return (unsigned int)((ref >> (m_polyBits+m_tileBits)) & saltMask);
}
// Decodes a tile id.
/// Extracts the tile's index from the specified polygon reference.
/// @note This function is generally meant for internal use only.
/// @param[in] ref The polygon reference.
/// @see #encodePolyId
inline unsigned int decodePolyIdTile(dtPolyRef ref) const
{
const dtPolyRef tileMask = ((dtPolyRef)1<<m_tileBits)-1;
return (unsigned int)((ref >> m_polyBits) & tileMask);
}
// Decodes a poly id.
/// Extracts the polygon's index (within its tile) from the specified polygon reference.
/// @note This function is generally meant for internal use only.
/// @param[in] ref The polygon reference.
/// @see #encodePolyId
inline unsigned int decodePolyIdPoly(dtPolyRef ref) const
{
const dtPolyRef polyMask = ((dtPolyRef)1<<m_polyBits)-1;
return (unsigned int)(ref & polyMask);
}
/// @}
private:
// Returns pointer to tile in the tile array.
/// Returns pointer to tile in the tile array.
dtMeshTile* getTile(int i);
// Returns neighbour tile based on side.
dtMeshTile* getNeighbourTileAt(int x, int y, int side) const;
// Returns all polygons in neighbour tile based on portal defined by the segment.
/// Returns neighbour tile based on side.
int getTilesAt(const int x, const int y,
dtMeshTile** tiles, const int maxTiles) const;
/// Returns neighbour tile based on side.
int getNeighbourTilesAt(const int x, const int y, const int side,
dtMeshTile** tiles, const int maxTiles) const;
/// Returns all polygons in neighbour tile based on portal defined by the segment.
int findConnectingPolys(const float* va, const float* vb,
const dtMeshTile* tile, int side,
dtPolyRef* con, float* conarea, int maxcon) const;
// Builds internal polygons links for a tile.
/// Builds internal polygons links for a tile.
void connectIntLinks(dtMeshTile* tile);
// Builds internal polygons links for a tile.
void connectIntOffMeshLinks(dtMeshTile* tile);
/// Builds internal polygons links for a tile.
void baseOffMeshLinks(dtMeshTile* tile);
// Builds external polygon links for a tile.
/// Builds external polygon links for a tile.
void connectExtLinks(dtMeshTile* tile, dtMeshTile* target, int side);
// Builds external polygon links for a tile.
/// Builds external polygon links for a tile.
void connectExtOffMeshLinks(dtMeshTile* tile, dtMeshTile* target, int side);
// Removes external links at specified side.
void unconnectExtLinks(dtMeshTile* tile, int side);
/// Removes external links at specified side.
void unconnectExtLinks(dtMeshTile* tile, dtMeshTile* target);
// TODO: These methods are duplicates from dtNavMeshQuery, but are needed for off-mesh connection finding.
// Queries polygons within a tile.
/// Queries polygons within a tile.
int queryPolygonsInTile(const dtMeshTile* tile, const float* qmin, const float* qmax,
dtPolyRef* polys, const int maxPolys) const;
// Find nearest polygon within a tile.
/// Find nearest polygon within a tile.
dtPolyRef findNearestPolyInTile(const dtMeshTile* tile, const float* center,
const float* extents, float* nearestPt) const;
// Returns closest point on polygon.
dtStatus closestPointOnPolyInTile(const dtMeshTile* tile, unsigned int ip,
const float* pos, float* closest) const;
/// Returns closest point on polygon.
void closestPointOnPolyInTile(const dtMeshTile* tile, unsigned int ip,
const float* pos, float* closest) const;
dtNavMeshParams m_params; // Current initialization params. TODO: do not store this info twice.
float m_orig[3]; // Origin of the tile (0,0)
float m_tileWidth, m_tileHeight; // Dimensions of each tile.
int m_maxTiles; // Max number of tiles.
int m_tileLutSize; // Tile hash lookup size (must be pot).
int m_tileLutMask; // Tile hash lookup mask.
dtNavMeshParams m_params; ///< Current initialization params. TODO: do not store this info twice.
float m_orig[3]; ///< Origin of the tile (0,0)
float m_tileWidth, m_tileHeight; ///< Dimensions of each tile.
int m_maxTiles; ///< Max number of tiles.
int m_tileLutSize; ///< Tile hash lookup size (must be pot).
int m_tileLutMask; ///< Tile hash lookup mask.
dtMeshTile** m_posLookup; // Tile hash lookup.
dtMeshTile* m_nextFree; // Freelist of tiles.
dtMeshTile* m_tiles; // List of tiles.
dtMeshTile** m_posLookup; ///< Tile hash lookup.
dtMeshTile* m_nextFree; ///< Freelist of tiles.
dtMeshTile* m_tiles; ///< List of tiles.
unsigned int m_saltBits; // Number of salt bits in the tile ID.
unsigned int m_tileBits; // Number of tile bits in the tile ID.
unsigned int m_polyBits; // Number of poly bits in the tile ID.
unsigned int m_saltBits; ///< Number of salt bits in the tile ID.
unsigned int m_tileBits; ///< Number of tile bits in the tile ID.
unsigned int m_polyBits; ///< Number of poly bits in the tile ID.
};
// Helper function to allocate navmesh class using Detour allocator.
/// Allocates a navigation mesh object using the Detour allocator.
/// @return A navigation mesh that is ready for initialization, or null on failure.
/// @ingroup detour
dtNavMesh* dtAllocNavMesh();
/// Frees the specified navigation mesh object using the Detour allocator.
/// @param[in] navmesh A navigation mesh allocated using #dtAllocNavMesh
/// @ingroup detour
void dtFreeNavMesh(dtNavMesh* navmesh);
#endif // DETOURNAVMESH_H
///////////////////////////////////////////////////////////////////////////
// This section contains detailed documentation for members that don't have
// a source file. It reduces clutter in the main section of the header.
/**
@typedef dtPolyRef
@par
Polygon references are subject to the same invalidate/preserve/restore
rules that apply to #dtTileRef's. If the #dtTileRef for the polygon's
tile changes, the polygon reference becomes invalid.
Changing a polygon's flags, area id, etc. does not impact its polygon
reference.
@typedef dtTileRef
@par
The following changes will invalidate a tile reference:
- The referenced tile has been removed from the navigation mesh.
- The navigation mesh has been initialized using a different set
of #dtNavMeshParams.
A tile reference is preserved/restored if the tile is added to a navigation
mesh initialized with the original #dtNavMeshParams and is added at the
original reference location. (E.g. The lastRef parameter is used with
dtNavMesh::addTile.)
Basically, if the storage structure of a tile changes, its associated
tile reference changes.
@var unsigned short dtPoly::neis[DT_VERTS_PER_POLYGON]
@par
Each entry represents data for the edge starting at the vertex of the same index.
E.g. The entry at index n represents the edge data for vertex[n] to vertex[n+1].
A value of zero indicates the edge has no polygon connection. (It makes up the
border of the navigation mesh.)
The information can be extracted as follows:
@code
neighborRef = neis[n] & 0xff; // Get the neighbor polygon reference.
if (neis[n] & #DT_EX_LINK)
{
// The edge is an external (portal) edge.
}
@endcode
@var float dtMeshHeader::bvQuantFactor
@par
This value is used for converting between world and bounding volume coordinates.
For example:
@code
const float cs = 1.0f / tile->header->bvQuantFactor;
const dtBVNode* n = &tile->bvTree[i];
if (n->i >= 0)
{
// This is a leaf node.
float worldMinX = tile->header->bmin[0] + n->bmin[0]*cs;
float worldMinY = tile->header->bmin[0] + n->bmin[1]*cs;
// Etc...
}
@endcode
@struct dtMeshTile
@par
Tiles generally only exist within the context of a dtNavMesh object.
Some tile content is optional. For example, a tile may not contain any
off-mesh connections. In this case the associated pointer will be null.
If a detail mesh exists it will share vertices with the base polygon mesh.
Only the vertices unique to the detail mesh will be stored in #detailVerts.
@warning Tiles returned by a dtNavMesh object are not guarenteed to be populated.
For example: The tile at a location might not have been loaded yet, or may have been removed.
In this case, pointers will be null. So if in doubt, check the polygon count in the
tile's header to determine if a tile has polygons defined.
@var float dtOffMeshConnection::pos[6]
@par
For a properly built navigation mesh, vertex A will always be within the bounds of the mesh.
Vertex B is not required to be within the bounds of the mesh.
*/
@@ -20,6 +20,7 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <float.h>
#include "DetourNavMesh.h"
#include "DetourCommon.h"
#include "DetourNavMeshBuilder.h"
@@ -237,11 +238,19 @@ static unsigned char classifyOffMeshPoint(const float* pt, const float* bmin, co
case ZM: return 6;
case XP|ZM: return 7;
};
return 0xff;
}
// TODO: Better error handling.
/// @par
///
/// The output data array is allocated using the detour allocator (dtAlloc()). The method
/// used to free the memory will be determined by how the tile is added to the navigation
/// mesh.
///
/// @see dtNavMesh, dtNavMesh::addTile()
bool dtCreateNavMeshData(dtNavMeshCreateParams* params, unsigned char** outData, int* outDataSize)
{
if (params->nvp > DT_VERTS_PER_POLYGON)
@@ -252,8 +261,6 @@ bool dtCreateNavMeshData(dtNavMeshCreateParams* params, unsigned char** outData,
return false;
if (!params->polyCount || !params->polys)
return false;
if (!params->detailMeshes || !params->detailVerts || !params->detailTris)
return false;
const int nvp = params->nvp;
@@ -269,10 +276,50 @@ bool dtCreateNavMeshData(dtNavMeshCreateParams* params, unsigned char** outData,
if (!offMeshConClass)
return false;
// Find tight heigh bounds, used for culling out off-mesh start locations.
float hmin = FLT_MAX;
float hmax = -FLT_MAX;
if (params->detailVerts && params->detailVertsCount)
{
for (int i = 0; i < params->detailVertsCount; ++i)
{
const float h = params->detailVerts[i*3+1];
hmin = dtMin(hmin,h);
hmax = dtMax(hmax,h);
}
}
else
{
for (int i = 0; i < params->vertCount; ++i)
{
const unsigned short* iv = &params->verts[i*3];
const float h = params->bmin[1] + iv[1] * params->ch;
hmin = dtMin(hmin,h);
hmax = dtMax(hmax,h);
}
}
hmin -= params->walkableClimb;
hmax += params->walkableClimb;
float bmin[3], bmax[3];
dtVcopy(bmin, params->bmin);
dtVcopy(bmax, params->bmax);
bmin[1] = hmin;
bmax[1] = hmax;
for (int i = 0; i < params->offMeshConCount; ++i)
{
offMeshConClass[i*2+0] = classifyOffMeshPoint(&params->offMeshConVerts[(i*2+0)*3], params->bmin, params->bmax);
offMeshConClass[i*2+1] = classifyOffMeshPoint(&params->offMeshConVerts[(i*2+1)*3], params->bmin, params->bmax);
const float* p0 = &params->offMeshConVerts[(i*2+0)*3];
const float* p1 = &params->offMeshConVerts[(i*2+1)*3];
offMeshConClass[i*2+0] = classifyOffMeshPoint(p0, bmin, bmax);
offMeshConClass[i*2+1] = classifyOffMeshPoint(p1, bmin, bmax);
// Zero out off-mesh start positions which are not even potentially touching the mesh.
if (offMeshConClass[i*2+0] == 0xff)
{
if (p0[1] < bmin[1] || p0[1] > bmax[1])
offMeshConClass[i*2+0] = 0;
}
// Cound how many links should be allocated for off-mesh connections.
if (offMeshConClass[i*2+0] == 0xff)
@@ -298,23 +345,13 @@ bool dtCreateNavMeshData(dtNavMeshCreateParams* params, unsigned char** outData,
for (int j = 0; j < nvp; ++j)
{
if (p[j] == MESH_NULL_IDX) break;
int nj = j+1;
if (nj >= nvp || p[nj] == MESH_NULL_IDX) nj = 0;
const unsigned short* va = &params->verts[p[j]*3];
const unsigned short* vb = &params->verts[p[nj]*3];
edgeCount++;
if (params->tileSize > 0)
if (p[nvp+j] & 0x8000)
{
if (va[0] == params->tileSize && vb[0] == params->tileSize)
portalCount++; // x+
else if (va[2] == params->tileSize && vb[2] == params->tileSize)
portalCount++; // z+
else if (va[0] == 0 && vb[0] == 0)
portalCount++; // x-
else if (va[2] == 0 && vb[2] == 0)
portalCount++; // z-
unsigned short dir = p[nvp+j] & 0xf;
if (dir != 0xf)
portalCount++;
}
}
}
@@ -323,18 +360,41 @@ bool dtCreateNavMeshData(dtNavMeshCreateParams* params, unsigned char** outData,
// Find unique detail vertices.
int uniqueDetailVertCount = 0;
for (int i = 0; i < params->polyCount; ++i)
int detailTriCount = 0;
if (params->detailMeshes)
{
const unsigned short* p = &params->polys[i*nvp*2];
int ndv = params->detailMeshes[i*4+1];
int nv = 0;
for (int j = 0; j < nvp; ++j)
// Has detail mesh, count unique detail vertex count and use input detail tri count.
detailTriCount = params->detailTriCount;
for (int i = 0; i < params->polyCount; ++i)
{
if (p[j] == MESH_NULL_IDX) break;
nv++;
const unsigned short* p = &params->polys[i*nvp*2];
int ndv = params->detailMeshes[i*4+1];
int nv = 0;
for (int j = 0; j < nvp; ++j)
{
if (p[j] == MESH_NULL_IDX) break;
nv++;
}
ndv -= nv;
uniqueDetailVertCount += ndv;
}
}
else
{
// No input detail mesh, build detail mesh from nav polys.
uniqueDetailVertCount = 0; // No extra detail verts.
detailTriCount = 0;
for (int i = 0; i < params->polyCount; ++i)
{
const unsigned short* p = &params->polys[i*nvp*2];
int nv = 0;
for (int j = 0; j < nvp; ++j)
{
if (p[j] == MESH_NULL_IDX) break;
nv++;
}
detailTriCount += nv-2;
}
ndv -= nv;
uniqueDetailVertCount += ndv;
}
// Calculate data size
@@ -344,8 +404,8 @@ bool dtCreateNavMeshData(dtNavMeshCreateParams* params, unsigned char** outData,
const int linksSize = dtAlign4(sizeof(dtLink)*maxLinkCount);
const int detailMeshesSize = dtAlign4(sizeof(dtPolyDetail)*params->polyCount);
const int detailVertsSize = dtAlign4(sizeof(float)*3*uniqueDetailVertCount);
const int detailTrisSize = dtAlign4(sizeof(unsigned char)*4*params->detailTriCount);
const int bvTreeSize = dtAlign4(sizeof(dtBVNode)*params->polyCount*2);
const int detailTrisSize = dtAlign4(sizeof(unsigned char)*4*detailTriCount);
const int bvTreeSize = params->buildBvTree ? dtAlign4(sizeof(dtBVNode)*params->polyCount*2) : 0;
const int offMeshConsSize = dtAlign4(sizeof(dtOffMeshConnection)*storedOffMeshConCount);
const int dataSize = headerSize + vertsSize + polysSize + linksSize +
@@ -377,6 +437,7 @@ bool dtCreateNavMeshData(dtNavMeshCreateParams* params, unsigned char** outData,
header->version = DT_NAVMESH_VERSION;
header->x = params->tileX;
header->y = params->tileY;
header->layer = params->tileLayer;
header->userId = params->userId;
header->polyCount = totPolyCount;
header->vertCount = totVertCount;
@@ -385,14 +446,14 @@ bool dtCreateNavMeshData(dtNavMeshCreateParams* params, unsigned char** outData,
dtVcopy(header->bmax, params->bmax);
header->detailMeshCount = params->polyCount;
header->detailVertCount = uniqueDetailVertCount;
header->detailTriCount = params->detailTriCount;
header->detailTriCount = detailTriCount;
header->bvQuantFactor = 1.0f / params->cs;
header->offMeshBase = params->polyCount;
header->walkableHeight = params->walkableHeight;
header->walkableRadius = params->walkableRadius;
header->walkableClimb = params->walkableClimb;
header->offMeshConCount = storedOffMeshConCount;
header->bvNodeCount = params->polyCount*2;
header->bvNodeCount = params->buildBvTree ? params->polyCount*2 : 0;
const int offMeshVertsBase = params->vertCount;
const int offMeshPolyBase = params->polyCount;
@@ -436,7 +497,27 @@ bool dtCreateNavMeshData(dtNavMeshCreateParams* params, unsigned char** outData,
{
if (src[j] == MESH_NULL_IDX) break;
p->verts[j] = src[j];
p->neis[j] = (src[nvp+j]+1) & 0xffff;
if (src[nvp+j] & 0x8000)
{
// Border or portal edge.
unsigned short dir = src[nvp+j] & 0xf;
if (dir == 0xf) // Border
p->neis[j] = 0;
else if (dir == 0) // Portal x-
p->neis[j] = DT_EXT_LINK | 4;
else if (dir == 1) // Portal z+
p->neis[j] = DT_EXT_LINK | 2;
else if (dir == 2) // Portal x+
p->neis[j] = DT_EXT_LINK | 0;
else if (dir == 3) // Portal z-
p->neis[j] = DT_EXT_LINK | 6;
}
else
{
// Normal connection
p->neis[j] = src[nvp+j]+1;
}
p->vertCount++;
}
src += nvp*2;
@@ -458,61 +539,68 @@ bool dtCreateNavMeshData(dtNavMeshCreateParams* params, unsigned char** outData,
n++;
}
}
// Store portal edges.
if (params->tileSize > 0)
{
for (int i = 0; i < params->polyCount; ++i)
{
dtPoly* poly = &navPolys[i];
for (int j = 0; j < poly->vertCount; ++j)
{
int nj = j+1;
if (nj >= poly->vertCount) nj = 0;
const unsigned short* va = &params->verts[poly->verts[j]*3];
const unsigned short* vb = &params->verts[poly->verts[nj]*3];
if (va[0] == params->tileSize && vb[0] == params->tileSize) // x+
poly->neis[j] = DT_EXT_LINK | 0;
else if (va[2] == params->tileSize && vb[2] == params->tileSize) // z+
poly->neis[j] = DT_EXT_LINK | 2;
else if (va[0] == 0 && vb[0] == 0) // x-
poly->neis[j] = DT_EXT_LINK | 4;
else if (va[2] == 0 && vb[2] == 0) // z-
poly->neis[j] = DT_EXT_LINK | 6;
}
}
}
// Store detail meshes and vertices.
// The nav polygon vertices are stored as the first vertices on each mesh.
// We compress the mesh data by skipping them and using the navmesh coordinates.
unsigned short vbase = 0;
for (int i = 0; i < params->polyCount; ++i)
if (params->detailMeshes)
{
dtPolyDetail& dtl = navDMeshes[i];
const int vb = (int)params->detailMeshes[i*4+0];
const int ndv = (int)params->detailMeshes[i*4+1];
const int nv = navPolys[i].vertCount;
dtl.vertBase = (unsigned int)vbase;
dtl.vertCount = (unsigned char)(ndv-nv);
dtl.triBase = (unsigned int)params->detailMeshes[i*4+2];
dtl.triCount = (unsigned char)params->detailMeshes[i*4+3];
// Copy vertices except the first 'nv' verts which are equal to nav poly verts.
if (ndv-nv)
unsigned short vbase = 0;
for (int i = 0; i < params->polyCount; ++i)
{
memcpy(&navDVerts[vbase*3], &params->detailVerts[(vb+nv)*3], sizeof(float)*3*(ndv-nv));
vbase += (unsigned short)(ndv-nv);
dtPolyDetail& dtl = navDMeshes[i];
const int vb = (int)params->detailMeshes[i*4+0];
const int ndv = (int)params->detailMeshes[i*4+1];
const int nv = navPolys[i].vertCount;
dtl.vertBase = (unsigned int)vbase;
dtl.vertCount = (unsigned char)(ndv-nv);
dtl.triBase = (unsigned int)params->detailMeshes[i*4+2];
dtl.triCount = (unsigned char)params->detailMeshes[i*4+3];
// Copy vertices except the first 'nv' verts which are equal to nav poly verts.
if (ndv-nv)
{
memcpy(&navDVerts[vbase*3], &params->detailVerts[(vb+nv)*3], sizeof(float)*3*(ndv-nv));
vbase += (unsigned short)(ndv-nv);
}
}
// Store triangles.
memcpy(navDTris, params->detailTris, sizeof(unsigned char)*4*params->detailTriCount);
}
else
{
// Create dummy detail mesh by triangulating polys.
int tbase = 0;
for (int i = 0; i < params->polyCount; ++i)
{
dtPolyDetail& dtl = navDMeshes[i];
const int nv = navPolys[i].vertCount;
dtl.vertBase = 0;
dtl.vertCount = 0;
dtl.triBase = (unsigned int)tbase;
dtl.triCount = (unsigned char)(nv-2);
// Triangulate polygon (local indices).
for (int j = 2; j < nv; ++j)
{
unsigned char* t = &navDTris[tbase*4];
t[0] = 0;
t[1] = (unsigned char)(j-1);
t[2] = (unsigned char)j;
// Bit for each edge that belongs to poly boundary.
t[3] = (1<<2);
if (j == 2) t[3] |= (1<<0);
if (j == nv-1) t[3] |= (1<<4);
tbase++;
}
}
}
// Store triangles.
memcpy(navDTris, params->detailTris, sizeof(unsigned char)*4*params->detailTriCount);
// Store and create BVtree.
// TODO: take detail mesh into account! use byte per bbox extent?
createBVTree(params->verts, params->vertCount, params->polys, params->polyCount,
nvp, params->cs, params->ch, params->polyCount*2, navBvtree);
if (params->buildBvTree)
{
createBVTree(params->verts, params->vertCount, params->polys, params->polyCount,
nvp, params->cs, params->ch, params->polyCount*2, navBvtree);
}
// Store Off-Mesh connections.
n = 0;
@@ -544,51 +632,14 @@ bool dtCreateNavMeshData(dtNavMeshCreateParams* params, unsigned char** outData,
return true;
}
inline void swapByte(unsigned char* a, unsigned char* b)
{
unsigned char tmp = *a;
*a = *b;
*b = tmp;
}
inline void swapEndian(unsigned short* v)
{
unsigned char* x = (unsigned char*)v;
swapByte(x+0, x+1);
}
inline void swapEndian(short* v)
{
unsigned char* x = (unsigned char*)v;
swapByte(x+0, x+1);
}
inline void swapEndian(unsigned int* v)
{
unsigned char* x = (unsigned char*)v;
swapByte(x+0, x+3); swapByte(x+1, x+2);
}
inline void swapEndian(int* v)
{
unsigned char* x = (unsigned char*)v;
swapByte(x+0, x+3); swapByte(x+1, x+2);
}
inline void swapEndian(float* v)
{
unsigned char* x = (unsigned char*)v;
swapByte(x+0, x+3); swapByte(x+1, x+2);
}
bool dtNavMeshHeaderSwapEndian(unsigned char* data, const int /*dataSize*/)
{
dtMeshHeader* header = (dtMeshHeader*)data;
int swappedMagic = DT_NAVMESH_MAGIC;
int swappedVersion = DT_NAVMESH_VERSION;
swapEndian(&swappedMagic);
swapEndian(&swappedVersion);
dtSwapEndian(&swappedMagic);
dtSwapEndian(&swappedVersion);
if ((header->magic != DT_NAVMESH_MAGIC || header->version != DT_NAVMESH_VERSION) &&
(header->magic != swappedMagic || header->version != swappedVersion))
@@ -596,36 +647,43 @@ bool dtNavMeshHeaderSwapEndian(unsigned char* data, const int /*dataSize*/)
return false;
}
swapEndian(&header->magic);
swapEndian(&header->version);
swapEndian(&header->x);
swapEndian(&header->y);
swapEndian(&header->userId);
swapEndian(&header->polyCount);
swapEndian(&header->vertCount);
swapEndian(&header->maxLinkCount);
swapEndian(&header->detailMeshCount);
swapEndian(&header->detailVertCount);
swapEndian(&header->detailTriCount);
swapEndian(&header->bvNodeCount);
swapEndian(&header->offMeshConCount);
swapEndian(&header->offMeshBase);
swapEndian(&header->walkableHeight);
swapEndian(&header->walkableRadius);
swapEndian(&header->walkableClimb);
swapEndian(&header->bmin[0]);
swapEndian(&header->bmin[1]);
swapEndian(&header->bmin[2]);
swapEndian(&header->bmax[0]);
swapEndian(&header->bmax[1]);
swapEndian(&header->bmax[2]);
swapEndian(&header->bvQuantFactor);
dtSwapEndian(&header->magic);
dtSwapEndian(&header->version);
dtSwapEndian(&header->x);
dtSwapEndian(&header->y);
dtSwapEndian(&header->layer);
dtSwapEndian(&header->userId);
dtSwapEndian(&header->polyCount);
dtSwapEndian(&header->vertCount);
dtSwapEndian(&header->maxLinkCount);
dtSwapEndian(&header->detailMeshCount);
dtSwapEndian(&header->detailVertCount);
dtSwapEndian(&header->detailTriCount);
dtSwapEndian(&header->bvNodeCount);
dtSwapEndian(&header->offMeshConCount);
dtSwapEndian(&header->offMeshBase);
dtSwapEndian(&header->walkableHeight);
dtSwapEndian(&header->walkableRadius);
dtSwapEndian(&header->walkableClimb);
dtSwapEndian(&header->bmin[0]);
dtSwapEndian(&header->bmin[1]);
dtSwapEndian(&header->bmin[2]);
dtSwapEndian(&header->bmax[0]);
dtSwapEndian(&header->bmax[1]);
dtSwapEndian(&header->bmax[2]);
dtSwapEndian(&header->bvQuantFactor);
// Freelist index and pointers are updated when tile is added, no need to swap.
return true;
}
/// @par
///
/// @warning This function assumes that the header is in the correct endianess already.
/// Call #dtNavMeshHeaderSwapEndian() first on the data if the data is expected to be in wrong endianess
/// to start with. Call #dtNavMeshHeaderSwapEndian() after the data has been swapped if converting from
/// native to foreign endianess.
bool dtNavMeshDataSwapEndian(unsigned char* data, const int /*dataSize*/)
{
// Make sure the data is in right format.
@@ -659,7 +717,7 @@ bool dtNavMeshDataSwapEndian(unsigned char* data, const int /*dataSize*/)
// Vertices
for (int i = 0; i < header->vertCount*3; ++i)
{
swapEndian(&verts[i]);
dtSwapEndian(&verts[i]);
}
// Polys
@@ -669,10 +727,10 @@ bool dtNavMeshDataSwapEndian(unsigned char* data, const int /*dataSize*/)
// poly->firstLink is update when tile is added, no need to swap.
for (int j = 0; j < DT_VERTS_PER_POLYGON; ++j)
{
swapEndian(&p->verts[j]);
swapEndian(&p->neis[j]);
dtSwapEndian(&p->verts[j]);
dtSwapEndian(&p->neis[j]);
}
swapEndian(&p->flags);
dtSwapEndian(&p->flags);
}
// Links are rebuild when tile is added, no need to swap.
@@ -681,14 +739,14 @@ bool dtNavMeshDataSwapEndian(unsigned char* data, const int /*dataSize*/)
for (int i = 0; i < header->detailMeshCount; ++i)
{
dtPolyDetail* pd = &detailMeshes[i];
swapEndian(&pd->vertBase);
swapEndian(&pd->triBase);
dtSwapEndian(&pd->vertBase);
dtSwapEndian(&pd->triBase);
}
// Detail verts
for (int i = 0; i < header->detailVertCount*3; ++i)
{
swapEndian(&detailVerts[i]);
dtSwapEndian(&detailVerts[i]);
}
// BV-tree
@@ -697,10 +755,10 @@ bool dtNavMeshDataSwapEndian(unsigned char* data, const int /*dataSize*/)
dtBVNode* node = &bvTree[i];
for (int j = 0; j < 3; ++j)
{
swapEndian(&node->bmin[j]);
swapEndian(&node->bmax[j]);
dtSwapEndian(&node->bmin[j]);
dtSwapEndian(&node->bmax[j]);
}
swapEndian(&node->i);
dtSwapEndian(&node->i);
}
// Off-mesh Connections.
@@ -708,9 +766,9 @@ bool dtNavMeshDataSwapEndian(unsigned char* data, const int /*dataSize*/)
{
dtOffMeshConnection* con = &offMeshCons[i];
for (int j = 0; j < 6; ++j)
swapEndian(&con->pos[j]);
swapEndian(&con->rad);
swapEndian(&con->poly);
dtSwapEndian(&con->pos[j]);
dtSwapEndian(&con->rad);
dtSwapEndian(&con->poly);
}
return true;
@@ -21,57 +21,128 @@
#include "DetourAlloc.h"
// The units of the parameters are specified in parenthesis as follows:
// (vx) voxels, (wu) world units
/// Represents the source data used to build an navigation mesh tile.
/// @ingroup detour
struct dtNavMeshCreateParams
{
// Navmesh vertices.
const unsigned short* verts; // Array of vertices, each vertex has 3 components. (vx).
int vertCount; // Vertex count
// Navmesh polygons
const unsigned short* polys; // Array of polygons, uses same format as rcPolyMesh.
const unsigned short* polyFlags; // Array of flags per polygon.
const unsigned char* polyAreas; // Array of area ids per polygon.
int polyCount; // Number of polygons
int nvp; // Number of verts per polygon.
// Navmesh Detail
const unsigned int* detailMeshes; // Detail meshes, uses same format as rcPolyMeshDetail.
const float* detailVerts; // Detail mesh vertices, uses same format as rcPolyMeshDetail (wu).
int detailVertsCount; // Total number of detail vertices
const unsigned char* detailTris; // Array of detail tris per detail mesh.
int detailTriCount; // Total number of detail triangles.
// Off-Mesh Connections.
const float* offMeshConVerts; // Off-mesh connection vertices (wu).
const float* offMeshConRad; // Off-mesh connection radii (wu).
const unsigned short* offMeshConFlags; // Off-mesh connection flags.
const unsigned char* offMeshConAreas; // Off-mesh connection area ids.
const unsigned char* offMeshConDir; // Off-mesh connection direction flags (1 = bidir, 0 = oneway).
const unsigned int* offMeshConUserID; // Off-mesh connection user id (optional).
int offMeshConCount; // Number of off-mesh connections
// Tile location
unsigned int userId; // User ID bound to the tile.
int tileX, tileY; // Tile location (tile coords).
float bmin[3], bmax[3]; // Tile bounds (wu).
// Settings
float walkableHeight; // Agent height (wu).
float walkableRadius; // Agent radius (wu).
float walkableClimb; // Agent max climb (wu).
float cs; // Cell size (xz) (wu).
float ch; // Cell height (y) (wu).
int tileSize; // Tile size (width & height) (vx).
/// @name Polygon Mesh Attributes
/// Used to create the base navigation graph.
/// See #rcPolyMesh for details related to these attributes.
/// @{
const unsigned short* verts; ///< The polygon mesh vertices. [(x, y, z) * #vertCount] [Unit: vx]
int vertCount; ///< The number vertices in the polygon mesh. [Limit: >= 3]
const unsigned short* polys; ///< The polygon data. [Size: #polyCount * 2 * #nvp]
const unsigned short* polyFlags; ///< The user defined flags assigned to each polygon. [Size: #polyCount]
const unsigned char* polyAreas; ///< The user defined area ids assigned to each polygon. [Size: #polyCount]
int polyCount; ///< Number of polygons in the mesh. [Limit: >= 1]
int nvp; ///< Number maximum number of vertices per polygon. [Limit: >= 3]
/// @}
/// @name Height Detail Attributes (Optional)
/// See #rcPolyMeshDetail for details related to these attributes.
/// @{
const unsigned int* detailMeshes; ///< The height detail sub-mesh data. [Size: 4 * #polyCount]
const float* detailVerts; ///< The detail mesh vertices. [Size: 3 * #detailVertsCount] [Unit: wu]
int detailVertsCount; ///< The number of vertices in the detail mesh.
const unsigned char* detailTris; ///< The detail mesh triangles. [Size: 4 * #detailTriCount]
int detailTriCount; ///< The number of triangles in the detail mesh.
/// @}
/// @name Off-Mesh Connections Attributes (Optional)
/// Used to define a custom point-to-point edge within the navigation graph, an
/// off-mesh connection is a user defined traversable connection made up to two vertices,
/// at least one of which resides within a navigation mesh polygon.
/// @{
/// Off-mesh connection vertices. [(ax, ay, az, bx, by, bz) * #offMeshConCount] [Unit: wu]
const float* offMeshConVerts;
/// Off-mesh connection radii. [Size: #offMeshConCount] [Unit: wu]
const float* offMeshConRad;
/// User defined flags assigned to the off-mesh connections. [Size: #offMeshConCount]
const unsigned short* offMeshConFlags;
/// User defined area ids assigned to the off-mesh connections. [Size: #offMeshConCount]
const unsigned char* offMeshConAreas;
/// The permitted travel direction of the off-mesh connections. [Size: #offMeshConCount]
///
/// 0 = Travel only from endpoint A to endpoint B.<br/>
/// #DT_OFFMESH_CON_BIDIR = Bidirectional travel.
const unsigned char* offMeshConDir;
/// The user defined ids of the off-mesh connection. [Size: #offMeshConCount]
const unsigned int* offMeshConUserID;
/// The number of off-mesh connections. [Limit: >= 0]
int offMeshConCount;
/// @}
/// @name Tile Attributes
/// @note The tile grid/layer data can be left at zero if the destination is a single tile mesh.
/// @{
unsigned int userId; ///< The user defined id of the tile.
int tileX; ///< The tile's x-grid location within the multi-tile destination mesh. (Along the x-axis.)
int tileY; ///< The tile's y-grid location within the multi-tile desitation mesh. (Along the z-axis.)
int tileLayer; ///< The tile's layer within the layered destination mesh. [Limit: >= 0] (Along the y-axis.)
float bmin[3]; ///< The minimum bounds of the tile. [(x, y, z)] [Unit: wu]
float bmax[3]; ///< The maximum bounds of the tile. [(x, y, z)] [Unit: wu]
/// @}
/// @name General Configuration Attributes
/// @{
float walkableHeight; ///< The agent height. [Unit: wu]
float walkableRadius; ///< The agent radius. [Unit: wu]
float walkableClimb; ///< The agent maximum traversable ledge. (Up/Down) [Unit: wu]
float cs; ///< The xz-plane cell size of the polygon mesh. [Limit: > 0] [Unit: wu]
float ch; ///< The y-axis cell height of the polygon mesh. [Limit: > 0] [Unit: wu]
/// True if a bounding volume tree should be built for the tile.
/// @note The BVTree is not normally needed for layered navigation meshes.
bool buildBvTree;
/// @}
};
// Build navmesh data from given input data.
/// Builds navigation mesh tile data from the provided tile creation data.
/// @ingroup detour
/// @param[in] params Tile creation data.
/// @param[out] outData The resulting tile data.
/// @param[out] outDataSize The size of the tile data array.
/// @return True if the tile data was successfully created.
bool dtCreateNavMeshData(dtNavMeshCreateParams* params, unsigned char** outData, int* outDataSize);
// Swaps endianess of navmesh header.
/// Swaps the endianess of the tile data's header (#dtMeshHeader).
/// @param[in,out] data The tile data array.
/// @param[in] dataSize The size of the data array.
bool dtNavMeshHeaderSwapEndian(unsigned char* data, const int dataSize);
// Swaps endianess of the navmesh data. This function assumes that the header is in correct
// endianess already. Call dtNavMeshHeaderSwapEndian() first on the data if the data is
// assumed to be in wrong endianess to start with. If converting from native endianess to foreign,
// call dtNavMeshHeaderSwapEndian() after the data has been swapped.
/// Swaps endianess of the tile data.
/// @param[in,out] data The tile data array.
/// @param[in] dataSize The size of the data array.
bool dtNavMeshDataSwapEndian(unsigned char* data, const int dataSize);
#endif // DETOURNAVMESHBUILDER_H
// This section contains detailed documentation for members that don't have
// a source file. It reduces clutter in the main section of the header.
/**
@struct dtNavMeshCreateParams
@par
This structure is used to marshal data between the Recast mesh generation pipeline and Detour navigation components.
See the rcPolyMesh and rcPolyMeshDetail documentation for detailed information related to mesh structure.
Units are usually in voxels (vx) or world units (wu). The units for voxels, grid size, and cell size
are all based on the values of #cs and #ch.
The standard navigation mesh build process is to create tile data using dtCreateNavMeshData, then add the tile
to a navigation mesh using either the dtNavMesh single tile <tt>init()</tt> function or the dtNavMesh::addTile()
function.
@see dtCreateNavMeshData
*/
File diff suppressed because it is too large. Load diff
+336 -255
View File
@@ -20,39 +20,31 @@
#define DETOURNAVMESHQUERY_H
#include "DetourNavMesh.h"
#include "DetourStatus.h"
// Define DT_VIRTUAL_QUERYFILTER if you wish to derive a custom filter from dtQueryFilter.
// On certain platforms indirect or virtual function call is expensive. The default
// setting is to use non-virtual functions, the actualy implementations of the functions
// setting is to use non-virtual functions, the actual implementations of the functions
// are declared as inline for maximum speed.
//#define DT_VIRTUAL_QUERYFILTER 1
// Class for polygon filtering and cost calculation during query operations.
// - It is possible to derive a custom query filter from dtQueryFilter by overriding
// the virtual functions passFilter() and getCost().
// - Both functions should be as fast as possible. Use cached local copy of data
// instead of accessing your own objects where possible.
// - You do not need to adhere to the flags and cost logic provided by the default
// implementation.
// - In order for the A* to work properly, the cost should be proportional to
// the travel distance. Using cost modifier less than 1.0 is likely to lead
// to problems during pathfinding.
/// Defines polygon filtering and traversal costs for navigation mesh query operations.
/// @ingroup detour
class dtQueryFilter
{
float m_areaCost[DT_MAX_AREAS]; // Array storing cost per area type, used by default implementation.
unsigned short m_includeFlags; // Include poly flags, used by default implementation.
unsigned short m_excludeFlags; // Exclude poly flags, used by default implementation.
float m_areaCost[DT_MAX_AREAS]; ///< Cost per area type. (Used by default implementation.)
unsigned short m_includeFlags; ///< Flags for polygons that can be visited. (Used by default implementation.)
unsigned short m_excludeFlags; ///< Flags for polygons that should not be visted. (Used by default implementation.)
public:
dtQueryFilter();
// Returns true if the polygon is can visited.
// Params:
// ref - (in) reference to the polygon test.
// tile - (in) pointer to the tile of the polygon test.
// poly - (in) pointer to the polygon test.
/// Returns true if the polygon can be visited. (I.e. Is traversable.)
/// @param[in] ref The reference id of the polygon test.
/// @param[in] tile The tile containing the polygon.
/// @param[in] poly The polygon to test.
#ifdef DT_VIRTUAL_QUERYFILTER
virtual bool passFilter(const dtPolyRef ref,
const dtMeshTile* tile,
@@ -63,16 +55,19 @@ public:
const dtPoly* poly) const;
#endif
// Returns cost to travel from 'pa' to 'pb'.'
// The segment is fully contained inside 'cur'.
// 'pa' lies on the edge between 'prev' and 'cur',
// 'pb' lies on the edge between 'cur' and 'next'.
// Params:
// pa - (in) segment start position.
// pb - (in) segment end position.
// prevRef, prevTile, prevPoly - (in) data describing the previous polygon, can be null.
// curRef, curTile, curPoly - (in) data describing the current polygon.
// nextRef, nextTile, nextPoly - (in) data describing the next polygon, can be null.
/// Returns cost to move from the beginning to the end of a line segment
/// that is fully contained within a polygon.
/// @param[in] pa The start position on the edge of the previous and current polygon. [(x, y, z)]
/// @param[in] pb The end position on the edge of the current and next polygon. [(x, y, z)]
/// @param[in] prevRef The reference id of the previous polygon. [opt]
/// @param[in] prevTile The tile containing the previous polygon. [opt]
/// @param[in] prevPoly The previous polygon. [opt]
/// @param[in] curRef The reference id of the current polygon.
/// @param[in] curTile The tile containing the current polygon.
/// @param[in] curPoly The current polygon.
/// @param[in] nextRef The refernece id of the next polygon. [opt]
/// @param[in] nextTile The tile containing the next polygon. [opt]
/// @param[in] nextPoly The next polygon. [opt]
#ifdef DT_VIRTUAL_QUERYFILTER
virtual float getCost(const float* pa, const float* pb,
const dtPolyRef prevRef, const dtMeshTile* prevTile, const dtPoly* prevPoly,
@@ -84,305 +79,385 @@ public:
const dtPolyRef curRef, const dtMeshTile* curTile, const dtPoly* curPoly,
const dtPolyRef nextRef, const dtMeshTile* nextTile, const dtPoly* nextPoly) const;
#endif
// Getters and setters for the default implementation data.
/// @name Getters and setters for the default implementation data.
///@{
/// Returns the traversal cost of the area.
/// @param[in] i The id of the area.
/// @returns The traversal cost of the area.
inline float getAreaCost(const int i) const { return m_areaCost[i]; }
/// Sets the traversal cost of the area.
/// @param[in] i The id of the area.
/// @param[in] cost The new cost of traversing the area.
inline void setAreaCost(const int i, const float cost) { m_areaCost[i] = cost; }
/// Returns the include flags for the filter.
/// Any polygons that include one or more of these flags will be
/// included in the operation.
inline unsigned short getIncludeFlags() const { return m_includeFlags; }
/// Sets the include flags for the filter.
/// @param[in] flags The new flags.
inline void setIncludeFlags(const unsigned short flags) { m_includeFlags = flags; }
/// Returns the exclude flags for the filter.
/// Any polygons that include one ore more of these flags will be
/// excluded from the operation.
inline unsigned short getExcludeFlags() const { return m_excludeFlags; }
/// Sets the exclude flags for the filter.
/// @param[in] flags The new flags.
inline void setExcludeFlags(const unsigned short flags) { m_excludeFlags = flags; }
///@}
};
/// Provides the ability to perform pathfinding related queries against
/// a navigation mesh.
/// @ingroup detour
class dtNavMeshQuery
{
public:
dtNavMeshQuery();
~dtNavMeshQuery();
// Initializes the nav mesh query.
// Params:
// nav - (in) pointer to navigation mesh data.
// maxNodes - (in) Maximum number of search nodes to use (max 65536).
// Returns: True if succeed, else false.
/// Initializes the query object.
/// @param[in] nav Pointer to the dtNavMesh object to use for all queries.
/// @param[in] maxNodes Maximum number of search nodes. [Limits: 0 < value <= 65536]
/// @returns The status flags for the query.
dtStatus init(const dtNavMesh* nav, const int maxNodes);
// Finds the nearest navigation polygon around the center location.
// Params:
// center[3] - (in) The center of the search box.
// extents[3] - (in) The extents of the search box.
// filter - (in) path polygon filter.
// nearestRef - (out) Reference to the nearest polygon.
// nearestPt[3] - (out, opt) The nearest point on found polygon, null if not needed.
// Returns: Reference identifier for the polygon, or 0 if no polygons found.
dtStatus findNearestPoly(const float* center, const float* extents,
const dtQueryFilter* filter,
dtPolyRef* nearestRef, float* nearestPt) const;
// Returns polygons which overlap the query box.
// Params:
// center[3] - (in) the center of the search box.
// extents[3] - (in) the extents of the search box.
// filter - (in) path polygon filter.
// polys - (out) array holding the search result.
// polyCount - (out) Number of polygons in search result array.
// maxPolys - (in) The max number of polygons the polys array can hold.
dtStatus queryPolygons(const float* center, const float* extents,
const dtQueryFilter* filter,
dtPolyRef* polys, int* polyCount, const int maxPolys) const;
// Finds path from start polygon to end polygon.
// If target polygon canno be reached through the navigation graph,
// the last node on the array is nearest node to the end polygon.
// Start end end positions are needed to calculate more accurate
// traversal cost at start end end polygons.
// Params:
// startRef - (in) ref to path start polygon.
// endRef - (in) ref to path end polygon.
// startPos[3] - (in) Path start location.
// endPos[3] - (in) Path end location.
// filter - (in) path polygon filter.
// path - (out) array holding the search result.
// pathCount - (out) Number of polygons in search result array.
// maxPath - (in) The max number of polygons the path array can hold. Must be at least 1.
/// @name Standard Pathfinding Functions
// /@{
/// Finds a path from the start polygon to the end polygon.
/// @param[in] startRef The refrence id of the start polygon.
/// @param[in] endRef The reference id of the end polygon.
/// @param[in] startPos A position within the start polygon. [(x, y, z)]
/// @param[in] endPos A position within the end polygon. [(x, y, z)]
/// @param[in] filter The polygon filter to apply to the query.
/// @param[out] path An ordered list of polygon references representing the path. (Start to end.)
/// [(polyRef) * @p pathCount]
/// @param[out] pathCount The number of polygons returned in the @p path array.
/// @param[in] maxPath The maximum number of polygons the @p path array can hold. [Limit: >= 1]
dtStatus findPath(dtPolyRef startRef, dtPolyRef endRef,
const float* startPos, const float* endPos,
const dtQueryFilter* filter,
dtPolyRef* path, int* pathCount, const int maxPath) const;
// Intializes sliced path find query.
// Note 1: calling any other dtNavMeshQuery method before calling findPathEnd()
// may results in corrupted data!
// Note 2: The pointer to filter is store, and used in subsequent
// calls to updateSlicedFindPath().
// Params:
// startRef - (in) ref to path start polygon.
// endRef - (in) ref to path end polygon.
// startPos[3] - (in) Path start location.
// endPos[3] - (in) Path end location.
// filter - (in) path polygon filter.
/// Finds the straight path from the start to the end position within the polygon corridor.
/// @param[in] startPos Path start position. [(x, y, z)]
/// @param[in] endPos Path end position. [(x, y, z)]
/// @param[in] path An array of polygon references that represent the path corridor.
/// @param[in] pathSize The number of polygons in the @p path array.
/// @param[out] straightPath Points describing the straight path. [(x, y, z) * @p straightPathCount].
/// @param[out] straightPathFlags Flags describing each point. (See: #dtStraightPathFlags) [opt]
/// @param[out] straightPathRefs The reference id of the polygon that is being entered at each point. [opt]
/// @param[out] straightPathCount The number of points in the straight path.
/// @param[in] maxStraightPath The maximum number of points the straight path arrays can hold. [Limit: > 0]
/// @param[in] options Query options. (see: #dtStraightPathOptions)
/// @returns The status flags for the query.
dtStatus findStraightPath(const float* startPos, const float* endPos,
const dtPolyRef* path, const int pathSize,
float* straightPath, unsigned char* straightPathFlags, dtPolyRef* straightPathRefs,
int* straightPathCount, const int maxStraightPath, const int options = 0) const;
///@}
/// @name Sliced Pathfinding Functions
/// Common use case:
/// -# Call initSlicedFindPath() to initialize the sliced path query.
/// -# Call updateSlicedFindPath() until it returns complete.
/// -# Call finalizeSlicedFindPath() to get the path.
///@{
/// Intializes a sliced path query.
/// @param[in] startRef The refrence id of the start polygon.
/// @param[in] endRef The reference id of the end polygon.
/// @param[in] startPos A position within the start polygon. [(x, y, z)]
/// @param[in] endPos A position within the end polygon. [(x, y, z)]
/// @param[in] filter The polygon filter to apply to the query.
/// @returns The status flags for the query.
dtStatus initSlicedFindPath(dtPolyRef startRef, dtPolyRef endRef,
const float* startPos, const float* endPos,
const dtQueryFilter* filter);
// Updates sliced path find query.
// Params:
// maxIter - (in) max number of iterations to update.
// Returns: Path query state.
dtStatus updateSlicedFindPath(const int maxIter);
/// Updates an in-progress sliced path query.
/// @param[in] maxIter The maximum number of iterations to perform.
/// @param[out] doneIters The actual number of iterations completed. [opt]
/// @returns The status flags for the query.
dtStatus updateSlicedFindPath(const int maxIter, int* doneIters);
// Finalizes sliced path find query and returns found path.
// path - (out) array holding the search result.
// pathCount - (out) Number of polygons in search result array.
// maxPath - (in) The max number of polygons the path array can hold.
/// Finalizes and returns the results of a sliced path query.
/// @param[out] path An ordered list of polygon references representing the path. (Start to end.)
/// [(polyRef) * @p pathCount]
/// @param[out] pathCount The number of polygons returned in the @p path array.
/// @param[in] maxPath The max number of polygons the path array can hold. [Limit: >= 1]
/// @returns The status flags for the query.
dtStatus finalizeSlicedFindPath(dtPolyRef* path, int* pathCount, const int maxPath);
// Finalizes partial sliced path find query and returns path to the furthest
// polygon on the existing path that was visited during the search.
// existing - (out) Array of polygons in the existing path.
// existingSize - (out) Number of polygons in existing path array.
// path - (out) array holding the search result.
// pathCount - (out) Number of polygons in search result array.
// maxPath - (in) The max number of polygons the path array can hold.
/// Finalizes and returns the results of an incomplete sliced path query, returning the path to the furthest
/// polygon on the existing path that was visited during the search.
/// @param[out] existing An array of polygon references for the existing path.
/// @param[out] existingSize The number of polygon in the @p existing array.
/// @param[out] path An ordered list of polygon references representing the path. (Start to end.)
/// [(polyRef) * @p pathCount]
/// @param[out] pathCount The number of polygons returned in the @p path array.
/// @param[in] maxPath The max number of polygons the @p path array can hold. [Limit: >= 1]
/// @returns The status flags for the query.
dtStatus finalizeSlicedFindPathPartial(const dtPolyRef* existing, const int existingSize,
dtPolyRef* path, int* pathCount, const int maxPath);
// Finds a straight path from start to end locations within the corridor
// described by the path polygons.
// Start and end locations will be clamped on the corridor.
// The returned polygon references are point to polygon which was entered when
// a path point was added. For the end point, zero will be returned. This allows
// to match for example off-mesh link points to their representative polygons.
// Params:
// startPos[3] - (in) Path start location.
// endPo[3] - (in) Path end location.
// path - (in) Array of connected polygons describing the corridor.
// pathSize - (in) Number of polygons in path array.
// straightPath - (out) Points describing the straight path.
// straightPathFlags - (out, opt) Flags describing each point type, see dtStraightPathFlags.
// straightPathRefs - (out, opt) References to polygons at point locations.
// straightPathCount - (out) Number of points in the path.
// maxStraightPath - (in) The max number of points the straight path array can hold. Must be at least 1.
dtStatus findStraightPath(const float* startPos, const float* endPos,
const dtPolyRef* path, const int pathSize,
float* straightPath, unsigned char* straightPathFlags, dtPolyRef* straightPathRefs,
int* straightPathCount, const int maxStraightPath) const;
// Moves from startPos to endPos constrained to the navmesh.
// If the endPos is reachable, the resultPos will be endPos,
// or else the resultPos will be the nearest point in navmesh.
// Note: The resulting point is not projected to the ground, use getPolyHeight() to get height.
// Note: The algorithm is optimized for small delta movement and small number of polygons.
// Params:
// startRef - (in) ref to the polygon where startPos lies.
// startPos[3] - (in) start position of the mover.
// endPos[3] - (in) desired end position of the mover.
// filter - (in) path polygon filter.
// resultPos[3] - (out) new position of the mover.
// visited - (out) array of visited polygons.
// visitedCount - (out) Number of entries in the visited array.
// maxVisitedSize - (in) max number of polygons in the visited array.
dtStatus moveAlongSurface(dtPolyRef startRef, const float* startPos, const float* endPos,
const dtQueryFilter* filter,
float* resultPos, dtPolyRef* visited, int* visitedCount, const int maxVisitedSize) const;
// Casts 'walkability' ray along the navmesh surface from startPos towards the endPos.
// Params:
// startRef - (in) ref to the polygon where the start lies.
// startPos[3] - (in) start position of the query.
// endPos[3] - (in) end position of the query.
// t - (out) hit parameter along the segment, FLT_MAX if no hit.
// hitNormal[3] - (out) normal of the nearest hit.
// filter - (in) path polygon filter.
// path - (out,opt) visited path polygons.
// pathCount - (out,opt) Number of polygons visited.
// maxPath - (in) max number of polygons in the path array.
dtStatus raycast(dtPolyRef startRef, const float* startPos, const float* endPos,
const dtQueryFilter* filter,
float* t, float* hitNormal, dtPolyRef* path, int* pathCount, const int maxPath) const;
// Returns distance to nearest wall from the specified location.
// Params:
// startRef - (in) ref to the polygon where the center lies.
// centerPos[3] - (in) center if the query circle.
// maxRadius - (in) max search radius.
// filter - (in) path polygon filter.
// hitDist - (out) distance to nearest wall from the test location.
// hitPos[3] - (out) location of the nearest hit.
// hitNormal[3] - (out) normal of the nearest hit.
dtStatus findDistanceToWall(dtPolyRef startRef, const float* centerPos, const float maxRadius,
const dtQueryFilter* filter,
float* hitDist, float* hitPos, float* hitNormal) const;
// Finds polygons found along the navigation graph which touch the specified circle.
// Params:
// startRef - (in) ref to the polygon where the search starts.
// centerPos[3] - (in) center if the query circle.
// radius - (in) radius of the query circle.
// filter - (in) path polygon filter.
// resultRef - (out, opt) refs to the polygons touched by the circle.
// resultParent - (out, opt) parent of each result polygon.
// resultCost - (out, opt) search cost at each result polygon.
// resultCount - (out, opt) Number of results.
// maxResult - (int) maximum capacity of search results.
///@}
/// @name Dijkstra Search Functions
/// @{
/// Finds the polygons along the navigation graph that touch the specified circle.
/// @param[in] startRef The reference id of the polygon where the search starts.
/// @param[in] centerPos The center of the search circle. [(x, y, z)]
/// @param[in] radius The radius of the search circle.
/// @param[in] filter The polygon filter to apply to the query.
/// @param[out] resultRef The reference ids of the polygons touched by the circle. [opt]
/// @param[out] resultParent The reference ids of the parent polygons for each result.
/// Zero if a result polygon has no parent. [opt]
/// @param[out] resultCost The search cost from @p centerPos to the polygon. [opt]
/// @param[out] resultCount The number of polygons found. [opt]
/// @param[in] maxResult The maximum number of polygons the result arrays can hold.
/// @returns The status flags for the query.
dtStatus findPolysAroundCircle(dtPolyRef startRef, const float* centerPos, const float radius,
const dtQueryFilter* filter,
dtPolyRef* resultRef, dtPolyRef* resultParent, float* resultCost,
int* resultCount, const int maxResult) const;
// Finds polygons found along the navigation graph which touch the convex polygon shape.
// Params:
// startRef - (in) ref to the polygon where the search starts.
// verts[3*n] - (in) vertices describing convex polygon shape (CCW).
// nverts - (in) number of vertices in the polygon.
// filter - (in) path polygon filter.
// resultRef - (out, opt) refs to the polygons touched by the circle.
// resultParent - (out, opt) parent of each result polygon.
// resultCost - (out, opt) search cost at each result polygon.
// resultCount - (out) number of results.
// maxResult - (int) maximum capacity of search results.
/// Finds the polygons along the naviation graph that touch the specified convex polygon.
/// @param[in] startRef The reference id of the polygon where the search starts.
/// @param[in] verts The vertices describing the convex polygon. (CCW)
/// [(x, y, z) * @p nverts]
/// @param[in] nverts The number of vertices in the polygon.
/// @param[in] filter The polygon filter to apply to the query.
/// @param[out] resultRef The reference ids of the polygons touched by the search polygon. [opt]
/// @param[out] resultParent The reference ids of the parent polygons for each result. Zero if a
/// result polygon has no parent. [opt]
/// @param[out] resultCost The search cost from the centroid point to the polygon. [opt]
/// @param[out] resultCount The number of polygons found.
/// @param[in] maxResult The maximum number of polygons the result arrays can hold.
/// @returns The status flags for the query.
dtStatus findPolysAroundShape(dtPolyRef startRef, const float* verts, const int nverts,
const dtQueryFilter* filter,
dtPolyRef* resultRef, dtPolyRef* resultParent, float* resultCost,
int* resultCount, const int maxResult) const;
// Finds non-overlapping local neighbourhood around center location.
// Note: The algorithm is optimized for small query radius and small number of polygons.
// Params:
// startRef - (in) ref to the polygon where the search starts.
// centerPos[3] - (in) center if the query circle.
// radius - (in) radius of the query circle.
// filter - (in) path polygon filter.
// resultRef - (out) refs to the polygons touched by the circle.
// resultParent - (out, opt) parent of each result polygon.
// resultCount - (out) number of results.
// maxResult - (int) maximum capacity of search results.
/// @}
/// @name Local Query Functions
///@{
/// Finds the polygon nearest to the specified center point.
/// @param[in] center The center of the search box. [(x, y, z)]
/// @param[in] extents The search distance along each axis. [(x, y, z)]
/// @param[in] filter The polygon filter to apply to the query.
/// @param[out] nearestRef The reference id of the nearest polygon.
/// @param[out] nearestPt The nearest point on the polygon. [opt] [(x, y, z)]
/// @returns The status flags for the query.
dtStatus findNearestPoly(const float* center, const float* extents,
const dtQueryFilter* filter,
dtPolyRef* nearestRef, float* nearestPt) const;
/// Finds polygons that overlap the search box.
/// @param[in] center The center of the search box. [(x, y, z)]
/// @param[in] extents The search distance along each axis. [(x, y, z)]
/// @param[in] filter The polygon filter to apply to the query.
/// @param[out] polys The reference ids of the polygons that overlap the query box.
/// @param[out] polyCount The number of polygons in the search result.
/// @param[in] maxPolys The maximum number of polygons the search result can hold.
/// @returns The status flags for the query.
dtStatus queryPolygons(const float* center, const float* extents,
const dtQueryFilter* filter,
dtPolyRef* polys, int* polyCount, const int maxPolys) const;
/// Finds the non-overlapping navigation polygons in the local neighbourhood around the center position.
/// @param[in] startRef The reference id of the polygon where the search starts.
/// @param[in] centerPos The center of the query circle. [(x, y, z)]
/// @param[in] radius The radius of the query circle.
/// @param[in] filter The polygon filter to apply to the query.
/// @param[out] resultRef The reference ids of the polygons touched by the circle.
/// @param[out] resultParent The reference ids of the parent polygons for each result.
/// Zero if a result polygon has no parent. [opt]
/// @param[out] resultCount The number of polygons found.
/// @param[in] maxResult The maximum number of polygons the result arrays can hold.
/// @returns The status flags for the query.
dtStatus findLocalNeighbourhood(dtPolyRef startRef, const float* centerPos, const float radius,
const dtQueryFilter* filter,
dtPolyRef* resultRef, dtPolyRef* resultParent,
int* resultCount, const int maxResult) const;
/// Moves from the start to the end position constrained to the navigation mesh.
/// @param[in] startRef The reference id of the start polygon.
/// @param[in] startPos A position of the mover within the start polygon. [(x, y, x)]
/// @param[in] endPos The desired end position of the mover. [(x, y, z)]
/// @param[in] filter The polygon filter to apply to the query.
/// @param[out] resultPos The result position of the mover. [(x, y, z)]
/// @param[out] visited The reference ids of the polygons visited during the move.
/// @param[out] visitedCount The number of polygons visited during the move.
/// @param[in] maxVisitedSize The maximum number of polygons the @p visited array can hold.
/// @returns The status flags for the query.
dtStatus moveAlongSurface(dtPolyRef startRef, const float* startPos, const float* endPos,
const dtQueryFilter* filter,
float* resultPos, dtPolyRef* visited, int* visitedCount, const int maxVisitedSize) const;
// Returns wall segments of specified polygon.
// Params:
// ref - (in) ref to the polygon.
// filter - (in) path polygon filter.
// segments[6*maxSegments] - (out) wall segments (2 endpoints per segment).
// segmentCount - (out) number of wall segments.
// maxSegments - (in) max number of segments that can be stored in 'segments'.
/// Casts a 'walkability' ray along the surface of the navigation mesh from
/// the start position toward the end position.
/// @param[in] startRef The reference id of the start polygon.
/// @param[in] startPos A position within the start polygon representing
/// the start of the ray. [(x, y, z)]
/// @param[in] endPos The position to cast the ray toward. [(x, y, z)]
/// @param[out] t The hit parameter. (FLT_MAX if no wall hit.)
/// @param[out] hitNormal The normal of the nearest wall hit. [(x, y, z)]
/// @param[in] filter The polygon filter to apply to the query.
/// @param[out] path The reference ids of the visited polygons. [opt]
/// @param[out] pathCount The number of visited polygons. [opt]
/// @param[in] maxPath The maximum number of polygons the @p path array can hold.
/// @returns The status flags for the query.
dtStatus raycast(dtPolyRef startRef, const float* startPos, const float* endPos,
const dtQueryFilter* filter,
float* t, float* hitNormal, dtPolyRef* path, int* pathCount, const int maxPath) const;
/// Finds the distance from the specified position to the nearest polygon wall.
/// @param[in] startRef The reference id of the polygon containing @p centerPos.
/// @param[in] centerPos The center of the search circle. [(x, y, z)]
/// @param[in] maxRadius The radius of the search circle.
/// @param[in] filter The polygon filter to apply to the query.
/// @param[out] hitDist The distance to the nearest wall from @p centerPos.
/// @param[out] hitPos The nearest position on the wall that was hit. [(x, y, z)]
/// @param[out] hitNormal The normalized ray formed from the wall point to the
/// source point. [(x, y, z)]
/// @returns The status flags for the query.
dtStatus findDistanceToWall(dtPolyRef startRef, const float* centerPos, const float maxRadius,
const dtQueryFilter* filter,
float* hitDist, float* hitPos, float* hitNormal) const;
/// Returns the segments for the specified polygon, optionally including portals.
/// @param[in] ref The reference id of the polygon.
/// @param[in] filter The polygon filter to apply to the query.
/// @param[out] segmentVerts The segments. [(ax, ay, az, bx, by, bz) * segmentCount]
/// @param[out] segmentRefs The reference ids of each segment's neighbor polygon.
/// Or zero if the segment is a wall. [opt] [(parentRef) * @p segmentCount]
/// @param[out] segmentCount The number of segments returned.
/// @param[in] maxSegments The maximum number of segments the result arrays can hold.
/// @returns The status flags for the query.
dtStatus getPolyWallSegments(dtPolyRef ref, const dtQueryFilter* filter,
float* segments, int* segmentCount, const int maxSegments) const;
float* segmentVerts, dtPolyRef* segmentRefs, int* segmentCount,
const int maxSegments) const;
/// Returns random location on navmesh.
/// Polygons are chosen weighted by area. The search runs in linear related to number of polygon.
/// @param[in] filter The polygon filter to apply to the query.
/// @param[in] frand Function returning a random number [0..1).
/// @param[out] randomRef The reference id of the random location.
/// @param[out] randomPt The random location.
/// @returns The status flags for the query.
dtStatus findRandomPoint(const dtQueryFilter* filter, float (*frand)(),
dtPolyRef* randomRef, float* randomPt) const;
/// Returns random location on navmesh within the reach of specified location.
/// Polygons are chosen weighted by area. The search runs in linear related to number of polygon.
/// The location is not exactly constrained by the circle, but it limits the visited polygons.
/// @param[in] startRef The reference id of the polygon where the search starts.
/// @param[in] centerPos The center of the search circle. [(x, y, z)]
/// @param[in] filter The polygon filter to apply to the query.
/// @param[in] frand Function returning a random number [0..1).
/// @param[out] randomRef The reference id of the random location.
/// @param[out] randomPt The random location. [(x, y, z)]
/// @returns The status flags for the query.
dtStatus findRandomPointAroundCircle(dtPolyRef startRef, const float* centerPos, const float maxRadius,
const dtQueryFilter* filter, float (*frand)(),
dtPolyRef* randomRef, float* randomPt) const;
// Returns closest point on navigation polygon.
// Uses detail polygons to find the closest point to the navigation polygon surface.
// Params:
// ref - (in) ref to the polygon.
// pos[3] - (in) the point to check.
// closest[3] - (out) closest point.
// Returns: true if closest point found.
/// Finds the closest point on the specified polygon.
/// @param[in] ref The reference id of the polygon.
/// @param[in] pos The position to check. [(x, y, z)]
/// @param[out] closest The closest point on the polygon. [(x, y, z)]
/// @returns The status flags for the query.
dtStatus closestPointOnPoly(dtPolyRef ref, const float* pos, float* closest) const;
// Returns closest point on navigation polygon boundary.
// Uses the navigation polygon boundary to snap the point to poly boundary
// if it is outside the polygon. Much faster than closestPointToPoly. Does not affect height.
// Params:
// ref - (in) ref to the polygon.
// pos[3] - (in) the point to check.
// closest[3] - (out) closest point.
// Returns: true if closest point found.
/// Returns a point on the boundary closest to the source point if the source point is outside the
/// polygon's xz-bounds.
/// @param[in] ref The reference id to the polygon.
/// @param[in] pos The position to check. [(x, y, z)]
/// @param[out] closest The closest point. [(x, y, z)]
/// @returns The status flags for the query.
dtStatus closestPointOnPolyBoundary(dtPolyRef ref, const float* pos, float* closest) const;
// Returns start and end location of an off-mesh link polygon.
// Params:
// prevRef - (in) ref to the polygon before the link (used to select direction).
// polyRef - (in) ref to the off-mesh link polygon.
// startPos[3] - (out) start point of the link.
// endPos[3] - (out) end point of the link.
// Returns: true if link is found.
dtStatus getOffMeshConnectionPolyEndPoints(dtPolyRef prevRef, dtPolyRef polyRef, float* startPos, float* endPos) const;
// Returns height of the polygon at specified location.
// Params:
// ref - (in) ref to the polygon.
// pos[3] - (in) the point where to locate the height.
// height - (out) height at the location.
// Returns: true if over polygon.
/// Gets the height of the polygon at the provided position using the height detail. (Most accurate.)
/// @param[in] ref The reference id of the polygon.
/// @param[in] pos A position within the xz-bounds of the polygon. [(x, y, z)]
/// @param[out] height The height at the surface of the polygon.
/// @returns The status flags for the query.
dtStatus getPolyHeight(dtPolyRef ref, const float* pos, float* height) const;
// Returns true if poly reference ins in closed list.
/// @}
/// @name Miscellaneous Functions
/// @{
/// Returns true if the polygon reference is valid and passes the filter restrictions.
/// @param[in] ref The polygon reference to check.
/// @param[in] filter The filter to apply.
bool isValidPolyRef(dtPolyRef ref, const dtQueryFilter* filter) const;
/// Returns true if the polygon reference is in the closed list.
/// @param[in] ref The reference id of the polygon to check.
/// @returns True if the polygon is in closed list.
bool isInClosedList(dtPolyRef ref) const;
/// Gets the node pool.
/// @returns The node pool.
class dtNodePool* getNodePool() const { return m_nodePool; }
/// Gets the navigation mesh the query object is using.
/// @return The navigation mesh the query object is using.
const dtNavMesh* getAttachedNavMesh() const { return m_nav; }
/// @}
private:
// Returns neighbour tile based on side.
/// Returns neighbour tile based on side.
dtMeshTile* getNeighbourTileAt(int x, int y, int side) const;
// Queries polygons within a tile.
/// Queries polygons within a tile.
int queryPolygonsInTile(const dtMeshTile* tile, const float* qmin, const float* qmax, const dtQueryFilter* filter,
dtPolyRef* polys, const int maxPolys) const;
// Find nearest polygon within a tile.
/// Find nearest polygon within a tile.
dtPolyRef findNearestPolyInTile(const dtMeshTile* tile, const float* center, const float* extents,
const dtQueryFilter* filter, float* nearestPt) const;
// Returns closest point on polygon.
dtStatus closestPointOnPolyInTile(const dtMeshTile* tile, const dtPoly* poly, const float* pos, float* closest) const;
/// Returns closest point on polygon.
void closestPointOnPolyInTile(const dtMeshTile* tile, const dtPoly* poly, const float* pos, float* closest) const;
// Returns portal points between two polygons.
/// Returns portal points between two polygons.
dtStatus getPortalPoints(dtPolyRef from, dtPolyRef to, float* left, float* right,
unsigned char& fromType, unsigned char& toType) const;
dtStatus getPortalPoints(dtPolyRef from, const dtPoly* fromPoly, const dtMeshTile* fromTile,
dtPolyRef to, const dtPoly* toPoly, const dtMeshTile* toTile,
float* left, float* right) const;
// Returns edge mid point between two polygons.
/// Returns edge mid point between two polygons.
dtStatus getEdgeMidPoint(dtPolyRef from, dtPolyRef to, float* mid) const;
dtStatus getEdgeMidPoint(dtPolyRef from, const dtPoly* fromPoly, const dtMeshTile* fromTile,
dtPolyRef to, const dtPoly* toPoly, const dtMeshTile* toTile,
float* mid) const;
const dtNavMesh* m_nav; // Pointer to navmesh data.
// Appends vertex to a straight path
dtStatus appendVertex(const float* pos, const unsigned char flags, const dtPolyRef ref,
float* straightPath, unsigned char* straightPathFlags, dtPolyRef* straightPathRefs,
int* straightPathCount, const int maxStraightPath) const;
// Appends intermediate portal points to a straight path.
dtStatus appendPortals(const int startIdx, const int endIdx, const float* endPos, const dtPolyRef* path,
float* straightPath, unsigned char* straightPathFlags, dtPolyRef* straightPathRefs,
int* straightPathCount, const int maxStraightPath, const int options) const;
const dtNavMesh* m_nav; ///< Pointer to navmesh data.
struct dtQueryData
{
@@ -393,15 +468,21 @@ private:
float startPos[3], endPos[3];
const dtQueryFilter* filter;
};
dtQueryData m_query; // Sliced query state.
dtQueryData m_query; ///< Sliced query state.
class dtNodePool* m_tinyNodePool; // Pointer to small node pool.
class dtNodePool* m_nodePool; // Pointer to node pool.
class dtNodeQueue* m_openList; // Pointer to open list queue.
class dtNodePool* m_tinyNodePool; ///< Pointer to small node pool.
class dtNodePool* m_nodePool; ///< Pointer to node pool.
class dtNodeQueue* m_openList; ///< Pointer to open list queue.
};
// Helper function to allocate navmesh query class using Detour allocator.
/// Allocates a query object using the Detour allocator.
/// @return An allocated query object, or null on failure.
/// @ingroup detour
dtNavMeshQuery* dtAllocNavMeshQuery();
/// Frees the specified query object using the Detour allocator.
/// @param[in] query A query object allocated using #dtAllocNavMeshQuery
/// @ingroup detour
void dtFreeNavMeshQuery(dtNavMeshQuery* query);
#endif // DETOURNAVMESHQUERY_H
+9 -8
View File
@@ -24,6 +24,7 @@
inline unsigned int dtHashRef(dtPolyRef a)
{
// Edited by TC
a = (~a) + (a << 18);
a = a ^ (a >> 31);
a = a * 21;
@@ -46,15 +47,15 @@ dtNodePool::dtNodePool(int maxNodes, int hashSize) :
dtAssert(m_maxNodes > 0);
m_nodes = (dtNode*)dtAlloc(sizeof(dtNode)*m_maxNodes, DT_ALLOC_PERM);
m_next = (unsigned short*)dtAlloc(sizeof(unsigned short)*m_maxNodes, DT_ALLOC_PERM);
m_first = (unsigned short*)dtAlloc(sizeof(unsigned short)*hashSize, DT_ALLOC_PERM);
m_next = (dtNodeIndex*)dtAlloc(sizeof(dtNodeIndex)*m_maxNodes, DT_ALLOC_PERM);
m_first = (dtNodeIndex*)dtAlloc(sizeof(dtNodeIndex)*hashSize, DT_ALLOC_PERM);
dtAssert(m_nodes);
dtAssert(m_next);
dtAssert(m_first);
memset(m_first, 0xff, sizeof(unsigned short)*m_hashSize);
memset(m_next, 0xff, sizeof(unsigned short)*m_maxNodes);
memset(m_first, 0xff, sizeof(dtNodeIndex)*m_hashSize);
memset(m_next, 0xff, sizeof(dtNodeIndex)*m_maxNodes);
}
dtNodePool::~dtNodePool()
@@ -66,14 +67,14 @@ dtNodePool::~dtNodePool()
void dtNodePool::clear()
{
memset(m_first, 0xff, sizeof(unsigned short)*m_hashSize);
memset(m_first, 0xff, sizeof(dtNodeIndex)*m_hashSize);
m_nodeCount = 0;
}
dtNode* dtNodePool::findNode(dtPolyRef id)
{
unsigned int bucket = dtHashRef(id) & (m_hashSize-1);
unsigned short i = m_first[bucket];
dtNodeIndex i = m_first[bucket];
while (i != DT_NULL_IDX)
{
if (m_nodes[i].id == id)
@@ -86,7 +87,7 @@ dtNode* dtNodePool::findNode(dtPolyRef id)
dtNode* dtNodePool::getNode(dtPolyRef id)
{
unsigned int bucket = dtHashRef(id) & (m_hashSize-1);
unsigned short i = m_first[bucket];
dtNodeIndex i = m_first[bucket];
dtNode* node = 0;
while (i != DT_NULL_IDX)
{
@@ -98,7 +99,7 @@ dtNode* dtNodePool::getNode(dtPolyRef id)
if (m_nodeCount >= m_maxNodes)
return 0;
i = (unsigned short)m_nodeCount;
i = (dtNodeIndex)m_nodeCount;
m_nodeCount++;
// Init node
+17 -15
View File
@@ -27,18 +27,20 @@ enum dtNodeFlags
DT_NODE_CLOSED = 0x02,
};
static const unsigned short DT_NULL_IDX = 0xffff;
typedef unsigned short dtNodeIndex;
static const dtNodeIndex DT_NULL_IDX = (dtNodeIndex)~0;
struct dtNode
{
float pos[3]; // Position of the node.
float cost; // Cost from previous node to current node.
float total; // Cost up to the node.
unsigned int pidx : 30; // Index to parent node.
unsigned int flags : 2; // Node flags 0/open/closed.
dtPolyRef id; // Polygon ref the node corresponds to.
float pos[3]; ///< Position of the node.
float cost; ///< Cost from previous node to current node.
float total; ///< Cost up to the node.
unsigned int pidx : 30; ///< Index to parent node.
unsigned int flags : 2; ///< Node flags 0/open/closed.
dtPolyRef id; ///< Polygon ref the node corresponds to.
};
class dtNodePool
{
public:
@@ -70,22 +72,22 @@ public:
inline int getMemUsed() const
{
return sizeof(*this) +
sizeof(dtNode)*m_maxNodes +
sizeof(unsigned short)*m_maxNodes +
sizeof(unsigned short)*m_hashSize;
sizeof(dtNode)*m_maxNodes +
sizeof(dtNodeIndex)*m_maxNodes +
sizeof(dtNodeIndex)*m_hashSize;
}
inline int getMaxNodes() const { return m_maxNodes; }
inline int getHashSize() const { return m_hashSize; }
inline unsigned short getFirst(int bucket) const { return m_first[bucket]; }
inline unsigned short getNext(int i) const { return m_next[i]; }
inline dtNodeIndex getFirst(int bucket) const { return m_first[bucket]; }
inline dtNodeIndex getNext(int i) const { return m_next[i]; }
private:
dtNode* m_nodes;
unsigned short* m_first;
unsigned short* m_next;
dtNodeIndex* m_first;
dtNodeIndex* m_next;
const int m_maxNodes;
const int m_hashSize;
int m_nodeCount;
@@ -154,4 +156,4 @@ private:
};
#endif // DETOURNODE_H
#endif // DETOURNODE_H
@@ -0,0 +1,64 @@
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
// 1. The origin of this software must not be misrepresented; you must not
// claim that you wrote the original software. If you use this software
// in a product, an acknowledgment in the product documentation would be
// appreciated but is not required.
// 2. Altered source versions must be plainly marked as such, and must not be
// misrepresented as being the original software.
// 3. This notice may not be removed or altered from any source distribution.
//
#ifndef DETOURSTATUS_H
#define DETOURSTATUS_H
typedef unsigned int dtStatus;
// High level status.
static const unsigned int DT_FAILURE = 1u << 31; // Operation failed.
static const unsigned int DT_SUCCESS = 1u << 30; // Operation succeed.
static const unsigned int DT_IN_PROGRESS = 1u << 29; // Operation still in progress.
// Detail information for status.
static const unsigned int DT_STATUS_DETAIL_MASK = 0x0ffffff;
static const unsigned int DT_WRONG_MAGIC = 1 << 0; // Input data is not recognized.
static const unsigned int DT_WRONG_VERSION = 1 << 1; // Input data is in wrong version.
static const unsigned int DT_OUT_OF_MEMORY = 1 << 2; // Operation ran out of memory.
static const unsigned int DT_INVALID_PARAM = 1 << 3; // An input parameter was invalid.
static const unsigned int DT_BUFFER_TOO_SMALL = 1 << 4; // Result buffer for the query was too small to store all results.
static const unsigned int DT_OUT_OF_NODES = 1 << 5; // Query ran out of nodes during search.
static const unsigned int DT_PARTIAL_RESULT = 1 << 6; // Query did not reach the end location, returning best guess.
// Returns true of status is success.
inline bool dtStatusSucceed(dtStatus status)
{
return (status & DT_SUCCESS) != 0;
}
// Returns true of status is failure.
inline bool dtStatusFailed(dtStatus status)
{
return (status & DT_FAILURE) != 0;
}
// Returns true of status is in progress.
inline bool dtStatusInProgress(dtStatus status)
{
return (status & DT_IN_PROGRESS) != 0;
}
// Returns true if specific detail is set.
inline bool dtStatusDetail(dtStatus status, unsigned int detail)
{
return (status & detail) != 0;
}
#endif // DETOURSTATUS_H
@@ -14,6 +14,7 @@ set(Recast_STAT_SRCS
RecastArea.cpp
RecastContour.cpp
RecastFilter.cpp
RecastLayers.cpp
RecastMesh.cpp
RecastMeshDetail.cpp
RecastRasterization.cpp
+75 -5
View File
@@ -32,7 +32,26 @@ float rcSqrt(float x)
return sqrtf(x);
}
/// @class rcContext
/// @par
///
/// This class does not provide logging or timer functionality on its
/// own. Both must be provided by a concrete implementation
/// by overriding the protected member functions. Also, this class does not
/// provide an interface for extracting log messages. (Only adding them.)
/// So concrete implementations must provide one.
///
/// If no logging or timers are required, just pass an instance of this
/// class through the Recast build process.
///
/// @par
///
/// Example:
/// @code
/// // Where ctx is an instance of rcContext and filepath is a char array.
/// ctx->log(RC_LOG_ERROR, "buildTiledNavigation: Could not load '%s'", filepath);
/// @endcode
void rcContext::log(const rcLogCategory category, const char* format, ...)
{
if (!m_logEnabled)
@@ -90,6 +109,28 @@ void rcFreeCompactHeightfield(rcCompactHeightfield* chf)
rcFree(chf);
}
rcHeightfieldLayerSet* rcAllocHeightfieldLayerSet()
{
rcHeightfieldLayerSet* lset = (rcHeightfieldLayerSet*)rcAlloc(sizeof(rcHeightfieldLayerSet), RC_ALLOC_PERM);
memset(lset, 0, sizeof(rcHeightfieldLayerSet));
return lset;
}
void rcFreeHeightfieldLayerSet(rcHeightfieldLayerSet* lset)
{
if (!lset) return;
for (int i = 0; i < lset->nlayers; ++i)
{
rcFree(lset->layers[i].heights);
rcFree(lset->layers[i].areas);
rcFree(lset->layers[i].cons);
}
rcFree(lset->layers);
rcFree(lset);
}
rcContourSet* rcAllocContourSet()
{
rcContourSet* cset = (rcContourSet*)rcAlloc(sizeof(rcContourSet), RC_ALLOC_PERM);
@@ -143,7 +184,6 @@ void rcFreePolyMeshDetail(rcPolyMeshDetail* dmesh)
rcFree(dmesh);
}
void rcCalcBounds(const float* verts, int nv, float* bmin, float* bmax)
{
// Calculate bounding box.
@@ -163,6 +203,11 @@ void rcCalcGridSize(const float* bmin, const float* bmax, float cs, int* w, int*
*h = (int)((bmax[2] - bmin[2])/cs+0.5f);
}
/// @par
///
/// See the #rcConfig documentation for more information on the configuration parameters.
///
/// @see rcAllocHeightfield, rcHeightfield
bool rcCreateHeightfield(rcContext* /*ctx*/, rcHeightfield& hf, int width, int height,
const float* bmin, const float* bmax,
float cs, float ch)
@@ -192,6 +237,14 @@ static void calcTriNormal(const float* v0, const float* v1, const float* v2, flo
rcVnormalize(norm);
}
/// @par
///
/// Only sets the aread id's for the walkable triangles. Does not alter the
/// area id's for unwalkable triangles.
///
/// See the #rcConfig documentation for more information on the configuration parameters.
///
/// @see rcHeightfield, rcClearUnwalkableTriangles, rcRasterizeTriangles
void rcMarkWalkableTriangles(rcContext* /*ctx*/, const float walkableSlopeAngle,
const float* verts, int /*nv*/,
const int* tris, int nt,
@@ -214,6 +267,14 @@ void rcMarkWalkableTriangles(rcContext* /*ctx*/, const float walkableSlopeAngle,
}
}
/// @par
///
/// Only sets the aread id's for the unwalkable triangles. Does not alter the
/// area id's for walkable triangles.
///
/// See the #rcConfig documentation for more information on the configuration parameters.
///
/// @see rcHeightfield, rcClearUnwalkableTriangles, rcRasterizeTriangles
void rcClearUnwalkableTriangles(rcContext* /*ctx*/, const float walkableSlopeAngle,
const float* verts, int /*nv*/,
const int* tris, int nt,
@@ -258,6 +319,15 @@ int rcGetHeightFieldSpanCount(rcContext* /*ctx*/, rcHeightfield& hf)
return spanCount;
}
/// @par
///
/// This is just the beginning of the process of fully building a compact heightfield.
/// Various filters may be applied applied, then the distance field and regions built.
/// E.g: #rcBuildDistanceField and #rcBuildRegions
///
/// See the #rcConfig documentation for more information on the configuration parameters.
///
/// @see rcAllocCompactHeightfield, rcHeightfield, rcCompactHeightfield, rcConfig
bool rcBuildCompactHeightfield(rcContext* ctx, const int walkableHeight, const int walkableClimb,
rcHeightfield& hf, rcCompactHeightfield& chf)
{
@@ -369,13 +439,13 @@ bool rcBuildCompactHeightfield(rcContext* ctx, const int walkableHeight, const i
if ((top - bot) >= walkableHeight && rcAbs((int)ns.y - (int)s.y) <= walkableClimb)
{
// Mark direction as walkable.
const int idx = k - (int)nc.index;
if (idx < 0 || idx > MAX_LAYERS)
const int lidx = k - (int)nc.index;
if (lidx < 0 || lidx > MAX_LAYERS)
{
tooHighNeighbour = rcMax(tooHighNeighbour, idx);
tooHighNeighbour = rcMax(tooHighNeighbour, lidx);
continue;
}
rcSetCon(s, dir, idx);
rcSetCon(s, dir, lidx);
break;
}
}
File diff suppressed because it is too large. Load diff
@@ -33,24 +33,45 @@ static void rcFreeDefault(void *ptr)
static rcAllocFunc* sRecastAllocFunc = rcAllocDefault;
static rcFreeFunc* sRecastFreeFunc = rcFreeDefault;
/// @see rcAlloc, rcFree
void rcAllocSetCustom(rcAllocFunc *allocFunc, rcFreeFunc *freeFunc)
{
sRecastAllocFunc = allocFunc ? allocFunc : rcAllocDefault;
sRecastFreeFunc = freeFunc ? freeFunc : rcFreeDefault;
}
/// @see rcAllocSetCustom
void* rcAlloc(int size, rcAllocHint hint)
{
return sRecastAllocFunc(size, hint);
}
/// @par
///
/// @warning This function leaves the value of @p ptr unchanged. So it still
/// points to the same (now invalid) location, and not to null.
///
/// @see rcAllocSetCustom
void rcFree(void* ptr)
{
if (ptr)
sRecastFreeFunc(ptr);
}
/// @class rcIntArray
///
/// While it is possible to pre-allocate a specific array size during
/// construction or by using the #resize method, certain methods will
/// automatically resize the array as needed.
///
/// @warning The array memory is not initialized to zero when the size is
/// manually set during construction or when using #resize.
/// @par
///
/// Using this method ensures the array is at least large enough to hold
/// the specified number of elements. This can improve performance by
/// avoiding auto-resizing during use.
void rcIntArray::resize(int n)
{
if (n > m_cap)
+60 -5
View File
@@ -19,23 +19,45 @@
#ifndef RECASTALLOC_H
#define RECASTALLOC_H
/// Provides hint values to the memory allocator on how long the
/// memory is expected to be used.
enum rcAllocHint
{
RC_ALLOC_PERM, // Memory persist after a function call.
RC_ALLOC_TEMP // Memory used temporarily within a function.
RC_ALLOC_PERM, ///< Memory will persist after a function call.
RC_ALLOC_TEMP ///< Memory used temporarily within a function.
};
/// A memory allocation function.
// @param[in] size The size, in bytes of memory, to allocate.
// @param[in] rcAllocHint A hint to the allocator on how long the memory is expected to be in use.
// @return A pointer to the beginning of the allocated memory block, or null if the allocation failed.
/// @see rcAllocSetCustom
typedef void* (rcAllocFunc)(int size, rcAllocHint hint);
/// A memory deallocation function.
/// @param[in] ptr A pointer to a memory block previously allocated using #rcAllocFunc.
/// @see rcAllocSetCustom
typedef void (rcFreeFunc)(void* ptr);
/// Sets the base custom allocation functions to be used by Recast.
/// @param[in] allocFunc The memory allocation function to be used by #rcAlloc
/// @param[in] freeFunc The memory de-allocation function to be used by #rcFree
void rcAllocSetCustom(rcAllocFunc *allocFunc, rcFreeFunc *freeFunc);
/// Allocates a memory block.
/// @param[in] size The size, in bytes of memory, to allocate.
/// @param[in] hint A hint to the allocator on how long the memory is expected to be in use.
/// @return A pointer to the beginning of the allocated memory block, or null if the allocation failed.
/// @see rcFree
void* rcAlloc(int size, rcAllocHint hint);
/// Deallocates a memory block.
/// @param[in] ptr A pointer to a memory block previously allocated using #rcAlloc.
/// @see rcAlloc
void rcFree(void* ptr);
// Simple dynamic array ints.
/// A simple dynamic array of integers.
class rcIntArray
{
int* m_data;
@@ -43,26 +65,59 @@ class rcIntArray
inline rcIntArray(const rcIntArray&);
inline rcIntArray& operator=(const rcIntArray&);
public:
/// Constructs an instance with an initial array size of zero.
inline rcIntArray() : m_data(0), m_size(0), m_cap(0) {}
/// Constructs an instance initialized to the specified size.
/// @param[in] n The initial size of the integer array.
inline rcIntArray(int n) : m_data(0), m_size(0), m_cap(0) { resize(n); }
inline ~rcIntArray() { rcFree(m_data); }
/// Specifies the new size of the integer array.
/// @param[in] n The new size of the integer array.
void resize(int n);
/// Push the specified integer onto the end of the array and increases the size by one.
/// @param[in] item The new value.
inline void push(int item) { resize(m_size+1); m_data[m_size-1] = item; }
/// Returns the value at the end of the array and reduces the size by one.
/// @return The value at the end of the array.
inline int pop() { if (m_size > 0) m_size--; return m_data[m_size]; }
/// The value at the specified array index.
/// @warning Does not provide overflow protection.
/// @param[in] i The index of the value.
inline const int& operator[](int i) const { return m_data[i]; }
/// The value at the specified array index.
/// @warning Does not provide overflow protection.
/// @param[in] i The index of the value.
inline int& operator[](int i) { return m_data[i]; }
/// The current size of the integer array.
inline int size() const { return m_size; }
};
// Simple internal helper class to delete array in scope
/// A simple helper class used to delete an array when it goes out of scope.
/// @note This class is rarely if ever used by the end user.
template<class T> class rcScopedDelete
{
T* ptr;
inline T* operator=(T* p);
public:
/// Constructs an instance with a null pointer.
inline rcScopedDelete() : ptr(0) {}
/// Constructs an instance with the specified pointer.
/// @param[in] p An pointer to an allocated array.
inline rcScopedDelete(T* p) : ptr(p) {}
inline ~rcScopedDelete() { rcFree(ptr); }
/// The root array pointer.
/// @return The root array pointer.
inline operator T*() { return ptr; }
};
+194 -5
View File
@@ -26,7 +26,14 @@
#include "RecastAlloc.h"
#include "RecastAssert.h"
/// @par
///
/// Basically, any spans that are closer to a boundary or obstruction than the specified radius
/// are marked as unwalkable.
///
/// This method is usually called immediately after the heightfield has been built.
///
/// @see rcCompactHeightfield, rcBuildCompactHeightfield, rcConfig::walkableRadius
bool rcErodeWalkableArea(rcContext* ctx, int radius, rcCompactHeightfield& chf)
{
rcAssert(ctx);
@@ -54,14 +61,26 @@ bool rcErodeWalkableArea(rcContext* ctx, int radius, rcCompactHeightfield& chf)
const rcCompactCell& c = chf.cells[x+y*w];
for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i)
{
if (chf.areas[i] != RC_NULL_AREA)
if (chf.areas[i] == RC_NULL_AREA)
{
dist[i] = 0;
}
else
{
const rcCompactSpan& s = chf.spans[i];
int nc = 0;
for (int dir = 0; dir < 4; ++dir)
{
if (rcGetCon(s, dir) != RC_NOT_CONNECTED)
nc++;
{
const int nx = x + rcGetDirOffsetX(dir);
const int ny = y + rcGetDirOffsetY(dir);
const int nidx = (int)chf.cells[nx+ny*w].index + rcGetCon(s, dir);
if (chf.areas[nidx] != RC_NULL_AREA)
{
nc++;
}
}
}
// At least one missing neighbour.
if (nc != 4)
@@ -213,7 +232,12 @@ static void insertSort(unsigned char* a, const int n)
}
}
/// @par
///
/// This filter is usually applied after applying area id's using functions
/// such as #rcMarkBoxArea, #rcMarkConvexPolyArea, and #rcMarkCylinderArea.
///
/// @see rcCompactHeightfield
bool rcMedianFilterWalkableArea(rcContext* ctx, rcCompactHeightfield& chf)
{
rcAssert(ctx);
@@ -288,6 +312,11 @@ bool rcMedianFilterWalkableArea(rcContext* ctx, rcCompactHeightfield& chf)
return true;
}
/// @par
///
/// The value of spacial parameters are in world units.
///
/// @see rcCompactHeightfield, rcMedianFilterWalkableArea
void rcMarkBoxArea(rcContext* ctx, const float* bmin, const float* bmax, unsigned char areaId,
rcCompactHeightfield& chf)
{
@@ -322,7 +351,8 @@ void rcMarkBoxArea(rcContext* ctx, const float* bmin, const float* bmax, unsigne
rcCompactSpan& s = chf.spans[i];
if ((int)s.y >= miny && (int)s.y <= maxy)
{
chf.areas[i] = areaId;
if (chf.areas[i] != RC_NULL_AREA)
chf.areas[i] = areaId;
}
}
}
@@ -347,6 +377,14 @@ static int pointInPoly(int nvert, const float* verts, const float* p)
return c;
}
/// @par
///
/// The value of spacial parameters are in world units.
///
/// The y-values of the polygon vertices are ignored. So the polygon is effectively
/// projected onto the xz-plane at @p hmin, then extruded to @p hmax.
///
/// @see rcCompactHeightfield, rcMedianFilterWalkableArea
void rcMarkConvexPolyArea(rcContext* ctx, const float* verts, const int nverts,
const float hmin, const float hmax, unsigned char areaId,
rcCompactHeightfield& chf)
@@ -393,6 +431,8 @@ void rcMarkConvexPolyArea(rcContext* ctx, const float* verts, const int nverts,
for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i)
{
rcCompactSpan& s = chf.spans[i];
if (chf.areas[i] == RC_NULL_AREA)
continue;
if ((int)s.y >= miny && (int)s.y <= maxy)
{
float p[3];
@@ -411,3 +451,152 @@ void rcMarkConvexPolyArea(rcContext* ctx, const float* verts, const int nverts,
ctx->stopTimer(RC_TIMER_MARK_CONVEXPOLY_AREA);
}
int rcOffsetPoly(const float* verts, const int nverts, const float offset,
float* outVerts, const int maxOutVerts)
{
const float MITER_LIMIT = 1.20f;
int n = 0;
for (int i = 0; i < nverts; i++)
{
const int a = (i+nverts-1) % nverts;
const int b = i;
const int c = (i+1) % nverts;
const float* va = &verts[a*3];
const float* vb = &verts[b*3];
const float* vc = &verts[c*3];
float dx0 = vb[0] - va[0];
float dy0 = vb[2] - va[2];
float d0 = dx0*dx0 + dy0*dy0;
if (d0 > 1e-6f)
{
d0 = 1.0f/rcSqrt(d0);
dx0 *= d0;
dy0 *= d0;
}
float dx1 = vc[0] - vb[0];
float dy1 = vc[2] - vb[2];
float d1 = dx1*dx1 + dy1*dy1;
if (d1 > 1e-6f)
{
d1 = 1.0f/rcSqrt(d1);
dx1 *= d1;
dy1 *= d1;
}
const float dlx0 = -dy0;
const float dly0 = dx0;
const float dlx1 = -dy1;
const float dly1 = dx1;
float cross = dx1*dy0 - dx0*dy1;
float dmx = (dlx0 + dlx1) * 0.5f;
float dmy = (dly0 + dly1) * 0.5f;
float dmr2 = dmx*dmx + dmy*dmy;
bool bevel = dmr2 * MITER_LIMIT*MITER_LIMIT < 1.0f;
if (dmr2 > 1e-6f)
{
const float scale = 1.0f / dmr2;
dmx *= scale;
dmy *= scale;
}
if (bevel && cross < 0.0f)
{
if (n+2 >= maxOutVerts)
return 0;
float d = (1.0f - (dx0*dx1 + dy0*dy1))*0.5f;
outVerts[n*3+0] = vb[0] + (-dlx0+dx0*d)*offset;
outVerts[n*3+1] = vb[1];
outVerts[n*3+2] = vb[2] + (-dly0+dy0*d)*offset;
n++;
outVerts[n*3+0] = vb[0] + (-dlx1-dx1*d)*offset;
outVerts[n*3+1] = vb[1];
outVerts[n*3+2] = vb[2] + (-dly1-dy1*d)*offset;
n++;
}
else
{
if (n+1 >= maxOutVerts)
return 0;
outVerts[n*3+0] = vb[0] - dmx*offset;
outVerts[n*3+1] = vb[1];
outVerts[n*3+2] = vb[2] - dmy*offset;
n++;
}
}
return n;
}
/// @par
///
/// The value of spacial parameters are in world units.
///
/// @see rcCompactHeightfield, rcMedianFilterWalkableArea
void rcMarkCylinderArea(rcContext* ctx, const float* pos,
const float r, const float h, unsigned char areaId,
rcCompactHeightfield& chf)
{
rcAssert(ctx);
ctx->startTimer(RC_TIMER_MARK_CYLINDER_AREA);
float bmin[3], bmax[3];
bmin[0] = pos[0] - r;
bmin[1] = pos[1];
bmin[2] = pos[2] - r;
bmax[0] = pos[0] + r;
bmax[1] = pos[1] + h;
bmax[2] = pos[2] + r;
const float r2 = r*r;
int minx = (int)((bmin[0]-chf.bmin[0])/chf.cs);
int miny = (int)((bmin[1]-chf.bmin[1])/chf.ch);
int minz = (int)((bmin[2]-chf.bmin[2])/chf.cs);
int maxx = (int)((bmax[0]-chf.bmin[0])/chf.cs);
int maxy = (int)((bmax[1]-chf.bmin[1])/chf.ch);
int maxz = (int)((bmax[2]-chf.bmin[2])/chf.cs);
if (maxx < 0) return;
if (minx >= chf.width) return;
if (maxz < 0) return;
if (minz >= chf.height) return;
if (minx < 0) minx = 0;
if (maxx >= chf.width) maxx = chf.width-1;
if (minz < 0) minz = 0;
if (maxz >= chf.height) maxz = chf.height-1;
for (int z = minz; z <= maxz; ++z)
{
for (int x = minx; x <= maxx; ++x)
{
const rcCompactCell& c = chf.cells[x+z*chf.width];
for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i)
{
rcCompactSpan& s = chf.spans[i];
if (chf.areas[i] == RC_NULL_AREA)
continue;
if ((int)s.y >= miny && (int)s.y <= maxy)
{
const float sx = chf.bmin[0] + (x+0.5f)*chf.cs;
const float sz = chf.bmin[2] + (z+0.5f)*chf.cs;
const float dx = sx - pos[0];
const float dz = sz - pos[2];
if (dx*dx + dz*dz < r2)
{
chf.areas[i] = areaId;
}
}
}
}
}
ctx->stopTimer(RC_TIMER_MARK_CYLINDER_AREA);
}
+1 -1
View File
@@ -24,7 +24,7 @@
#ifdef NDEBUG
// From http://cnicholson.net/2009/02/stupid-c-tricks-adventures-in-assert/
# define rcAssert(x) do { (void)sizeof(x); } while(__LINE__==-1,false)
# define rcAssert(x) do { (void)sizeof(x); } while((void)(__LINE__==-1),false)
#else
# include <assert.h>
# define rcAssert assert
+61 -14
View File
@@ -340,7 +340,7 @@ static void simplifyContour(rcIntArray& points, rcIntArray& simplified,
endi = ai;
}
// Tessellate only outer edges oredges between areas.
// Tessellate only outer edges or edges between areas.
if ((points[ci*4+3] & RC_CONTOUR_REG_MASK) == 0 ||
(points[ci*4+3] & RC_AREA_BORDER))
{
@@ -420,15 +420,13 @@ static void simplifyContour(rcIntArray& points, rcIntArray& simplified,
// Round based on the segments in lexilogical order so that the
// max tesselation is consistent regardles in which direction
// segments are traversed.
if (bx > ax || (bx == ax && bz > az))
const int n = bi < ai ? (bi+pn - ai) : (bi - ai);
if (n > 1)
{
const int n = bi < ai ? (bi+pn - ai) : (bi - ai);
maxi = (ai + n/2) % pn;
}
else
{
const int n = bi < ai ? (bi+pn - ai) : (bi - ai);
maxi = (ai + (n+1)/2) % pn;
if (bx > ax || (bx == ax && bz > az))
maxi = (ai + n/2) % pn;
else
maxi = (ai + (n+1)/2) % pn;
}
}
}
@@ -466,7 +464,7 @@ static void simplifyContour(rcIntArray& points, rcIntArray& simplified,
// and the neighbour region is take from the next raw point.
const int ai = (simplified[i*4+3]+1) % pn;
const int bi = simplified[i*4+3];
simplified[i*4+3] = (points[ai*4+3] & RC_CONTOUR_REG_MASK) | (points[bi*4+3] & RC_BORDER_VERTEX);
simplified[i*4+3] = (points[ai*4+3] & (RC_CONTOUR_REG_MASK|RC_AREA_BORDER)) | (points[bi*4+3] & RC_BORDER_VERTEX);
}
}
@@ -592,6 +590,19 @@ static bool mergeContours(rcContour& ca, rcContour& cb, int ia, int ib)
return true;
}
/// @par
///
/// The raw contours will match the region outlines exactly. The @p maxError and @p maxEdgeLen
/// parameters control how closely the simplified contours will match the raw contours.
///
/// Simplified contours are generated such that the vertices for portals between areas match up.
/// (They are considered mandatory vertices.)
///
/// Setting @p maxEdgeLength to zero will disabled the edge length feature.
///
/// See the #rcConfig documentation for more information on the configuration parameters.
///
/// @see rcAllocContourSet, rcCompactHeightfield, rcContourSet, rcConfig
bool rcBuildContours(rcContext* ctx, rcCompactHeightfield& chf,
const float maxError, const int maxEdgeLen,
rcContourSet& cset, const int buildFlags)
@@ -600,13 +611,26 @@ bool rcBuildContours(rcContext* ctx, rcCompactHeightfield& chf,
const int w = chf.width;
const int h = chf.height;
const int borderSize = chf.borderSize;
ctx->startTimer(RC_TIMER_BUILD_CONTOURS);
rcVcopy(cset.bmin, chf.bmin);
rcVcopy(cset.bmax, chf.bmax);
if (borderSize > 0)
{
// If the heightfield was build with bordersize, remove the offset.
const float pad = borderSize*chf.cs;
cset.bmin[0] += pad;
cset.bmin[2] += pad;
cset.bmax[0] -= pad;
cset.bmax[2] -= pad;
}
cset.cs = chf.cs;
cset.ch = chf.ch;
cset.width = chf.width - chf.borderSize*2;
cset.height = chf.height - chf.borderSize*2;
cset.borderSize = chf.borderSize;
int maxContours = rcMax((int)chf.maxRegions, 8);
cset.conts = (rcContour*)rcAlloc(sizeof(rcContour)*maxContours, RC_ALLOC_PERM);
@@ -658,8 +682,6 @@ bool rcBuildContours(rcContext* ctx, rcCompactHeightfield& chf,
ctx->stopTimer(RC_TIMER_BUILD_CONTOURS_TRACE);
ctx->startTimer(RC_TIMER_BUILD_CONTOURS_SIMPLIFY);
rcIntArray verts(256);
rcIntArray simplified(64);
@@ -682,10 +704,17 @@ bool rcBuildContours(rcContext* ctx, rcCompactHeightfield& chf,
verts.resize(0);
simplified.resize(0);
ctx->startTimer(RC_TIMER_BUILD_CONTOURS_TRACE);
walkContour(x, y, i, chf, flags, verts);
ctx->stopTimer(RC_TIMER_BUILD_CONTOURS_TRACE);
ctx->startTimer(RC_TIMER_BUILD_CONTOURS_SIMPLIFY);
simplifyContour(verts, simplified, maxError, maxEdgeLen, buildFlags);
removeDegenerateSegments(simplified);
ctx->stopTimer(RC_TIMER_BUILD_CONTOURS_SIMPLIFY);
// Store region->contour remap info.
// Create contour.
if (simplified.size()/4 >= 3)
@@ -720,6 +749,16 @@ bool rcBuildContours(rcContext* ctx, rcCompactHeightfield& chf,
return false;
}
memcpy(cont->verts, &simplified[0], sizeof(int)*cont->nverts*4);
if (borderSize > 0)
{
// If the heightfield was build with bordersize, remove the offset.
for (int j = 0; j < cont->nverts; ++j)
{
int* v = &cont->verts[j*4];
v[0] -= borderSize;
v[2] -= borderSize;
}
}
cont->nrverts = verts.size()/4;
cont->rverts = (int*)rcAlloc(sizeof(int)*cont->nrverts*4, RC_ALLOC_PERM);
@@ -729,6 +768,16 @@ bool rcBuildContours(rcContext* ctx, rcCompactHeightfield& chf,
return false;
}
memcpy(cont->rverts, &verts[0], sizeof(int)*cont->nrverts*4);
if (borderSize > 0)
{
// If the heightfield was build with bordersize, remove the offset.
for (int j = 0; j < cont->nrverts; ++j)
{
int* v = &cont->rverts[j*4];
v[0] -= borderSize;
v[2] -= borderSize;
}
}
/* cont->cx = cont->cy = cont->cz = 0;
for (int i = 0; i < cont->nverts; ++i)
@@ -796,8 +845,6 @@ bool rcBuildContours(rcContext* ctx, rcCompactHeightfield& chf,
}
}
ctx->stopTimer(RC_TIMER_BUILD_CONTOURS_SIMPLIFY);
ctx->stopTimer(RC_TIMER_BUILD_CONTOURS);
return true;
+31 -3
View File
@@ -22,7 +22,17 @@
#include "Recast.h"
#include "RecastAssert.h"
/// @par
///
/// Allows the formation of walkable regions that will flow over low lying
/// objects such as curbs, and up structures such as stairways.
///
/// Two neighboring spans are walkable if: <tt>rcAbs(currentSpan.smax - neighborSpan.smax) < waklableClimb</tt>
///
/// @warning Will override the effect of #rcFilterLedgeSpans. So if both filters are used, call
/// #rcFilterLedgeSpans after calling this filter.
///
/// @see rcHeightfield, rcConfig
void rcFilterLowHangingWalkableObstacles(rcContext* ctx, const int walkableClimb, rcHeightfield& solid)
{
rcAssert(ctx);
@@ -38,6 +48,7 @@ void rcFilterLowHangingWalkableObstacles(rcContext* ctx, const int walkableClimb
{
rcSpan* ps = 0;
bool previousWalkable = false;
unsigned char previousArea = RC_NULL_AREA;
for (rcSpan* s = solid.spans[x + y*w]; s; ps = s, s = s->next)
{
@@ -47,18 +58,29 @@ void rcFilterLowHangingWalkableObstacles(rcContext* ctx, const int walkableClimb
if (!walkable && previousWalkable)
{
if (rcAbs((int)s->smax - (int)ps->smax) <= walkableClimb)
s->area = RC_NULL_AREA;
s->area = previousArea;
}
// Copy walkable flag so that it cannot propagate
// past multiple non-walkable objects.
previousWalkable = walkable;
previousArea = s->area;
}
}
}
ctx->stopTimer(RC_TIMER_FILTER_LOW_OBSTACLES);
}
/// @par
///
/// A ledge is a span with one or more neighbors whose maximum is further away than @p walkableClimb
/// from the current span's maximum.
/// This method removes the impact of the overestimation of conservative voxelization
/// so the resulting mesh will not have regions hanging in the air over ledges.
///
/// A span is a ledge if: <tt>rcAbs(currentSpan.smax - neighborSpan.smax) > walkableClimb</tt>
///
/// @see rcHeightfield, rcConfig
void rcFilterLedgeSpans(rcContext* ctx, const int walkableHeight, const int walkableClimb,
rcHeightfield& solid)
{
@@ -149,6 +171,12 @@ void rcFilterLedgeSpans(rcContext* ctx, const int walkableHeight, const int walk
ctx->stopTimer(RC_TIMER_FILTER_BORDER);
}
/// @par
///
/// For this filter, the clearance above the span is the distance from the span's
/// maximum to the next higher span's minimum. (Same grid column.)
///
/// @see rcHeightfield, rcConfig
void rcFilterWalkableLowHeightSpans(rcContext* ctx, int walkableHeight, rcHeightfield& solid)
{
rcAssert(ctx);
@@ -0,0 +1,620 @@
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
// 1. The origin of this software must not be misrepresented; you must not
// claim that you wrote the original software. If you use this software
// in a product, an acknowledgment in the product documentation would be
// appreciated but is not required.
// 2. Altered source versions must be plainly marked as such, and must not be
// misrepresented as being the original software.
// 3. This notice may not be removed or altered from any source distribution.
//
#include <float.h>
#define _USE_MATH_DEFINES
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "Recast.h"
#include "RecastAlloc.h"
#include "RecastAssert.h"
static const int RC_MAX_LAYERS = RC_NOT_CONNECTED;
static const int RC_MAX_NEIS = 16;
struct rcLayerRegion
{
unsigned char layers[RC_MAX_LAYERS];
unsigned char neis[RC_MAX_NEIS];
unsigned short ymin, ymax;
unsigned char layerId; // Layer ID
unsigned char nlayers; // Layer count
unsigned char nneis; // Neighbour count
unsigned char base; // Flag indicating if the region is hte base of merged regions.
};
static void addUnique(unsigned char* a, unsigned char& an, unsigned char v)
{
const int n = (int)an;
for (int i = 0; i < n; ++i)
if (a[i] == v)
return;
a[an] = v;
an++;
}
static bool contains(const unsigned char* a, const unsigned char an, const unsigned char v)
{
const int n = (int)an;
for (int i = 0; i < n; ++i)
if (a[i] == v)
return true;
return false;
}
inline bool overlapRange(const unsigned short amin, const unsigned short amax,
const unsigned short bmin, const unsigned short bmax)
{
return (amin > bmax || amax < bmin) ? false : true;
}
struct rcLayerSweepSpan
{
unsigned short ns; // number samples
unsigned char id; // region id
unsigned char nei; // neighbour id
};
/// @par
///
/// See the #rcConfig documentation for more information on the configuration parameters.
///
/// @see rcAllocHeightfieldLayerSet, rcCompactHeightfield, rcHeightfieldLayerSet, rcConfig
bool rcBuildHeightfieldLayers(rcContext* ctx, rcCompactHeightfield& chf,
const int borderSize, const int walkableHeight,
rcHeightfieldLayerSet& lset)
{
rcAssert(ctx);
ctx->startTimer(RC_TIMER_BUILD_LAYERS);
const int w = chf.width;
const int h = chf.height;
rcScopedDelete<unsigned char> srcReg = (unsigned char*)rcAlloc(sizeof(unsigned char)*chf.spanCount, RC_ALLOC_TEMP);
if (!srcReg)
{
ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Out of memory 'srcReg' (%d).", chf.spanCount);
return false;
}
memset(srcReg,0xff,sizeof(unsigned char)*chf.spanCount);
const int nsweeps = chf.width;
rcScopedDelete<rcLayerSweepSpan> sweeps = (rcLayerSweepSpan*)rcAlloc(sizeof(rcLayerSweepSpan)*nsweeps, RC_ALLOC_TEMP);
if (!sweeps)
{
ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Out of memory 'sweeps' (%d).", nsweeps);
return false;
}
// Partition walkable area into monotone regions.
int prevCount[256];
unsigned char regId = 0;
for (int y = borderSize; y < h-borderSize; ++y)
{
memset(prevCount,0,sizeof(int)*regId);
unsigned char sweepId = 0;
for (int x = borderSize; x < w-borderSize; ++x)
{
const rcCompactCell& c = chf.cells[x+y*w];
for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i)
{
const rcCompactSpan& s = chf.spans[i];
if (chf.areas[i] == RC_NULL_AREA) continue;
unsigned char sid = 0xff;
// -x
if (rcGetCon(s, 0) != RC_NOT_CONNECTED)
{
const int ax = x + rcGetDirOffsetX(0);
const int ay = y + rcGetDirOffsetY(0);
const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, 0);
if (chf.areas[ai] != RC_NULL_AREA && srcReg[ai] != 0xff)
sid = srcReg[ai];
}
if (sid == 0xff)
{
sid = sweepId++;
sweeps[sid].nei = 0xff;
sweeps[sid].ns = 0;
}
// -y
if (rcGetCon(s,3) != RC_NOT_CONNECTED)
{
const int ax = x + rcGetDirOffsetX(3);
const int ay = y + rcGetDirOffsetY(3);
const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, 3);
const unsigned char nr = srcReg[ai];
if (nr != 0xff)
{
// Set neighbour when first valid neighbour is encoutered.
if (sweeps[sid].ns == 0)
sweeps[sid].nei = nr;
if (sweeps[sid].nei == nr)
{
// Update existing neighbour
sweeps[sid].ns++;
prevCount[nr]++;
}
else
{
// This is hit if there is nore than one neighbour.
// Invalidate the neighbour.
sweeps[sid].nei = 0xff;
}
}
}
srcReg[i] = sid;
}
}
// Create unique ID.
for (int i = 0; i < sweepId; ++i)
{
// If the neighbour is set and there is only one continuous connection to it,
// the sweep will be merged with the previous one, else new region is created.
if (sweeps[i].nei != 0xff && prevCount[sweeps[i].nei] == (int)sweeps[i].ns)
{
sweeps[i].id = sweeps[i].nei;
}
else
{
if (regId == 255)
{
ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Region ID overflow.");
return false;
}
sweeps[i].id = regId++;
}
}
// Remap local sweep ids to region ids.
for (int x = borderSize; x < w-borderSize; ++x)
{
const rcCompactCell& c = chf.cells[x+y*w];
for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i)
{
if (srcReg[i] != 0xff)
srcReg[i] = sweeps[srcReg[i]].id;
}
}
}
// Allocate and init layer regions.
const int nregs = (int)regId;
rcScopedDelete<rcLayerRegion> regs = (rcLayerRegion*)rcAlloc(sizeof(rcLayerRegion)*nregs, RC_ALLOC_TEMP);
if (!regs)
{
ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Out of memory 'regs' (%d).", nregs);
return false;
}
memset(regs, 0, sizeof(rcLayerRegion)*nregs);
for (int i = 0; i < nregs; ++i)
{
regs[i].layerId = 0xff;
regs[i].ymin = 0xffff;
regs[i].ymax = 0;
}
// Find region neighbours and overlapping regions.
for (int y = 0; y < h; ++y)
{
for (int x = 0; x < w; ++x)
{
const rcCompactCell& c = chf.cells[x+y*w];
unsigned char lregs[RC_MAX_LAYERS];
int nlregs = 0;
for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i)
{
const rcCompactSpan& s = chf.spans[i];
const unsigned char ri = srcReg[i];
if (ri == 0xff) continue;
regs[ri].ymin = rcMin(regs[ri].ymin, s.y);
regs[ri].ymax = rcMax(regs[ri].ymax, s.y);
// Collect all region layers.
if (nlregs < RC_MAX_LAYERS)
lregs[nlregs++] = ri;
// Update neighbours
for (int dir = 0; dir < 4; ++dir)
{
if (rcGetCon(s, dir) != RC_NOT_CONNECTED)
{
const int ax = x + rcGetDirOffsetX(dir);
const int ay = y + rcGetDirOffsetY(dir);
const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, dir);
const unsigned char rai = srcReg[ai];
if (rai != 0xff && rai != ri)
addUnique(regs[ri].neis, regs[ri].nneis, rai);
}
}
}
// Update overlapping regions.
for (int i = 0; i < nlregs-1; ++i)
{
for (int j = i+1; j < nlregs; ++j)
{
if (lregs[i] != lregs[j])
{
rcLayerRegion& ri = regs[lregs[i]];
rcLayerRegion& rj = regs[lregs[j]];
addUnique(ri.layers, ri.nlayers, lregs[j]);
addUnique(rj.layers, rj.nlayers, lregs[i]);
}
}
}
}
}
// Create 2D layers from regions.
unsigned char layerId = 0;
static const int MAX_STACK = 64;
unsigned char stack[MAX_STACK];
int nstack = 0;
for (int i = 0; i < nregs; ++i)
{
rcLayerRegion& root = regs[i];
// Skip alreadu visited.
if (root.layerId != 0xff)
continue;
// Start search.
root.layerId = layerId;
root.base = 1;
nstack = 0;
stack[nstack++] = (unsigned char)i;
while (nstack)
{
// Pop front
rcLayerRegion& reg = regs[stack[0]];
nstack--;
for (int j = 0; j < nstack; ++j)
stack[j] = stack[j+1];
const int nneis = (int)reg.nneis;
for (int j = 0; j < nneis; ++j)
{
const unsigned char nei = reg.neis[j];
rcLayerRegion& regn = regs[nei];
// Skip already visited.
if (regn.layerId != 0xff)
continue;
// Skip if the neighbour is overlapping root region.
if (contains(root.layers, root.nlayers, nei))
continue;
// Skip if the height range would become too large.
const int ymin = rcMin(root.ymin, regn.ymin);
const int ymax = rcMax(root.ymax, regn.ymax); // Edited by TC
if ((ymax - ymin) >= 255)
continue;
if (nstack < MAX_STACK)
{
// Deepen
stack[nstack++] = (unsigned char)nei;
// Mark layer id
regn.layerId = layerId;
// Merge current layers to root.
for (int k = 0; k < regn.nlayers; ++k)
addUnique(root.layers, root.nlayers, regn.layers[k]);
root.ymin = rcMin(root.ymin, regn.ymin);
root.ymax = rcMax(root.ymax, regn.ymax);
}
}
}
layerId++;
}
// Merge non-overlapping regions that are close in height.
const unsigned short mergeHeight = (unsigned short)walkableHeight * 4;
for (int i = 0; i < nregs; ++i)
{
rcLayerRegion& ri = regs[i];
if (!ri.base) continue;
unsigned char newId = ri.layerId;
for (;;)
{
unsigned char oldId = 0xff;
for (int j = 0; j < nregs; ++j)
{
if (i == j) continue;
rcLayerRegion& rj = regs[j];
if (!rj.base) continue;
// Skip if teh regions are not close to each other.
if (!overlapRange(ri.ymin,ri.ymax+mergeHeight, rj.ymin,rj.ymax+mergeHeight))
continue;
// Skip if the height range would become too large.
const int ymin = rcMin(ri.ymin, rj.ymin);
const int ymax = rcMax(ri.ymax, rj.ymax); // Edited by TC
if ((ymax - ymin) >= 255)
continue;
// Make sure that there is no overlap when mergin 'ri' and 'rj'.
bool overlap = false;
// Iterate over all regions which have the same layerId as 'rj'
for (int k = 0; k < nregs; ++k)
{
if (regs[k].layerId != rj.layerId)
continue;
// Check if region 'k' is overlapping region 'ri'
// Index to 'regs' is the same as region id.
if (contains(ri.layers,ri.nlayers, (unsigned char)k))
{
overlap = true;
break;
}
}
// Cannot merge of regions overlap.
if (overlap)
continue;
// Can merge i and j.
oldId = rj.layerId;
break;
}
// Could not find anything to merge with, stop.
if (oldId == 0xff)
break;
// Merge
for (int j = 0; j < nregs; ++j)
{
rcLayerRegion& rj = regs[j];
if (rj.layerId == oldId)
{
rj.base = 0;
// Remap layerIds.
rj.layerId = newId;
// Add overlaid layers from 'rj' to 'ri'.
for (int k = 0; k < rj.nlayers; ++k)
addUnique(ri.layers, ri.nlayers, rj.layers[k]);
// Update heigh bounds.
ri.ymin = rcMin(ri.ymin, rj.ymin);
ri.ymax = rcMax(ri.ymax, rj.ymax);
}
}
}
}
// Compact layerIds
unsigned char remap[256];
memset(remap, 0, 256);
// Find number of unique layers.
layerId = 0;
for (int i = 0; i < nregs; ++i)
remap[regs[i].layerId] = 1;
for (int i = 0; i < 256; ++i)
{
if (remap[i])
remap[i] = layerId++;
else
remap[i] = 0xff;
}
// Remap ids.
for (int i = 0; i < nregs; ++i)
regs[i].layerId = remap[regs[i].layerId];
// No layers, return empty.
if (layerId == 0)
{
ctx->stopTimer(RC_TIMER_BUILD_LAYERS);
return true;
}
// Create layers.
rcAssert(lset.layers == 0);
const int lw = w - borderSize*2;
const int lh = h - borderSize*2;
// Build contracted bbox for layers.
float bmin[3], bmax[3];
rcVcopy(bmin, chf.bmin);
rcVcopy(bmax, chf.bmax);
bmin[0] += borderSize*chf.cs;
bmin[2] += borderSize*chf.cs;
bmax[0] -= borderSize*chf.cs;
bmax[2] -= borderSize*chf.cs;
lset.nlayers = (int)layerId;
lset.layers = (rcHeightfieldLayer*)rcAlloc(sizeof(rcHeightfieldLayer)*lset.nlayers, RC_ALLOC_PERM);
if (!lset.layers)
{
ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Out of memory 'layers' (%d).", lset.nlayers);
return false;
}
memset(lset.layers, 0, sizeof(rcHeightfieldLayer)*lset.nlayers);
// Store layers.
for (int i = 0; i < lset.nlayers; ++i)
{
unsigned char curId = (unsigned char)i;
// Allocate memory for the current layer.
rcHeightfieldLayer* layer = &lset.layers[i];
memset(layer, 0, sizeof(rcHeightfieldLayer));
const int gridSize = sizeof(unsigned char)*lw*lh;
layer->heights = (unsigned char*)rcAlloc(gridSize, RC_ALLOC_PERM);
if (!layer->heights)
{
ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Out of memory 'heights' (%d).", gridSize);
return false;
}
memset(layer->heights, 0xff, gridSize);
layer->areas = (unsigned char*)rcAlloc(gridSize, RC_ALLOC_PERM);
if (!layer->areas)
{
ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Out of memory 'areas' (%d).", gridSize);
return false;
}
memset(layer->areas, 0, gridSize);
layer->cons = (unsigned char*)rcAlloc(gridSize, RC_ALLOC_PERM);
if (!layer->cons)
{
ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Out of memory 'cons' (%d).", gridSize);
return false;
}
memset(layer->cons, 0, gridSize);
// Find layer height bounds.
int hmin = 0, hmax = 0;
for (int j = 0; j < nregs; ++j)
{
if (regs[j].base && regs[j].layerId == curId)
{
hmin = (int)regs[j].ymin;
hmax = (int)regs[j].ymax;
}
}
layer->width = lw;
layer->height = lh;
layer->cs = chf.cs;
layer->ch = chf.ch;
// Adjust the bbox to fit the heighfield.
rcVcopy(layer->bmin, bmin);
rcVcopy(layer->bmax, bmax);
layer->bmin[1] = bmin[1] + hmin*chf.ch;
layer->bmax[1] = bmin[1] + hmax*chf.ch;
layer->hmin = hmin;
layer->hmax = hmax;
// Update usable data region.
layer->minx = layer->width;
layer->maxx = 0;
layer->miny = layer->height;
layer->maxy = 0;
// Copy height and area from compact heighfield.
for (int y = 0; y < lh; ++y)
{
for (int x = 0; x < lw; ++x)
{
const int cx = borderSize+x;
const int cy = borderSize+y;
const rcCompactCell& c = chf.cells[cx+cy*w];
for (int j = (int)c.index, nj = (int)(c.index+c.count); j < nj; ++j)
{
const rcCompactSpan& s = chf.spans[j];
// Skip unassigned regions.
if (srcReg[j] == 0xff)
continue;
// Skip of does nto belong to current layer.
unsigned char lid = regs[srcReg[j]].layerId;
if (lid != curId)
continue;
// Update data bounds.
layer->minx = rcMin(layer->minx, x);
layer->maxx = rcMax(layer->maxx, x);
layer->miny = rcMin(layer->miny, y);
layer->maxy = rcMax(layer->maxy, y);
// Store height and area type.
const int idx = x+y*lw;
layer->heights[idx] = (unsigned char)(s.y - hmin);
layer->areas[idx] = chf.areas[j];
// Check connection.
unsigned char portal = 0;
unsigned char con = 0;
for (int dir = 0; dir < 4; ++dir)
{
if (rcGetCon(s, dir) != RC_NOT_CONNECTED)
{
const int ax = cx + rcGetDirOffsetX(dir);
const int ay = cy + rcGetDirOffsetY(dir);
const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, dir);
unsigned char alid = srcReg[ai] != 0xff ? regs[srcReg[ai]].layerId : 0xff;
// Portal mask
if (chf.areas[ai] != RC_NULL_AREA && lid != alid)
{
portal |= (unsigned char)(1<<dir);
// Update height so that it matches on both sides of the portal.
const rcCompactSpan& as = chf.spans[ai];
if (as.y > hmin)
layer->heights[idx] = rcMax(layer->heights[idx], (unsigned char)(as.y - hmin));
}
// Valid connection mask
if (chf.areas[ai] != RC_NULL_AREA && lid == alid)
{
const int nx = ax - borderSize;
const int ny = ay - borderSize;
if (nx >= 0 && ny >= 0 && nx < lw && ny < lh)
con |= (unsigned char)(1<<dir);
}
}
}
layer->cons[idx] = (portal << 4) | con;
}
}
}
if (layer->minx > layer->maxx)
layer->minx = layer->maxx = 0;
if (layer->miny > layer->maxy)
layer->miny = layer->maxy = 0;
}
ctx->stopTimer(RC_TIMER_BUILD_LAYERS);
return true;
}
+117 -11
View File
@@ -59,6 +59,7 @@ static bool buildMeshAdjacency(unsigned short* polys, const int npolys,
unsigned short* t = &polys[i*vertsPerPoly*2];
for (int j = 0; j < vertsPerPoly; ++j)
{
if (t[j] == RC_MESH_NULL_IDX) break;
unsigned short v0 = t[j];
unsigned short v1 = (j+1 >= vertsPerPoly || t[j+1] == RC_MESH_NULL_IDX) ? t[0] : t[j+1];
if (v0 < v1)
@@ -83,6 +84,7 @@ static bool buildMeshAdjacency(unsigned short* polys, const int npolys,
unsigned short* t = &polys[i*vertsPerPoly*2];
for (int j = 0; j < vertsPerPoly; ++j)
{
if (t[j] == RC_MESH_NULL_IDX) break;
unsigned short v0 = t[j];
unsigned short v1 = (j+1 >= vertsPerPoly || t[j+1] == RC_MESH_NULL_IDX) ? t[0] : t[j+1];
if (v0 > v1)
@@ -195,7 +197,7 @@ inline bool collinear(const int* a, const int* b, const int* c)
// Returns true iff ab properly intersects cd: they share
// a point interior to both segments. The properness of the
// intersection is ensured by using strict leftness.
bool intersectProp(const int* a, const int* b, const int* c, const int* d)
static bool intersectProp(const int* a, const int* b, const int* c, const int* d)
{
// Eliminate improper cases.
if (collinear(a,b,c) || collinear(a,b,d) ||
@@ -470,6 +472,7 @@ static void mergePolys(unsigned short* pa, unsigned short* pb, int ea, int eb,
memcpy(pa, tmp, sizeof(unsigned short)*nvp);
}
static void pushFront(int v, int* arr, int& an)
{
an++;
@@ -547,9 +550,9 @@ static bool canRemoveVertex(rcContext* ctx, rcPolyMesh& mesh, const unsigned sho
// Check if the edge exists
bool exists = false;
for (int k = 0; k < nedges; ++k)
for (int m = 0; m < nedges; ++m)
{
int* e = &edges[k*3];
int* e = &edges[m*3];
if (e[1] == b)
{
// Exists, increment vertex share count.
@@ -892,8 +895,13 @@ static bool removeVertex(rcContext* ctx, rcPolyMesh& mesh, const unsigned short
return true;
}
bool rcBuildPolyMesh(rcContext* ctx, rcContourSet& cset, int nvp, rcPolyMesh& mesh)
/// @par
///
/// @note If the mesh data is to be used to construct a Detour navigation mesh, then the upper
/// limit must be retricted to <= #DT_VERTS_PER_POLYGON.
///
/// @see rcAllocPolyMesh, rcContourSet, rcPolyMesh, rcConfig
bool rcBuildPolyMesh(rcContext* ctx, rcContourSet& cset, const int nvp, rcPolyMesh& mesh)
{
rcAssert(ctx);
@@ -903,6 +911,7 @@ bool rcBuildPolyMesh(rcContext* ctx, rcContourSet& cset, int nvp, rcPolyMesh& me
rcVcopy(mesh.bmax, cset.bmax);
mesh.cs = cset.cs;
mesh.ch = cset.ch;
mesh.borderSize = cset.borderSize;
int maxVertices = 0;
int maxTris = 0;
@@ -925,7 +934,7 @@ bool rcBuildPolyMesh(rcContext* ctx, rcContourSet& cset, int nvp, rcPolyMesh& me
rcScopedDelete<unsigned char> vflags = (unsigned char*)rcAlloc(sizeof(unsigned char)*maxVertices, RC_ALLOC_TEMP);
if (!vflags)
{
ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.verts' (%d).", maxVertices);
ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'vflags' (%d).", maxVertices);
return false;
}
memset(vflags, 0, maxVertices);
@@ -936,7 +945,7 @@ bool rcBuildPolyMesh(rcContext* ctx, rcContourSet& cset, int nvp, rcPolyMesh& me
ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.verts' (%d).", maxVertices);
return false;
}
mesh.polys = (unsigned short*)rcAlloc(sizeof(unsigned short)*maxTris*nvp*2*2, RC_ALLOC_PERM);
mesh.polys = (unsigned short*)rcAlloc(sizeof(unsigned short)*maxTris*nvp*2, RC_ALLOC_PERM);
if (!mesh.polys)
{
ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.polys' (%d).", maxTris*nvp*2);
@@ -1044,7 +1053,7 @@ bool rcBuildPolyMesh(rcContext* ctx, rcContourSet& cset, int nvp, rcPolyMesh& me
vflags[indices[j]] = 1;
}
}
// Build initial polygons.
int npolys = 0;
memset(polys, 0xff, maxVertsPerCont*nvp*sizeof(unsigned short));
@@ -1141,6 +1150,7 @@ bool rcBuildPolyMesh(rcContext* ctx, rcContourSet& cset, int nvp, rcPolyMesh& me
}
// Remove vertex
// Note: mesh.nverts is already decremented inside removeVertex()!
// Fixup vertex flags
for (int j = i; j < mesh.nverts; ++j)
vflags[j] = vflags[j+1];
--i;
@@ -1153,6 +1163,37 @@ bool rcBuildPolyMesh(rcContext* ctx, rcContourSet& cset, int nvp, rcPolyMesh& me
ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Adjacency failed.");
return false;
}
// Find portal edges
if (mesh.borderSize > 0)
{
const int w = cset.width;
const int h = cset.height;
for (int i = 0; i < mesh.npolys; ++i)
{
unsigned short* p = &mesh.polys[i*2*nvp];
for (int j = 0; j < nvp; ++j)
{
if (p[j] == RC_MESH_NULL_IDX) break;
// Skip connected edges.
if (p[nvp+j] != RC_MESH_NULL_IDX)
continue;
int nj = j+1;
if (nj >= nvp || p[nj] == RC_MESH_NULL_IDX) nj = 0;
const unsigned short* va = &mesh.verts[p[j]*3];
const unsigned short* vb = &mesh.verts[p[nj]*3];
if ((int)va[0] == 0 && (int)vb[0] == 0)
p[nvp+j] = 0x8000 | 0;
else if ((int)va[2] == h && (int)vb[2] == h)
p[nvp+j] = 0x8000 | 1;
else if ((int)va[0] == w && (int)vb[0] == w)
p[nvp+j] = 0x8000 | 2;
else if ((int)va[2] == 0 && (int)vb[2] == 0)
p[nvp+j] = 0x8000 | 3;
}
}
}
// Just allocate the mesh flags array. The user is resposible to fill it.
mesh.flags = (unsigned short*)rcAlloc(sizeof(unsigned short)*mesh.npolys, RC_ALLOC_PERM);
@@ -1165,11 +1206,11 @@ bool rcBuildPolyMesh(rcContext* ctx, rcContourSet& cset, int nvp, rcPolyMesh& me
if (mesh.nverts > 0xffff)
{
ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: The resulting mesh has too many vertices %d (max %d). Data can be corrupted.", mesh.nverts, 0xffff);
ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: The resulting mesh has too many vertices %d (max %d). Data can be corrupted.", mesh.nverts, 0xffff);
}
if (mesh.npolys > 0xffff)
{
ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: The resulting mesh has too many polygons %d (max %d). Data can be corrupted.", mesh.npolys, 0xffff);
ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: The resulting mesh has too many polygons %d (max %d). Data can be corrupted.", mesh.npolys, 0xffff);
}
ctx->stopTimer(RC_TIMER_BUILD_POLYMESH);
@@ -1177,6 +1218,7 @@ bool rcBuildPolyMesh(rcContext* ctx, rcContourSet& cset, int nvp, rcPolyMesh& me
return true;
}
/// @see rcAllocPolyMesh, rcPolyMesh
bool rcMergePolyMeshes(rcContext* ctx, rcPolyMesh** meshes, const int nmeshes, rcPolyMesh& mesh)
{
rcAssert(ctx);
@@ -1268,7 +1310,7 @@ bool rcMergePolyMeshes(rcContext* ctx, rcPolyMesh** meshes, const int nmeshes, r
ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: Out of memory 'vremap' (%d).", maxVertsPerMesh);
return false;
}
memset(nextVert, 0, sizeof(int)*maxVerts);
memset(vremap, 0, sizeof(unsigned short)*maxVertsPerMesh);
for (int i = 0; i < nmeshes; ++i)
{
@@ -1320,3 +1362,67 @@ bool rcMergePolyMeshes(rcContext* ctx, rcPolyMesh** meshes, const int nmeshes, r
return true;
}
bool rcCopyPolyMesh(rcContext* ctx, const rcPolyMesh& src, rcPolyMesh& dst)
{
rcAssert(ctx);
// Destination must be empty.
rcAssert(dst.verts == 0);
rcAssert(dst.polys == 0);
rcAssert(dst.regs == 0);
rcAssert(dst.areas == 0);
rcAssert(dst.flags == 0);
dst.nverts = src.nverts;
dst.npolys = src.npolys;
dst.maxpolys = src.npolys;
dst.nvp = src.nvp;
rcVcopy(dst.bmin, src.bmin);
rcVcopy(dst.bmax, src.bmax);
dst.cs = src.cs;
dst.ch = src.ch;
dst.borderSize = src.borderSize;
dst.verts = (unsigned short*)rcAlloc(sizeof(unsigned short)*src.nverts*3, RC_ALLOC_PERM);
if (!dst.verts)
{
ctx->log(RC_LOG_ERROR, "rcCopyPolyMesh: Out of memory 'dst.verts' (%d).", src.nverts*3);
return false;
}
memcpy(dst.verts, src.verts, sizeof(unsigned short)*src.nverts*3);
dst.polys = (unsigned short*)rcAlloc(sizeof(unsigned short)*src.npolys*2*src.nvp, RC_ALLOC_PERM);
if (!dst.polys)
{
ctx->log(RC_LOG_ERROR, "rcCopyPolyMesh: Out of memory 'dst.polys' (%d).", src.npolys*2*src.nvp);
return false;
}
memcpy(dst.polys, src.polys, sizeof(unsigned short)*src.npolys*2*src.nvp);
dst.regs = (unsigned short*)rcAlloc(sizeof(unsigned short)*src.npolys, RC_ALLOC_PERM);
if (!dst.regs)
{
ctx->log(RC_LOG_ERROR, "rcCopyPolyMesh: Out of memory 'dst.regs' (%d).", src.npolys);
return false;
}
memcpy(dst.regs, src.regs, sizeof(unsigned short)*src.npolys);
dst.areas = (unsigned char*)rcAlloc(sizeof(unsigned char)*src.npolys, RC_ALLOC_PERM);
if (!dst.areas)
{
ctx->log(RC_LOG_ERROR, "rcCopyPolyMesh: Out of memory 'dst.areas' (%d).", src.npolys);
return false;
}
memcpy(dst.areas, src.areas, sizeof(unsigned char)*src.npolys);
dst.flags = (unsigned short*)rcAlloc(sizeof(unsigned short)*src.npolys, RC_ALLOC_PERM);
if (!dst.flags)
{
ctx->log(RC_LOG_ERROR, "rcCopyPolyMesh: Out of memory 'dst.flags' (%d).", src.npolys);
return false;
}
memcpy(dst.flags, src.flags, sizeof(unsigned char)*src.npolys);
return true;
}
@@ -267,11 +267,11 @@ static int addEdge(rcContext* ctx, int* edges, int& nedges, const int maxEdges,
int e = findEdge(edges, nedges, s, t);
if (e == UNDEF)
{
int* e = &edges[nedges*4];
e[0] = s;
e[1] = t;
e[2] = l;
e[3] = r;
int* edge = &edges[nedges*4];
edge[0] = s;
edge[1] = t;
edge[2] = l;
edge[3] = r;
return nedges++;
}
else
@@ -554,7 +554,7 @@ static bool buildPolyDetail(rcContext* ctx, const float* in, const int nin,
float dx = vi[0] - vj[0];
float dy = vi[1] - vj[1];
float dz = vi[2] - vj[2];
float d = sqrtf(dx*dx + dz*dz);
float d = rcSqrt(dx*dx + dz*dz);
int nn = 1 + (int)floorf(d/sampleDist);
if (nn >= MAX_VERTS_PER_EDGE) nn = MAX_VERTS_PER_EDGE-1;
if (nverts+nn >= MAX_VERTS)
@@ -583,10 +583,10 @@ static bool buildPolyDetail(rcContext* ctx, const float* in, const int nin,
int maxi = -1;
for (int m = a+1; m < b; ++m)
{
float d = distancePtSeg(&edge[m*3],va,vb);
if (d > maxd)
float dev = distancePtSeg(&edge[m*3],va,vb);
if (dev > maxd)
{
maxd = d;
maxd = dev;
maxi = m;
}
}
@@ -743,12 +743,15 @@ static bool buildPolyDetail(rcContext* ctx, const float* in, const int nin,
static void getHeightData(const rcCompactHeightfield& chf,
const unsigned short* poly, const int npoly,
const unsigned short* verts,
const unsigned short* verts, const int bs,
rcHeightPatch& hp, rcIntArray& stack)
{
// Floodfill the heightfield to get 2D height data,
// starting at vertex locations as seeds.
// Note: Reads to the compact heightfield are offset by border size (bs)
// since border size offset is already removed from the polymesh vertices.
memset(hp.data, 0, sizeof(unsigned short)*hp.width*hp.height);
stack.resize(0);
@@ -772,7 +775,7 @@ static void getHeightData(const rcCompactHeightfield& chf,
az < hp.ymin || az >= hp.ymin+hp.height)
continue;
const rcCompactCell& c = chf.cells[ax+az*chf.width];
const rcCompactCell& c = chf.cells[(ax+bs)+(az+bs)*chf.width];
for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i)
{
const rcCompactSpan& s = chf.spans[i];
@@ -844,7 +847,7 @@ static void getHeightData(const rcCompactHeightfield& chf,
if (hp.data[ax-hp.xmin+(ay-hp.ymin)*hp.width] != 0)
continue;
const int ai = (int)chf.cells[ax+ay*chf.width].index + rcGetCon(cs, dir);
const int ai = (int)chf.cells[(ax+bs)+(ay+bs)*chf.width].index + rcGetCon(cs, dir);
int idx = ax-hp.xmin+(ay-hp.ymin)*hp.width;
hp.data[idx] = 1;
@@ -900,7 +903,7 @@ static void getHeightData(const rcCompactHeightfield& chf,
if (hp.data[ax-hp.xmin+(ay-hp.ymin)*hp.width] != RC_UNSET_HEIGHT)
continue;
const int ai = (int)chf.cells[ax+ay*chf.width].index + rcGetCon(cs, dir);
const int ai = (int)chf.cells[(ax+bs)+(ay+bs)*chf.width].index + rcGetCon(cs, dir);
const rcCompactSpan& as = chf.spans[ai];
int idx = ax-hp.xmin+(ay-hp.ymin)*hp.width;
@@ -938,8 +941,11 @@ static unsigned char getTriFlags(const float* va, const float* vb, const float*
return flags;
}
/// @par
///
/// See the #rcConfig documentation for more information on the configuration parameters.
///
/// @see rcAllocPolyMeshDetail, rcPolyMesh, rcCompactHeightfield, rcPolyMeshDetail, rcConfig
bool rcBuildPolyMeshDetail(rcContext* ctx, const rcPolyMesh& mesh, const rcCompactHeightfield& chf,
const float sampleDist, const float sampleMaxError,
rcPolyMeshDetail& dmesh)
@@ -955,6 +961,7 @@ bool rcBuildPolyMeshDetail(rcContext* ctx, const rcPolyMesh& mesh, const rcCompa
const float cs = mesh.cs;
const float ch = mesh.ch;
const float* orig = mesh.bmin;
const int borderSize = mesh.borderSize;
rcIntArray edges(64);
rcIntArray tris(512);
@@ -1065,7 +1072,7 @@ bool rcBuildPolyMeshDetail(rcContext* ctx, const rcPolyMesh& mesh, const rcCompa
hp.ymin = bounds[i*4+2];
hp.width = bounds[i*4+1]-bounds[i*4+0];
hp.height = bounds[i*4+3]-bounds[i*4+2];
getHeightData(chf, p, npoly, mesh.verts, hp, stack);
getHeightData(chf, p, npoly, mesh.verts, borderSize, hp, stack);
// Build detail mesh.
int nverts = 0;
@@ -1157,6 +1164,7 @@ bool rcBuildPolyMeshDetail(rcContext* ctx, const rcPolyMesh& mesh, const rcCompa
return true;
}
/// @see rcAllocPolyMeshDetail, rcPolyMeshDetail
bool rcMergePolyMeshDetails(rcContext* ctx, rcPolyMeshDetail** meshes, const int nmeshes, rcPolyMeshDetail& mesh)
{
rcAssert(ctx);
@@ -154,6 +154,13 @@ static void addSpan(rcHeightfield& hf, const int x, const int y,
}
}
/// @par
///
/// The span addition can be set to favor flags. If the span is merged to
/// another span and the new @p smax is within @p flagMergeThr units
/// from the existing span, the span flags are merged.
///
/// @see rcHeightfield, rcSpan.
void rcAddSpan(rcContext* /*ctx*/, rcHeightfield& hf, const int x, const int y,
const unsigned short smin, const unsigned short smax,
const unsigned char area, const int flagMergeThr)
@@ -276,6 +283,11 @@ static void rasterizeTri(const float* v0, const float* v1, const float* v2,
}
}
/// @par
///
/// No spans will be added if the triangle does not overlap the heightfield grid.
///
/// @see rcHeightfield
void rcRasterizeTriangle(rcContext* ctx, const float* v0, const float* v1, const float* v2,
const unsigned char area, rcHeightfield& solid,
const int flagMergeThr)
@@ -291,6 +303,11 @@ void rcRasterizeTriangle(rcContext* ctx, const float* v0, const float* v1, const
ctx->stopTimer(RC_TIMER_RASTERIZE_TRIANGLES);
}
/// @par
///
/// Spans will only be added for triangles that overlap the heightfield grid.
///
/// @see rcHeightfield
void rcRasterizeTriangles(rcContext* ctx, const float* verts, const int /*nv*/,
const int* tris, const unsigned char* areas, const int nt,
rcHeightfield& solid, const int flagMergeThr)
@@ -314,6 +331,11 @@ void rcRasterizeTriangles(rcContext* ctx, const float* verts, const int /*nv*/,
ctx->stopTimer(RC_TIMER_RASTERIZE_TRIANGLES);
}
/// @par
///
/// Spans will only be added for triangles that overlap the heightfield grid.
///
/// @see rcHeightfield
void rcRasterizeTriangles(rcContext* ctx, const float* verts, const int /*nv*/,
const unsigned short* tris, const unsigned char* areas, const int nt,
rcHeightfield& solid, const int flagMergeThr)
@@ -337,6 +359,11 @@ void rcRasterizeTriangles(rcContext* ctx, const float* verts, const int /*nv*/,
ctx->stopTimer(RC_TIMER_RASTERIZE_TRIANGLES);
}
/// @par
///
/// Spans will only be added for triangles that overlap the heightfield grid.
///
/// @see rcHeightfield
void rcRasterizeTriangles(rcContext* ctx, const float* verts, const unsigned char* areas, const int nt,
rcHeightfield& solid, const int flagMergeThr)
{
+85 -31
View File
@@ -283,6 +283,8 @@ static bool floodRegion(int x, int y, int i,
if (chf.areas[ai] != area)
continue;
unsigned short nr = srcReg[ai];
if (nr & RC_BORDER_REG) // Do not take borders into account.
continue;
if (nr != 0 && nr != r)
ar = nr;
@@ -296,9 +298,9 @@ static bool floodRegion(int x, int y, int i,
const int ai2 = (int)chf.cells[ax2+ay2*w].index + rcGetCon(as, dir2);
if (chf.areas[ai2] != area)
continue;
unsigned short nr = srcReg[ai2];
if (nr != 0 && nr != r)
ar = nr;
unsigned short nr2 = srcReg[ai2];
if (nr2 != 0 && nr2 != r)
ar = nr2;
}
}
}
@@ -319,16 +321,13 @@ static bool floodRegion(int x, int y, int i,
const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(cs, dir);
if (chf.areas[ai] != area)
continue;
if (chf.dist[ai] >= lev)
if (chf.dist[ai] >= lev && srcReg[ai] == 0)
{
if (srcReg[ai] == 0)
{
srcReg[ai] = r;
srcDist[ai] = 0;
stack.push(ax);
stack.push(ay);
stack.push(ai);
}
srcReg[ai] = r;
srcDist[ai] = 0;
stack.push(ax);
stack.push(ay);
stack.push(ai);
}
}
}
@@ -679,17 +678,17 @@ static void walkContour(int x, int y, int i, int dir,
// Remove adjacent duplicates.
if (cont.size() > 1)
{
for (int i = 0; i < cont.size(); )
for (int j = 0; j < cont.size(); )
{
int ni = (i+1) % cont.size();
if (cont[i] == cont[ni])
int nj = (j+1) % cont.size();
if (cont[j] == cont[nj])
{
for (int j = i; j < cont.size()-1; ++j)
cont[j] = cont[j+1];
for (int k = j; k < cont.size()-1; ++k)
cont[k] = cont[k+1];
cont.pop();
}
else
++i;
++j;
}
}
}
@@ -807,14 +806,14 @@ static bool filterSmallRegions(rcContext* ctx, int minRegionArea, int mergeRegio
connectsToBorder = true;
continue;
}
rcRegion& nreg = regions[creg.connections[j]];
if (nreg.visited)
rcRegion& neireg = regions[creg.connections[j]];
if (neireg.visited)
continue;
if (nreg.id == 0 || (nreg.id & RC_BORDER_REG))
if (neireg.id == 0 || (neireg.id & RC_BORDER_REG))
continue;
// Visit
stack.push(nreg.id);
nreg.visited = true;
stack.push(neireg.id);
neireg.visited = true;
}
}
@@ -937,7 +936,16 @@ static bool filterSmallRegions(rcContext* ctx, int minRegionArea, int mergeRegio
return true;
}
/// @par
///
/// This is usually the second to the last step in creating a fully built
/// compact heightfield. This step is required before regions are built
/// using #rcBuildRegions or #rcBuildRegionsMonotone.
///
/// After this step, the distance data is available via the rcCompactHeightfield::maxDistance
/// and rcCompactHeightfield::dist fields.
///
/// @see rcCompactHeightfield, rcBuildRegions, rcBuildRegionsMonotone
bool rcBuildDistanceField(rcContext* ctx, rcCompactHeightfield& chf)
{
rcAssert(ctx);
@@ -1020,6 +1028,25 @@ struct rcSweepSpan
unsigned short nei; // neighbour id
};
/// @par
///
/// Non-null regions will consist of connected, non-overlapping walkable spans that form a single contour.
/// Contours will form simple polygons.
///
/// If multiple regions form an area that is smaller than @p minRegionArea, then all spans will be
/// re-assigned to the zero (null) region.
///
/// Partitioning can result in smaller than necessary regions. @p mergeRegionArea helps
/// reduce unecessarily small regions.
///
/// See the #rcConfig documentation for more information on the configuration parameters.
///
/// The region data will be available via the rcCompactHeightfield::maxRegions
/// and rcCompactSpan::reg fields.
///
/// @warning The distance field must be created using #rcBuildDistanceField before attempting to build regions.
///
/// @see rcCompactHeightfield, rcCompactSpan, rcBuildDistanceField, rcBuildRegionsMonotone, rcConfig
bool rcBuildRegionsMonotone(rcContext* ctx, rcCompactHeightfield& chf,
const int borderSize, const int minRegionArea, const int mergeRegionArea)
{
@@ -1059,6 +1086,8 @@ bool rcBuildRegionsMonotone(rcContext* ctx, rcCompactHeightfield& chf,
paintRectRegion(w-bw, w, 0, h, id|RC_BORDER_REG, chf, srcReg); id++;
paintRectRegion(0, w, 0, bh, id|RC_BORDER_REG, chf, srcReg); id++;
paintRectRegion(0, w, h-bh, h, id|RC_BORDER_REG, chf, srcReg); id++;
chf.borderSize = borderSize;
}
rcIntArray prev(256);
@@ -1170,6 +1199,25 @@ bool rcBuildRegionsMonotone(rcContext* ctx, rcCompactHeightfield& chf,
return true;
}
/// @par
///
/// Non-null regions will consist of connected, non-overlapping walkable spans that form a single contour.
/// Contours will form simple polygons.
///
/// If multiple regions form an area that is smaller than @p minRegionArea, then all spans will be
/// re-assigned to the zero (null) region.
///
/// Watershed partitioning can result in smaller than necessary regions, especially in diagonal corridors.
/// @p mergeRegionArea helps reduce unecessarily small regions.
///
/// See the #rcConfig documentation for more information on the configuration parameters.
///
/// The region data will be available via the rcCompactHeightfield::maxRegions
/// and rcCompactSpan::reg fields.
///
/// @warning The distance field must be created using #rcBuildDistanceField before attempting to build regions.
///
/// @see rcCompactHeightfield, rcCompactSpan, rcBuildDistanceField, rcBuildRegionsMonotone, rcConfig
bool rcBuildRegions(rcContext* ctx, rcCompactHeightfield& chf,
const int borderSize, const int minRegionArea, const int mergeRegionArea)
{
@@ -1209,11 +1257,19 @@ bool rcBuildRegions(rcContext* ctx, rcCompactHeightfield& chf,
// const int expandIters = 4 + walkableRadius * 2;
const int expandIters = 8;
// Mark border regions.
paintRectRegion(0, borderSize, 0, h, regionId|RC_BORDER_REG, chf, srcReg); regionId++;
paintRectRegion(w-borderSize, w, 0, h, regionId|RC_BORDER_REG, chf, srcReg); regionId++;
paintRectRegion(0, w, 0, borderSize, regionId|RC_BORDER_REG, chf, srcReg); regionId++;
paintRectRegion(0, w, h-borderSize, h, regionId|RC_BORDER_REG, chf, srcReg); regionId++;
if (borderSize > 0)
{
// Make sure border will not overflow.
const int bw = rcMin(w, borderSize);
const int bh = rcMin(h, borderSize);
// Paint regions
paintRectRegion(0, bw, 0, h, regionId|RC_BORDER_REG, chf, srcReg); regionId++;
paintRectRegion(w-bw, w, 0, h, regionId|RC_BORDER_REG, chf, srcReg); regionId++;
paintRectRegion(0, w, 0, bh, regionId|RC_BORDER_REG, chf, srcReg); regionId++;
paintRectRegion(0, w, h-bh, h, regionId|RC_BORDER_REG, chf, srcReg); regionId++;
chf.borderSize = borderSize;
}
while (level > 0)
{
@@ -1242,7 +1298,6 @@ bool rcBuildRegions(rcContext* ctx, rcCompactHeightfield& chf,
{
if (chf.dist[i] < level || srcReg[i] != 0 || chf.areas[i] == RC_NULL_AREA)
continue;
if (floodRegion(x, y, i, level, regionId, chf, srcReg, srcDist, stack))
regionId++;
}
@@ -1250,7 +1305,6 @@ bool rcBuildRegions(rcContext* ctx, rcCompactHeightfield& chf,
}
ctx->stopTimer(RC_TIMER_BUILD_REGIONS_FLOOD);
}
// Expand current regions until no empty connected cells found.
@@ -0,0 +1,2 @@
-- Update Void Traveler Scriptname
UPDATE `creature_template` SET `ScriptName`= 'npc_voidtraveler' WHERE `ScriptName`= 'mob_voidtraveler';
@@ -0,0 +1,47 @@
-- Arathandris Silversky
UPDATE `creature_template` SET `gossip_menu_id`=2208 WHERE `entry` IN (9528);
-- Add Any Missing Gossip Menu item
DELETE FROM `gossip_menu` WHERE `entry`=2208 AND `text_id`=2844; -- Before Quest 4101
INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (2208,2844);
DELETE FROM `gossip_menu` WHERE `entry`=2208 AND `text_id`=2845; -- After Quest 4101
INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (2208,2845);
DELETE FROM `gossip_menu` WHERE `entry`=2208 AND `text_id`=2848; -- If Horde
INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (2208,2848);
-- Add Any Missing Gossip Option
DELETE FROM `gossip_menu_option` WHERE menu_id=2208;
INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES
(2208,0,0,"I need a Cenarion beacon.",1,1,0,0,0,0,''),
(2208,1,0,"What plants are in Felwood that might be corrupted?",1,1,0,0,0,0,'');
-- Add option conditions for gossip
DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14) AND `SourceGroup` IN (2208);
INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`NegativeCondition`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES
(14,2208,2844,0,8,3781,0,0,1,0,'','Arathandris Silversky - Show gossip text if player has not been rewarded quest 4101'),
(14,2208,2845,0,8,3781,0,0,0,0,'','Arathandris Silversky - Show gossip text if player has been rewarded quest 4101'),
(14,2208,2848,0,6,67,0,0,0,0,'','Arathandris Silversky - Show gossip text if player is horde');
-- Add option conditions for gossip
DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (15) AND `SourceGroup` IN (2208);
INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`NegativeCondition`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES
(15,2208,0,0,8,3781,0,0,0,0,'','Arathandris Silversky - Show gossip option if player has been rewarded quest 4101'),
(15,2208,0,1,2,11511,1,1,1,0,'','Arathandris Silversky - Show gossip option if player does not have Cenarion Beacon'),
(15,2208,1,0,8,3781,0,0,0,0,'','Arathandris Silversky - Show gossip option if player has been rewarded quest 4101');
-- Maybess Riverbreeze
UPDATE `creature_template` SET `gossip_menu_id`=21400 WHERE `entry` IN (9529);
-- Add Any Missing Gossip Menu item
DELETE FROM `gossip_menu` WHERE `entry`=21400 AND `text_id`=2842; -- Before Quest 4102
INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (21400,2842);
DELETE FROM `gossip_menu` WHERE `entry`=21400 AND `text_id`=2843; -- After Quest 4102
INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (21400,2843);
DELETE FROM `gossip_menu` WHERE `entry`=21400 AND `text_id`=2849; -- If Alliance
INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (21400,2849);
-- Add Any Missing Gossip Option
DELETE FROM `gossip_menu_option` WHERE menu_id=21400;
INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES
(21400,0,0,"I need a Cenarion beacon.",1,1,0,0,0,0,''),
(21400,1,0,"What plants are in Felwood that might be corrupted?",1,1,0,0,0,0,'');
-- Add option conditions for gossip
DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (15) AND `SourceGroup` IN (21400);
INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`NegativeCondition`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES
(15,21400,0,0,8,3781,0,0,0,0,'','Maybess Riverbreeze - Show gossip option if player has been rewarded quest 4102'),
(15,21400,0,1,2,11511,1,1,1,0,'','Maybess Riverbreeze - Show gossip option if player does not have Cenarion Beacon'),
(15,21400,1,0,8,3781,0,0,0,0,'','Maybess Riverbreeze - Show gossip option if player has been rewarded quest 4102');
@@ -0,0 +1,5 @@
DELETE FROM `spelldifficulty_dbc` WHERE `id` IN (33923,33666,33711);
INSERT INTO `spelldifficulty_dbc` (`id`,`spellid0`,`spellid1`) VALUES
(33923,33923,38796),
(33666,33666,38795),
(33711,33711,38794);
@@ -0,0 +1,2 @@
-- Fix cosmetic-drakkari-bat-ph
UPDATE `creature_template` SET `flags_extra`=`flags_extra`|2 WHERE `entry`=27490;
@@ -0,0 +1 @@
UPDATE `creature_template` SET `faction_A`=103,`faction_H`=103 WHERE `entry`=26127;
@@ -0,0 +1,23 @@
-- Fix some path errors
UPDATE `creature` SET `MovementType`=0 WHERE `guid`=66949;
DELETE FROM `creature_addon` WHERE `guid`=114330;
INSERT INTO `creature_addon` (`guid`,`path_id`,`bytes2`) VALUES
(114330,1143300,1);
UPDATE `creature_addon` SET `path_id`=2034560 WHERE `guid`=203456;
UPDATE `waypoint_data` SET `id`=2034560 WHERE `id`=203591;
-- Windrock hunter removed in rev 2.2.0
DELETE FROM `creature` WHERE `id`=18996;
-- Delete existing unblizzlike spawns
DELETE FROM `creature` WHERE `id` IN (29064,29063,29062,29098,29096,29097);
-- Delete addon data from previous mentioned wrong spanws
DELETE FROM `creature_addon` WHERE `guid` BETWEEN 127316 AND 127337;
DELETE FROM `creature_addon` WHERE `guid` BETWEEN 127340 AND 127375;
DELETE FROM `creature_addon` WHERE `guid` BETWEEN 127293 AND 127315;
DELETE FROM `creature_addon` WHERE `guid` BETWEEN 127272 AND 127292;
DELETE FROM `creature_addon` WHERE `guid`=12246;
DELETE FROM `gameobject` WHERE `guid` IN (17454,17455);
@@ -0,0 +1,5 @@
DELETE FROM `creature` WHERE `id` IN (29119,28925,28924,29051);
DELETE FROM `linked_respawn` WHERE `guid` IN (127272,127273,127275,127293,127296,127318,127340,127341,127350,127351,127352,127355,127357,127359,127360,127364,127365,127375);
DELETE FROM `spell_ranks` WHERE `first_spell_id` IN (24440,24475);
@@ -0,0 +1,13 @@
UPDATE `quest_template` SET `PrevQuestId`=12596 WHERE `id`=12541;
UPDATE `quest_template` SET `PrevQuestId`=12565, `SpecialFlags`=1 WHERE `id`=12567;
-- Gooey Ghoul Drool SAI
SET @ENTRY := 29856;
UPDATE `creature_template` SET `AIName`= 'SmartAI',`ScriptName`= '' WHERE `entry`=@ENTRY;
DELETE FROM `smart_scripts` WHERE `source_type`=0 AND `entryorguid`=@ENTRY;
INSERT INTO `smart_scripts` (`entryorguid`,`source_type`,`id`,`link`,`event_type`,`event_phase_mask`,`event_chance`,`event_flags`,`event_param1`,`event_param2`,`event_param3`,`event_param4`,`action_type`,`action_param1`,`action_param2`,`action_param3`,`action_param4`,`action_param5`,`action_param6`,`target_type`,`target_param1`,`target_param2`,`target_param3`,`target_x`,`target_y`,`target_z`,`target_o`,`comment`) VALUES
(@ENTRY,0,0,0,8,0,100,0,55364,0,0,0,41,0,0,0,0,0,0,1,0,0,0,0,0,0,0, 'Gooey Ghoul Drool - On Spell Hit Create Gooey Ghoul Drool - despawn');
-- Add missing spell click
DELETE FROM `npc_spellclick_spells` WHERE `npc_entry`=29856 AND `spell_id`=55364;
INSERT INTO `npc_spellclick_spells` (`npc_entry`,`spell_id`,`cast_flags`) VALUES
(29856,55364,1);
@@ -0,0 +1,46 @@
-- Add texts for Alchemist Finklestein
DELETE FROM `creature_text` WHERE `entry`=28205;
INSERT INTO `creature_text` (`entry`,`groupid`,`id`,`text`,`type`,`language`,`probability`,`emote`,`duration`,`sound`,`comment`) VALUES
-- Events 1,2,3
(28205,0,0,'Quickly, get me some...',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,0,1,'I think it needs...',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,0,2,'Find me some...',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,0,3,'It simply must have some...',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,0,4,'We need some...',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,0,5,'It simply must have some...',42,0,100,0,0,0,'Alchemist Finklestein'),
-- Event 4
(28205,1,0,'I think it''s time for...',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,1,1,'Next, we''ll need...',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,1,2,'Tastes like it needs more....',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,1,3,'Alright, now find me some...',42,0,100,0,0,0,'Alchemist Finklestein'),
-- Event 5
(28205,2,0,'Coming along nicely, but still needs...',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,2,1,'Before it thickens, we must add...',42,0,100,0,0,0,'Alchemist Finklestein'),
-- Event 6
(28205,3,0,'Before it boils over, I need...',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,3,1,'It''s thickening! Quickly, get some...',42,0,100,0,0,0,'Alchemist Finklestein'),
-- Fail
(28205,4,0,'You''re too late. I must start again from the beginning....',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,4,1,'No! The serum is ruined!',42,0,100,0,0,0,'Alchemist Finklestein'),
-- Item request
(28205,5,0,'Knotroot!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,6,0,'Pickled Eagle Egg!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,7,0,'Speckled Guano!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,8,0,'Withered Batwing!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,9,0,'Seasoned Slider Cider!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,10,0,'Pulverized Gargoyle Teeth!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,11,0,'Muddy Mire Maggot!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,12,0,'Spiky Spider Egg!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,13,0,'Hairy Herring Head!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,14,0,'Putrid Pirate Perspiration!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,15,0,'Icecrown Bottled Water!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,16,0,'Wasp''s Wings!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,17,0,'Prismatic Mojo!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,18,0,'Raptor Claw!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,19,0,'Amberseed!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,20,0,'Shrunken Dragon''s Claw!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,21,0,'Chilled Serpent Mucus!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,22,0,'Crystallized Hogsnot!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,23,0,'Crushed Basilisk Crystals!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,24,0,'Trollbane!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,25,0,'Frozen Spider Ichor!',42,0,100,0,0,0,'Alchemist Finklestein');
@@ -0,0 +1,2 @@
-- Fix address check for multi-jump hack
UPDATE `warden_checks` SET `result`='75440FB75E', `length`=5 WHERE `id`=785;
@@ -0,0 +1,255 @@
SET @GUID := 21707;
SET @QUEST_INFILTRATING_VOLTARUS := 12661;
SET @QUEST_REUNITED := 12663;
SET @QUEST_DARK_HORIZON := 12664;
SET @NPC_DRAKURU := 28503;
SET @NPC_STEFAN := 28518;
SET @NPC_GOREBAG := 28666;
SET @NPC_FLYING_FIEND := 28669;
SET @NPC_OVERLORD_DRAKURU := 28717;
SET @NPC_PERSISTENCE := 29863;
UPDATE `creature_template` SET `speed_walk`=2.4, `speed_run`=0.992063, `AIName`='SmartAI' WHERE `entry`=@NPC_GOREBAG;
UPDATE `creature_template` SET `speed_walk`=4.4, `speed_run`=1.375, `InhabitType`=4, `AIName`='SmartAI', `vehicleId`=127 WHERE `entry`=@NPC_FLYING_FIEND;
UPDATE `creature_template` SET `AIName`='SmartAI' WHERE `entry`=@NPC_OVERLORD_DRAKURU;
UPDATE `creature_template` SET `unit_flags`=0, `InhabitType`=4 WHERE `entry`=28759;
UPDATE `creature_template` SET `AIName`='SmartAI' WHERE `entry`=@NPC_DRAKURU;
UPDATE `creature_template` SET `InhabitType`=4 WHERE `entry`=@NPC_PERSISTENCE;
DELETE FROM `creature_template_addon` WHERE `entry`=@NPC_PERSISTENCE;
INSERT INTO `creature_template_addon` (`entry`,`bytes1`,`bytes2`) VALUES
(@NPC_PERSISTENCE,50331648,1);
UPDATE `creature` SET `spawndist`=0, `MovementType`=0, `unit_flags`=768 WHERE `guid` IN (103732,103734,103744,103751,103753,103755,103765,103766);
DELETE FROM `creature` WHERE `guid` IN (@GUID,111712);
INSERT INTO `creature` (`guid`,`id`,`map`,`spawnMask`,`phaseMask`,`modelid`,`equipment_id`,`position_x`,`position_y`,`position_z`,`orientation`,`spawntimesecs`,`spawndist`,`currentwaypoint`,`curhealth`,`curmana`,`MovementType`,`npcflag`,`unit_flags`,`dynamicflags`) VALUES
(@GUID,28717,571,1,1,0,0,5954.766,-3273.196,406.9324,5.445427,300,0,0,0,0,0,0,0,0);
DELETE FROM `areatrigger_scripts` WHERE `entry` IN (5056,5057,5058,5059,5060,5095,5096,5097,5098);
INSERT INTO `areatrigger_scripts` (`entry`,`ScriptName`) VALUES
(5056,'SmartTrigger'),
(5057,'SmartTrigger'),
(5058,'SmartTrigger'),
(5059,'SmartTrigger'),
(5060,'SmartTrigger'),
(5095,'SmartTrigger'),
(5096,'SmartTrigger'),
(5097,'SmartTrigger'),
(5098,'SmartTrigger');
DELETE FROM `smart_scripts` WHERE `entryorguid` IN (-@GUID,-100088,-100089,-100090,-100091,-100092,-100093,-100094,-100095,@NPC_DRAKURU,@NPC_GOREBAG,@NPC_FLYING_FIEND,@NPC_PERSISTENCE) AND `source_type`=0;
DELETE FROM `smart_scripts` WHERE `entryorguid`=@NPC_STEFAN AND `source_type`=0 AND `id`=4;
DELETE FROM `smart_scripts` WHERE `entryorguid` IN (5056,5057,5058,5059,5060,5095,5096,5097,5098) AND `source_type`=2;
DELETE FROM `smart_scripts` WHERE `entryorguid` IN (@NPC_FLYING_FIEND*100,@NPC_OVERLORD_DRAKURU*100,@NPC_PERSISTENCE*100) AND `source_type`=9;
INSERT INTO `smart_scripts` (`entryorguid`,`source_type`,`id`,`link`,`event_type`,`event_phase_mask`,`event_chance`,`event_flags`,`event_param1`,`event_param2`,`event_param3`,`event_param4`,`action_type`,`action_param1`,`action_param2`,`action_param3`,`action_param4`,`action_param5`,`action_param6`,`target_type`,`target_param1`,`target_param2`,`target_param3`,`target_x`,`target_y`,`target_z`,`target_o`,`comment`) VALUES
(-100095,0,0,0,11,0,100,0,0,0,0,0,22,1,0,0,0,0,0,1,0,0,0,0,0,0,0,'Overlord Drakuru - On spawn - Set event phase 1'),
(-100095,0,1,2,38,1,100,0,0,1,0,0,1,0,0,0,0,0,0,12,1,0,0,0,0,0,0,'Overlord Drakuru - On data 0 1 set - Say line'),
(-100095,0,2,0,61,1,100,0,0,0,0,0,80,@NPC_OVERLORD_DRAKURU*100,2,0,0,0,0,1,0,0,0,0,0,0,0,'Overlord Drakuru - On data 0 1 set - Say line'),
(-100092,0,0,0,11,0,100,0,0,0,0,0,22,1,0,0,0,0,0,1,0,0,0,0,0,0,0,'Overlord Drakuru - On spawn - Set event phase 1'),
(-100092,0,1,2,38,1,100,0,0,1,0,0,1,1,0,0,0,0,0,12,1,0,0,0,0,0,0,'Overlord Drakuru - On data 0 1 set - Say line'),
(-100092,0,2,0,61,1,100,0,0,0,0,0,80,@NPC_OVERLORD_DRAKURU*100,2,0,0,0,0,1,0,0,0,0,0,0,0,'Overlord Drakuru - On data 0 1 set - Say line'),
(-100088,0,0,0,11,0,100,0,0,0,0,0,22,1,0,0,0,0,0,1,0,0,0,0,0,0,0,'Overlord Drakuru - On spawn - Set event phase 1'),
(-100088,0,1,2,38,1,100,0,0,1,0,0,1,2,0,0,0,0,0,12,1,0,0,0,0,0,0,'Overlord Drakuru - On data 0 1 set - Say line'),
(-100088,0,2,0,61,1,100,0,0,0,0,0,80,@NPC_OVERLORD_DRAKURU*100,2,0,0,0,0,1,0,0,0,0,0,0,0,'Overlord Drakuru - On data 0 1 set - Say line'),
(-@GUID,0,0,0,11,0,100,0,0,0,0,0,22,1,0,0,0,0,0,1,0,0,0,0,0,0,0,'Overlord Drakuru - On spawn - Set event phase 1'),
(-@GUID,0,1,2,38,1,100,0,0,1,0,0,1,3,0,0,0,0,0,12,1,0,0,0,0,0,0,'Overlord Drakuru - On data 0 1 set - Say line'),
(-@GUID,0,2,0,61,1,100,0,0,0,0,0,80,@NPC_OVERLORD_DRAKURU*100,2,0,0,0,0,1,0,0,0,0,0,0,0,'Overlord Drakuru - On data 0 1 set - Say line'),
(-100090,0,0,0,11,0,100,0,0,0,0,0,22,1,0,0,0,0,0,1,0,0,0,0,0,0,0,'Overlord Drakuru - On spawn - Set event phase 1'),
(-100090,0,1,2,38,1,100,0,0,1,0,0,1,4,0,0,0,0,0,12,1,0,0,0,0,0,0,'Overlord Drakuru - On data 0 1 set - Say line'),
(-100090,0,2,0,61,1,100,0,0,0,0,0,80,@NPC_OVERLORD_DRAKURU*100,2,0,0,0,0,1,0,0,0,0,0,0,0,'Overlord Drakuru - On data 0 1 set - Say line'),
(-100094,0,0,0,11,0,100,0,0,0,0,0,22,1,0,0,0,0,0,1,0,0,0,0,0,0,0,'Overlord Drakuru - On spawn - Set event phase 1'),
(-100094,0,1,2,38,1,100,0,0,1,0,0,1,5,0,0,0,0,0,12,1,0,0,0,0,0,0,'Overlord Drakuru - On data 0 1 set - Say line'),
(-100094,0,2,0,61,1,100,0,0,0,0,0,80,@NPC_OVERLORD_DRAKURU*100,2,0,0,0,0,1,0,0,0,0,0,0,0,'Overlord Drakuru - On data 0 1 set - Say line'),
(-100089,0,0,0,11,0,100,0,0,0,0,0,22,1,0,0,0,0,0,1,0,0,0,0,0,0,0,'Overlord Drakuru - On spawn - Set event phase 1'),
(-100089,0,1,2,38,1,100,0,0,1,0,0,1,6,0,0,0,0,0,12,1,0,0,0,0,0,0,'Overlord Drakuru - On data 0 1 set - Say line'),
(-100089,0,2,0,61,1,100,0,0,0,0,0,80,@NPC_OVERLORD_DRAKURU*100,2,0,0,0,0,1,0,0,0,0,0,0,0,'Overlord Drakuru - On data 0 1 set - Say line'),
(-100091,0,0,0,11,0,100,0,0,0,0,0,22,1,0,0,0,0,0,1,0,0,0,0,0,0,0,'Overlord Drakuru - On spawn - Set event phase 1'),
(-100091,0,1,2,38,1,100,0,0,1,0,0,1,7,0,0,0,0,0,12,1,0,0,0,0,0,0,'Overlord Drakuru - On data 0 1 set - Say line'),
(-100091,0,2,0,61,1,100,0,0,0,0,0,80,@NPC_OVERLORD_DRAKURU*100,2,0,0,0,0,1,0,0,0,0,0,0,0,'Overlord Drakuru - On data 0 1 set - Say line'),
(-100093,0,0,0,11,0,100,0,0,0,0,0,22,1,0,0,0,0,0,1,0,0,0,0,0,0,0,'Overlord Drakuru - On spawn - Set event phase 1'),
(-100093,0,1,2,38,1,100,0,0,1,0,0,1,8,0,0,0,0,0,12,1,0,0,0,0,0,0,'Overlord Drakuru - On data 0 1 set - Say line'),
(-100093,0,2,0,61,1,100,0,0,0,0,0,80,@NPC_OVERLORD_DRAKURU*100,2,0,0,0,0,1,0,0,0,0,0,0,0,'Overlord Drakuru - On data 0 1 set - Say line'),
(@NPC_DRAKURU,0,0,0,62,0,100,0,9731,1,0,0,11,52224,0,0,0,0,0,7,0,0,0,0,0,0,0,'Overlord Drakuru - On gossip select - Spellcast Kill Credit'),
(@NPC_DRAKURU,0,1,0,62,0,100,0,9731,2,0,0,11,52253,0,0,0,0,0,7,0,0,0,0,0,0,0,'Overlord Drakuru - On gossip select - Spellcast Kill Credit'),
(@NPC_DRAKURU,0,2,0,62,0,100,0,9731,3,0,0,11,52355,0,0,0,0,0,7,0,0,0,0,0,0,0,'Overlord Drakuru - On gossip select - Spellcast Quest Complete Credit Credit'),
(@NPC_DRAKURU,0,3,0,62,0,100,0,9731,4,0,0,11,52680,0,0,0,0,0,7,0,0,0,0,0,0,0,'Overlord Drakuru - On gossip select - Spellcast Kill Credit'),
(@NPC_DRAKURU,0,4,0,62,0,100,0,9731,5,0,0,11,52675,0,0,0,0,0,7,0,0,0,0,0,0,0,'Overlord Drakuru - On gossip select - Spellcast Kill Credit'),
(@NPC_STEFAN,0,4,0,62,0,100,0,9709,1,0,0,11,53810,0,0,0,0,0,7,0,0,0,0,0,0,0,'Stefan Vadu - On gossip select - Spellcast Push Ensorceled Choker'),
(@NPC_GOREBAG,0,0,1,62,0,100,0,9732,0,0,0,11,52194,0,0,0,0,0,7,0,0,0,0,0,0,0,'Gorebag - On gossip select - Spellcast Force Cast Summon Gargoyle'),
(@NPC_GOREBAG,0,1,0,61,0,100,0,0,0,0,0,72,0,0,0,0,0,0,7,0,0,0,0,0,0,0,'Gorebag - On gossip select - Close gossip'),
(@NPC_FLYING_FIEND,0,0,1,54,0,100,0,0,0,0,0,11,52191,0,0,0,0,0,1,0,0,0,0,0,0,0,'Flying Fiend - Just summoned - Spellcast Scourge Disguise'),
(@NPC_FLYING_FIEND,0,1,0,61,0,100,0,0,0,0,0,80,@NPC_FLYING_FIEND*100,2,0,0,0,0,1,0,0,0,0,0,0,0,'Flying Fiend - Just summoned - Run script'),
(@NPC_FLYING_FIEND,0,2,0,40,0,100,0,62,@NPC_FLYING_FIEND,0,0,33,28663,0,0,0,0,0,23,0,0,0,0,0,0,0,'Flying Fiend - On WP 62 reached - Quest Credit'),
(@NPC_FLYING_FIEND,0,3,0,40,0,100,0,63,@NPC_FLYING_FIEND,0,0,11,50630,0,0,0,0,0,1,0,0,0,0,0,0,0,'Flying Fiend - On WP 63 reached - Spellcast Eject All Passengers'),
(@NPC_PERSISTENCE,0,0,0,54,0,100,0,0,0,0,0,80,@NPC_PERSISTENCE*100,2,0,0,0,0,1,0,0,0,0,0,0,0,'Persistence - Just summoned - Run script'),
(5056,2,0,1,46,0,100,0,0,0,0,0,64,1,0,0,0,0,0,7,0,0,0,0,0,0,0,'On trigger - Store targetlist'),
(5056,2,1,2,61,0,100,0,0,0,0,0,100,1,0,0,0,0,0,10,100095,@NPC_OVERLORD_DRAKURU,0,0,0,0,0,'On trigger - Send targetlist'),
(5056,2,2,0,61,0,100,0,0,0,0,0,45,0,1,0,0,0,0,10,100095,@NPC_OVERLORD_DRAKURU,0,0,0,0,0,'On trigger - Set data 0 1 Overlord Drakuru'),
(5057,2,0,1,46,0,100,0,0,0,0,0,64,1,0,0,0,0,0,7,0,0,0,0,0,0,0,'On trigger - Store targetlist'),
(5057,2,1,2,61,0,100,0,0,0,0,0,100,1,0,0,0,0,0,10,100092,@NPC_OVERLORD_DRAKURU,0,0,0,0,0,'On trigger - Send targetlist'),
(5057,2,2,0,61,0,100,0,0,0,0,0,45,0,1,0,0,0,0,10,100092,@NPC_OVERLORD_DRAKURU,0,0,0,0,0,'On trigger - Set data 0 1 Overlord Drakuru'),
(5058,2,0,1,46,0,100,0,0,0,0,0,64,1,0,0,0,0,0,7,0,0,0,0,0,0,0,'On trigger - Store targetlist'),
(5058,2,1,2,61,0,100,0,0,0,0,0,100,1,0,0,0,0,0,10,100088,@NPC_OVERLORD_DRAKURU,0,0,0,0,0,'On trigger - Send targetlist'),
(5058,2,2,0,61,0,100,0,0,0,0,0,45,0,1,0,0,0,0,10,100088,@NPC_OVERLORD_DRAKURU,0,0,0,0,0,'On trigger - Set data 0 1 Overlord Drakuru'),
(5059,2,0,1,46,0,100,0,0,0,0,0,64,1,0,0,0,0,0,7,0,0,0,0,0,0,0,'On trigger - Store targetlist'),
(5059,2,1,2,61,0,100,0,0,0,0,0,100,1,0,0,0,0,0,10,@GUID,@NPC_OVERLORD_DRAKURU,0,0,0,0,0,'On trigger - Send targetlist'),
(5059,2,2,0,61,0,100,0,0,0,0,0,45,0,1,0,0,0,0,10,@GUID,@NPC_OVERLORD_DRAKURU,0,0,0,0,0,'On trigger - Set data 0 1 Overlord Drakuru'),
(5060,2,0,1,46,0,100,0,0,0,0,0,64,1,0,0,0,0,0,7,0,0,0,0,0,0,0,'On trigger - Store targetlist'),
(5060,2,1,2,61,0,100,0,0,0,0,0,100,1,0,0,0,0,0,10,100090,@NPC_OVERLORD_DRAKURU,0,0,0,0,0,'On trigger - Send targetlist'),
(5060,2,2,0,61,0,100,0,0,0,0,0,45,0,1,0,0,0,0,10,100090,@NPC_OVERLORD_DRAKURU,0,0,0,0,0,'On trigger - Set data 0 1 Overlord Drakuru'),
(5095,2,0,1,46,0,100,0,0,0,0,0,64,1,0,0,0,0,0,7,0,0,0,0,0,0,0,'On trigger - Store targetlist'),
(5095,2,1,2,61,0,100,0,0,0,0,0,100,1,0,0,0,0,0,10,100094,@NPC_OVERLORD_DRAKURU,0,0,0,0,0,'On trigger - Send targetlist'),
(5095,2,2,0,61,0,100,0,0,0,0,0,45,0,1,0,0,0,0,10,100094,@NPC_OVERLORD_DRAKURU,0,0,0,0,0,'On trigger - Set data 0 1 Overlord Drakuru'),
(5096,2,0,1,46,0,100,0,0,0,0,0,64,1,0,0,0,0,0,7,0,0,0,0,0,0,0,'On trigger - Store targetlist'),
(5096,2,1,2,61,0,100,0,0,0,0,0,100,1,0,0,0,0,0,10,100089,@NPC_OVERLORD_DRAKURU,0,0,0,0,0,'On trigger - Send targetlist'),
(5096,2,2,0,61,0,100,0,0,0,0,0,45,0,1,0,0,0,0,10,100089,@NPC_OVERLORD_DRAKURU,0,0,0,0,0,'On trigger - Set data 0 1 Overlord Drakuru'),
(5097,2,0,1,46,0,100,0,0,0,0,0,64,1,0,0,0,0,0,7,0,0,0,0,0,0,0,'On trigger - Store targetlist'),
(5097,2,1,2,61,0,100,0,0,0,0,0,100,1,0,0,0,0,0,10,100091,@NPC_OVERLORD_DRAKURU,0,0,0,0,0,'On trigger - Send targetlist'),
(5097,2,2,0,61,0,100,0,0,0,0,0,45,0,1,0,0,0,0,10,100091,@NPC_OVERLORD_DRAKURU,0,0,0,0,0,'On trigger - Set data 0 1 Overlord Drakuru'),
(5098,2,0,1,46,0,100,0,0,0,0,0,64,1,0,0,0,0,0,7,0,0,0,0,0,0,0,'On trigger - Store targetlist'),
(5098,2,1,2,61,0,100,0,0,0,0,0,100,1,0,0,0,0,0,10,100093,@NPC_OVERLORD_DRAKURU,0,0,0,0,0,'On trigger - Send targetlist'),
(5098,2,2,0,61,0,100,0,0,0,0,0,45,0,1,0,0,0,0,10,100093,@NPC_OVERLORD_DRAKURU,0,0,0,0,0,'On trigger - Set data 0 1 Overlord Drakuru'),
(@NPC_FLYING_FIEND*100,9,0,0,0,0,100,0,1700,1700,0,0,53,1,@NPC_FLYING_FIEND,0,0,0,0,1,0,0,0,0,0,0,0,'Flying Fiend script - Start WP movement'),
(@NPC_OVERLORD_DRAKURU*100,9,0,0,0,0,100,0,0,0,0,0,22,0,0,0,0,0,0,1,0,0,0,0,0,0,0,'Overlord Drakuru script - Set event phase 0'),
(@NPC_OVERLORD_DRAKURU*100,9,1,0,0,0,100,0,5000,5000,0,0,22,1,0,0,0,0,0,1,0,0,0,0,0,0,0,'Overlord Drakuru script - Set event phase 1'),
(@NPC_PERSISTENCE*100,9,0,0,0,0,100,0,1000,1000,0,0,69,0,0,0,0,0,0,7,0,0,0,0,0,0,0,'Persistence script - Move to position');
DELETE FROM `creature_text` WHERE `entry`=@NPC_OVERLORD_DRAKURU;
INSERT INTO `creature_text` (`entry`,`groupid`,`id`,`text`,`type`,`language`,`probability`,`emote`,`duration`,`sound`,`comment`) VALUES
(@NPC_OVERLORD_DRAKURU,0,0,'A portion of this land already be mine, mon, but it only be da beginning!',15,0,100,0,0,0,''),
(@NPC_OVERLORD_DRAKURU,1,0,'Here, da self-righteous crusaders be standin'' in da way of our goal. Dey will fall!',15,0,100,0,0,0,''),
(@NPC_OVERLORD_DRAKURU,2,0,'Dis all soon gonna belong to da Lich King.',15,0,100,0,0,0,''),
(@NPC_OVERLORD_DRAKURU,3,0,'Da Drakkari be destroyin'' their lands! Dey gunna be losin'' dem... soon, mon.',15,0,100,0,0,0,''),
(@NPC_OVERLORD_DRAKURU,4,0,'Ahh, dere be our destiny... Gundrak!',15,0,100,0,0,0,''),
(@NPC_OVERLORD_DRAKURU,5,0,'Study dis place well, mon. Ya gonna be helpin'' me conquer it!',15,0,100,0,0,0,''),
(@NPC_OVERLORD_DRAKURU,6,0,'Ahh yeah, mon! Dere be great glory ta be had here!',15,0,100,0,0,0,''),
(@NPC_OVERLORD_DRAKURU,7,0,'Da Lich King be sharin'' his power wit dem who serve him well, mon.',15,0,100,0,0,0,''),
(@NPC_OVERLORD_DRAKURU,8,0,'Come to me now, $n. I must be speakin'' wit ya.',15,0,100,0,0,0,'');
DELETE FROM `spell_scripts` WHERE `id`=50630;
INSERT INTO `spell_scripts` (`id`,`effIndex`,`delay`,`command`,`datalong`,`datalong2`,`dataint`,`x`,`y`,`z`,`o`) VALUES
(50630,0,0,14,46598,0,0,0,0,0,0);
DELETE FROM `spell_script_names` WHERE `spell_id`=55368;
INSERT INTO `spell_script_names` (`spell_id`,`ScriptName`) VALUES
(55368,'spell_q12661_q12669_q12676_q12677_q12713_summon_stefan');
DELETE FROM `waypoints` WHERE `entry`=@NPC_FLYING_FIEND;
INSERT INTO `waypoints` (`entry`,`pointid`,`position_x`,`position_y`,`position_z`,`point_comment`) VALUES
(@NPC_FLYING_FIEND,1,6063.744,-2094.859,431.5205,''),
(@NPC_FLYING_FIEND,2,5967.444,-2165.715,422.854,''),
(@NPC_FLYING_FIEND,3,5865.666,-2174.974,393.3817,''),
(@NPC_FLYING_FIEND,4,5713.336,-2151.653,373.4649,''),
(@NPC_FLYING_FIEND,5,5558.722,-2128.131,366.1319,''),
(@NPC_FLYING_FIEND,6,5451.114,-2151.127,354.4373,''),
(@NPC_FLYING_FIEND,7,5377.812,-2219.117,359.1318,''),
(@NPC_FLYING_FIEND,8,5366.704,-2360.862,377.715,''),
(@NPC_FLYING_FIEND,9,5435.392,-2533.554,373.9926,''),
(@NPC_FLYING_FIEND,10,5620.228,-2725.159,344.5209,''),
(@NPC_FLYING_FIEND,11,5710.932,-2849.435,341.9651,''),
(@NPC_FLYING_FIEND,12,5793.25,-3015.15,364.3539,''),
(@NPC_FLYING_FIEND,13,5879.358,-3182.915,393.3817,''),
(@NPC_FLYING_FIEND,14,5964.949,-3300.001,393.3817,''),
(@NPC_FLYING_FIEND,15,6115.404,-3420.539,450.5761,''),
(@NPC_FLYING_FIEND,16,6211.264,-3582.169,481.242,''),
(@NPC_FLYING_FIEND,17,6279.312,-3777.027,504.3809,''),
(@NPC_FLYING_FIEND,18,6463.991,-3861.046,546.2137,''),
(@NPC_FLYING_FIEND,19,6575.966,-4030.918,546.2137,''),
(@NPC_FLYING_FIEND,20,6743.058,-4188.865,546.2137,''),
(@NPC_FLYING_FIEND,21,6896.725,-4247.418,577.3526,''),
(@NPC_FLYING_FIEND,22,6999.448,-4298.92,582.9353,''),
(@NPC_FLYING_FIEND,23,7100.701,-4416.983,611.0741,''),
(@NPC_FLYING_FIEND,24,7116.469,-4555.864,660.6572,''),
(@NPC_FLYING_FIEND,25,7057.505,-4669.796,675.6574,''),
(@NPC_FLYING_FIEND,26,6947.491,-4771.33,660.6572,''),
(@NPC_FLYING_FIEND,27,6758.396,-4783.884,626.5463,''),
(@NPC_FLYING_FIEND,28,6650.223,-4701.149,597.2407,''),
(@NPC_FLYING_FIEND,29,6627.306,-4597.556,586.0188,''),
(@NPC_FLYING_FIEND,30,6613.611,-4439.712,592.6573,''),
(@NPC_FLYING_FIEND,31,6526.06,-4289.037,568.1019,''),
(@NPC_FLYING_FIEND,32,6401.896,-4215.937,538.5742,''),
(@NPC_FLYING_FIEND,33,6286.808,-4191.781,518.3241,''),
(@NPC_FLYING_FIEND,34,6204.36,-4223.743,465.0742,''),
(@NPC_FLYING_FIEND,35,6134.582,-4239.067,386.1299,''),
(@NPC_FLYING_FIEND,36,5995.454,-4246.94,428.5185,''),
(@NPC_FLYING_FIEND,37,5909.651,-4251.924,428.5185,''),
(@NPC_FLYING_FIEND,38,5792.211,-4212.291,428.5185,''),
(@NPC_FLYING_FIEND,39,5656.491,-4115.374,428.5185,''),
(@NPC_FLYING_FIEND,40,5549.697,-3983.661,428.5185,''),
(@NPC_FLYING_FIEND,41,5495.661,-3853.954,428.5185,''),
(@NPC_FLYING_FIEND,42,5463.381,-3751.72,428.5185,''),
(@NPC_FLYING_FIEND,43,5430.445,-3669.375,428.5185,''),
(@NPC_FLYING_FIEND,44,5348.065,-3559.13,406.3796,''),
(@NPC_FLYING_FIEND,45,5240.038,-3418.709,381.4073,''),
(@NPC_FLYING_FIEND,46,5160.26,-3335.475,381.4073,''),
(@NPC_FLYING_FIEND,47,5044.02,-3214.565,381.4073,''),
(@NPC_FLYING_FIEND,48,4994.617,-3163.257,381.4073,''),
(@NPC_FLYING_FIEND,49,4929.424,-3062.172,381.4073,''),
(@NPC_FLYING_FIEND,50,4874.155,-2945.799,381.4073,''),
(@NPC_FLYING_FIEND,51,4892.917,-2768.813,381.4073,''),
(@NPC_FLYING_FIEND,52,5019.182,-2627.008,381.4073,''),
(@NPC_FLYING_FIEND,53,5067.444,-2519.115,381.4073,''),
(@NPC_FLYING_FIEND,54,5081.711,-2367.998,381.4073,''),
(@NPC_FLYING_FIEND,55,5152.338,-2120.359,419.4349,''),
(@NPC_FLYING_FIEND,56,5368.514,-1851.122,422.8514,''),
(@NPC_FLYING_FIEND,57,5660.992,-1784.473,360.5462,''),
(@NPC_FLYING_FIEND,58,5851.7,-1800.855,350.1305,''),
(@NPC_FLYING_FIEND,59,6030.714,-1863.997,348.1571,''),
(@NPC_FLYING_FIEND,60,6103.75,-1910.458,354.3242,''),
(@NPC_FLYING_FIEND,61,6163.79,-1944.525,374.379,''),
(@NPC_FLYING_FIEND,62,6183.492,-1976.164,410.129,''),
(@NPC_FLYING_FIEND,63,6184.051,-1991.26,417.3231,'');
DELETE FROM `vehicle_template_accessory` WHERE `entry` IN (@NPC_FLYING_FIEND,@NPC_PERSISTENCE);
INSERT INTO `vehicle_template_accessory` (`entry`,`accessory_entry`,`seat_id`,`minion`,`description`,`summontype`,`summontimer`) VALUES
(@NPC_FLYING_FIEND,@NPC_OVERLORD_DRAKURU,1,1,'Flying Fiend',8,0),
(@NPC_PERSISTENCE,@NPC_STEFAN,0,1,'Persistence',8,0);
DELETE FROM `npc_spellclick_spells` WHERE `npc_entry` IN (@NPC_FLYING_FIEND,@NPC_PERSISTENCE);
INSERT INTO `npc_spellclick_spells` (`npc_entry`,`spell_id`,`cast_flags`,`user_type`) VALUES
(@NPC_FLYING_FIEND,46598,0,1),
(@NPC_PERSISTENCE,46598,0,1);
UPDATE `quest_template` SET `PrevQuestId`=12649 WHERE `Id`=@QUEST_REUNITED;
UPDATE `quest_template` SET `PrevQuestId`=12648 WHERE `Id`=@QUEST_DARK_HORIZON;
DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId`=14 AND `SourceGroup`=9731 AND `SourceEntry`=13348;
DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId`=19 AND `SourceEntry` IN (@QUEST_REUNITED,@QUEST_DARK_HORIZON);
DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId`=20 AND `SourceEntry` IN (@QUEST_REUNITED,@QUEST_DARK_HORIZON);
DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId`=22 AND `SourceEntry` IN (5056,5057,5058,5059,5060,5095,5096,5097,5098);
INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`SourceId`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`NegativeCondition`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES
(14,9731,13348,0,0,8,12238,0,0,1,0,'','Overlord Drakuru - Show different gossip if player has not rewarded quest Cleansing Drak''Tharon'),
(14,9731,13348,0,0,8,12661,0,0,1,0,'','Overlord Drakuru - Show different gossip if player has not rewarded quest Infiltrating Voltarus'),
(19,0,@QUEST_REUNITED,0,0,9,@QUEST_INFILTRATING_VOLTARUS,0,0,0,0,'','Quest acceptable only if player has taken quest Infiltrating Voltarus'),
(19,0,@QUEST_DARK_HORIZON,0,0,9,@QUEST_INFILTRATING_VOLTARUS,0,0,0,0,'','Quest acceptable only if player has taken quest Infiltrating Voltarus'),
(20,0,@QUEST_REUNITED,0,0,9,@QUEST_INFILTRATING_VOLTARUS,0,0,0,0,'','Show quest mark only if player has taken quest Infiltrating Voltarus'),
(20,0,@QUEST_DARK_HORIZON,0,0,9,@QUEST_INFILTRATING_VOLTARUS,0,0,0,0,'','Show quest mark only if player has taken quest Infiltrating Voltarus'),
(22,1,5056,2,0,9,@QUEST_REUNITED,0,0,0,0,'','SAI triggers only if player has taken quest Reunited'),
(22,1,5056,2,1,9,@QUEST_DARK_HORIZON,0,0,0,0,'','SAI triggers only if player has taken quest Dark Horizon'),
(22,1,5057,2,0,9,@QUEST_REUNITED,0,0,0,0,'','SAI triggers only if player has taken quest Reunited'),
(22,1,5057,2,1,9,@QUEST_DARK_HORIZON,0,0,0,0,'','SAI triggers only if player has taken quest Dark Horizon'),
(22,1,5058,2,0,9,@QUEST_REUNITED,0,0,0,0,'','SAI triggers only if player has taken quest Reunited'),
(22,1,5058,2,1,9,@QUEST_DARK_HORIZON,0,0,0,0,'','SAI triggers only if player has taken quest Dark Horizon'),
(22,1,5059,2,0,9,@QUEST_REUNITED,0,0,0,0,'','SAI triggers only if player has taken quest Reunited'),
(22,1,5059,2,1,9,@QUEST_DARK_HORIZON,0,0,0,0,'','SAI triggers only if player has taken quest Dark Horizon'),
(22,1,5060,2,0,9,@QUEST_REUNITED,0,0,0,0,'','SAI triggers only if player has taken quest Reunited'),
(22,1,5060,2,1,9,@QUEST_DARK_HORIZON,0,0,0,0,'','SAI triggers only if player has taken quest Dark Horizon'),
(22,1,5095,2,0,9,@QUEST_REUNITED,0,0,0,0,'','SAI triggers only if player has taken quest Reunited'),
(22,1,5095,2,1,9,@QUEST_DARK_HORIZON,0,0,0,0,'','SAI triggers only if player has taken quest Dark Horizon'),
(22,1,5096,2,0,9,@QUEST_REUNITED,0,0,0,0,'','SAI triggers only if player has taken quest Reunited'),
(22,1,5096,2,1,9,@QUEST_DARK_HORIZON,0,0,0,0,'','SAI triggers only if player has taken quest Dark Horizon'),
(22,1,5097,2,0,9,@QUEST_REUNITED,0,0,0,0,'','SAI triggers only if player has taken quest Reunited'),
(22,1,5097,2,1,9,@QUEST_DARK_HORIZON,0,0,0,0,'','SAI triggers only if player has taken quest Dark Horizon'),
(22,1,5098,2,0,9,@QUEST_REUNITED,0,0,0,0,'','SAI triggers only if player has taken quest Reunited'),
(22,1,5098,2,1,9,@QUEST_DARK_HORIZON,0,0,0,0,'','SAI triggers only if player has taken quest Dark Horizon');
@@ -0,0 +1,86 @@
-- Add option conditions for Alchemist Finklestein
DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (15) AND `SourceGroup` IN (9668) AND `SourceEntry` IN (0) AND `ConditionValue1` IN (51216);
INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`NegativeCondition`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES
(15,9668,0,1,1,51216,0,0,1,0,'','Alchemist Finklestein - Show gossip option only if player does not have aura 51216');
UPDATE `creature_template` SET `AIName`= '',`ScriptName`= 'npc_alchemist_finklestein' WHERE `entry`=28205;
UPDATE `gameobject_template` SET `ScriptName`= 'go_finklesteins_cauldron' WHERE `entry`=190498;
DELETE FROM `spell_script_names` WHERE `spell_id` IN (51134,51105,51107,51015,51154,51157,51046,51018,51055,51057,
51059,51062,51064,51067,51069,51072,51077,51079,51081,51083,51085,51087,51091,51093,51095,51097,51100,51102);
INSERT INTO `spell_script_names` (`spell_id`,`ScriptName`) VALUES
(51134,'spell_random_ingredient_easy'),
(51105,'spell_random_ingredient_medium'),
(51107,'spell_random_ingredient_hard'),
(51015,'spell_random_ingredient_aura'),
(51154,'spell_random_ingredient_aura'),
(51157,'spell_random_ingredient_aura'),
(51046,'spell_pot_check'),
(51018,'spell_fetch_ingredient_aura'),
(51055,'spell_fetch_ingredient_aura'),
(51057,'spell_fetch_ingredient_aura'),
(51059,'spell_fetch_ingredient_aura'),
(51062,'spell_fetch_ingredient_aura'),
(51064,'spell_fetch_ingredient_aura'),
(51067,'spell_fetch_ingredient_aura'),
(51069,'spell_fetch_ingredient_aura'),
(51072,'spell_fetch_ingredient_aura'),
(51077,'spell_fetch_ingredient_aura'),
(51079,'spell_fetch_ingredient_aura'),
(51081,'spell_fetch_ingredient_aura'),
(51083,'spell_fetch_ingredient_aura'),
(51085,'spell_fetch_ingredient_aura'),
(51087,'spell_fetch_ingredient_aura'),
(51091,'spell_fetch_ingredient_aura'),
(51093,'spell_fetch_ingredient_aura'),
(51095,'spell_fetch_ingredient_aura'),
(51097,'spell_fetch_ingredient_aura'),
(51100,'spell_fetch_ingredient_aura'),
(51102,'spell_fetch_ingredient_aura');
-- Add texts for Alchemist Finklestein
DELETE FROM `creature_text` WHERE `entry`=28205;
INSERT INTO `creature_text` (`entry`,`groupid`,`id`,`text`,`type`,`language`,`probability`,`emote`,`duration`,`sound`,`comment`) VALUES
-- Events 1,2,3
(28205,0,0,'Quickly, get me some...',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,0,1,'I think it needs...',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,0,2,'Find me some...',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,0,3,'It simply must have some...',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,0,4,'We need some...',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,0,5,'It simply must have some...',42,0,100,0,0,0,'Alchemist Finklestein'),
-- Event 4
(28205,1,0,'I think it''s time for...',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,1,1,'Next, we''ll need...',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,1,2,'Tastes like it needs more....',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,1,3,'Alright, now find me some...',42,0,100,0,0,0,'Alchemist Finklestein'),
-- Event 5
(28205,2,0,'Coming along nicely, but still needs...',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,2,1,'Before it thickens, we must add...',42,0,100,0,0,0,'Alchemist Finklestein'),
-- Event 6
(28205,3,0,'Before it boils over, I need...',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,3,1,'It''s thickening! Quickly, get some...',42,0,100,0,0,0,'Alchemist Finklestein'),
-- Fail
(28205,4,0,'You''re too late. I must start again from the beginning....',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,4,1,'No! The serum is ruined!',42,0,100,0,0,0,'Alchemist Finklestein'),
-- Item request
(28205,5,0,'Knotroot!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,6,0,'Pickled Eagle Egg!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,7,0,'Speckled Guano!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,8,0,'Withered Batwing!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,9,0,'Seasoned Slider Cider!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,10,0,'Pulverized Gargoyle Teeth!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,11,0,'Muddy Mire Maggot!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,12,0,'Spiky Spider Egg!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,13,0,'Hairy Herring Head!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,14,0,'Putrid Pirate Perspiration!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,15,0,'Icecrown Bottled Water!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,16,0,'Wasp''s Wings!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,17,0,'Prismatic Mojo!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,18,0,'Raptor Claw!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,19,0,'Amberseed!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,20,0,'Shrunken Dragon''s Claw!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,21,0,'Chilled Serpent Mucus!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,22,0,'Crystallized Hogsnot!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,23,0,'Crushed Basilisk Crystals!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,24,0,'Trollbane!',42,0,100,0,0,0,'Alchemist Finklestein'),
(28205,25,0,'Frozen Spider Ichor!',42,0,100,0,0,0,'Alchemist Finklestein');
@@ -0,0 +1,6 @@
-- Cleaning the database of unused/obsolete data
DELETE FROM `game_event_creature` WHERE `guid` NOT IN (SELECT `guid` FROM `creature`);
DELETE FROM `game_event_gameobject` WHERE `guid` NOT IN (SELECT `guid` FROM `gameobject`);
DELETE FROM `pool_pool` WHERE `mother_pool` NOT IN (SELECT `entry` FROM `pool_template`);
DELETE FROM `game_event_creature` WHERE `guid` IN (40267,40470,40471);
DELETE FROM `creature` WHERE `id` = 18963; -- Removed from game arround wow 2.2.x
@@ -0,0 +1,4 @@
-- Cleaning the database of unused/obsolete data
DELETE FROM `creature` WHERE `map` IN (449,450);
DELETE FROM `creature_loot_template` WHERE `entry` IN (16156,16157,16158,16368,16446,16448,16449,16451,16452);
UPDATE `creature_template` SET `lootid`=0 WHERE `entry` IN (16156,16157,16158,16368,16446,16448,16449,16451,16452);
@@ -0,0 +1,3 @@
-- Part fix for NPC Hut Fire for Quest: This Just In: Fire Still Hot!
UPDATE `creature` SET `modelid`=0,`spawndist`=0,`MovementType`=0 WHERE `id`=29692;
UPDATE `creature_template` SET `InhabitType`=4, `flags_extra`=128 WHERE `entry`=29692;
@@ -0,0 +1,7 @@
-- Hut Fire SAI Quest: This Just In: Fire Still Hot! "Now looks more like Offi"
SET @ENTRY := 29692;
UPDATE `creature_template` SET `AIName`= 'SmartAI',`ScriptName`= '' WHERE `entry`=@ENTRY;
DELETE FROM `smart_scripts` WHERE `source_type`=0 AND `entryorguid`=@ENTRY;
INSERT INTO `smart_scripts` (`entryorguid`,`source_type`,`id`,`link`,`event_type`,`event_phase_mask`,`event_chance`,`event_flags`,`event_param1`,`event_param2`,`event_param3`,`event_param4`,`action_type`,`action_param1`,`action_param2`,`action_param3`,`action_param4`,`action_param5`,`action_param6`,`target_type`,`target_param1`,`target_param2`,`target_param3`,`target_x`,`target_y`,`target_z`,`target_o`,`comment`) VALUES
(@ENTRY,0,0,0,1,0,100,0,1000,1000,59000,59000,11,55049,0,0,0,0,0,1,0,0,0,0,0,0,0, 'Hut Fire - OOC - Cast Torch on Self'),
(@ENTRY,0,1,0,8,0,100,0,55037,0,0,0,41,0,0,0,0,0,0,1,0,0,0,0,0,0,0, 'Hut Fire - On Spell Hit - Despawn');
@@ -0,0 +1,5 @@
DELETE FROM `spell_script_names` WHERE `spell_id` IN (51134,51105,51107);
INSERT INTO `spell_script_names` (`spell_id`,`ScriptName`) VALUES
(51134,'spell_random_ingredient'),
(51105,'spell_random_ingredient'),
(51107,'spell_random_ingredient');
+1 -1
View File
@@ -17,7 +17,7 @@ if(CMAKE_COMPILER_IS_GNUCXX AND NOT MINGW)
endif()
if( SERVERS )
set(sources_Debugging
set(sources_windows_Debugging
${CMAKE_SOURCE_DIR}/src/server/shared/Debugging/WheatyExceptionReport.cpp
${CMAKE_SOURCE_DIR}/src/server/shared/Debugging/WheatyExceptionReport.h
)
+5 -7
View File
@@ -29,16 +29,14 @@ set(authserver_SRCS
)
if( WIN32 )
set(authserver_SRCS
${authserver_SRCS}
${sources_windows_Debugging}
)
if ( MSVC )
set(authserver_SRCS
${authserver_SRCS}
${sources_Debugging}
authserver.rc
)
else ( )
set(authserver_SRCS
${authserver_SRCS}
${sources_Debugging}
authserver.rc
)
endif ()
endif()
@@ -63,7 +63,7 @@ namespace MMAP
dtNavMesh* mesh = dtAllocNavMesh();
ASSERT(mesh);
if (DT_SUCCESS != mesh->init(&params))
if (dtStatusFailed(mesh->init(&params)))
{
dtFreeNavMesh(mesh);
TC_LOG_ERROR(LOG_FILTER_MAPS, "MMAP:loadMapData: Failed to initialize dtNavMesh for mmap %03u from file %s", mapId, fileName);
@@ -152,7 +152,7 @@ namespace MMAP
dtTileRef tileRef = 0;
// memory allocated for data is now managed by detour, and will be deallocated when the tile is removed
if (DT_SUCCESS == mmap->navMesh->addTile(data, fileHeader.size, DT_TILE_FREE_DATA, 0, &tileRef))
if (dtStatusSucceed(mmap->navMesh->addTile(data, fileHeader.size, DT_TILE_FREE_DATA, 0, &tileRef)))
{
mmap->mmapLoadedTiles.insert(std::pair<uint32, dtTileRef>(packedGridPos, tileRef));
++loadedTiles;
@@ -193,7 +193,7 @@ namespace MMAP
dtTileRef tileRef = mmap->mmapLoadedTiles[packedGridPos];
// unload, and mark as non loaded
if (DT_SUCCESS != mmap->navMesh->removeTile(tileRef, NULL, NULL))
if (dtStatusFailed(mmap->navMesh->removeTile(tileRef, NULL, NULL)))
{
// this is technically a memory leak
// if the grid is later reloaded, dtNavMesh::addTile will return error but no extra memory is used
@@ -227,7 +227,7 @@ namespace MMAP
{
uint32 x = (i->first >> 16);
uint32 y = (i->first & 0x0000FFFF);
if (DT_SUCCESS != mmap->navMesh->removeTile(i->second, NULL, NULL))
if (dtStatusFailed(mmap->navMesh->removeTile(i->second, NULL, NULL)))
TC_LOG_ERROR(LOG_FILTER_MAPS, "MMAP:unloadMap: Could not unload %03u%02i%02i.mmtile from navmesh", mapId, x, y);
else
{
@@ -288,7 +288,7 @@ namespace MMAP
// allocate mesh query
dtNavMeshQuery* query = dtAllocNavMeshQuery();
ASSERT(query);
if (DT_SUCCESS != query->init(mmap->navMesh, 1024))
if (dtStatusFailed(query->init(mmap->navMesh, 1024)))
{
dtFreeNavMeshQuery(query);
TC_LOG_ERROR(LOG_FILTER_MAPS, "MMAP:GetNavMeshQuery: Failed to initialize dtNavMeshQuery for mapId %03u instanceId %u", mapId, instanceId);
+2 -11
View File
@@ -724,27 +724,18 @@ uint64 SmartAI::GetGUID(int32 /*id*/) const
void SmartAI::SetRun(bool run)
{
if (run)
me->SetWalk(false);
else
me->SetWalk(true);
me->SetWalk(!run);
mRun = run;
}
void SmartAI::SetFly(bool fly)
{
me->SetDisableGravity(fly);
me->SendMovementDisableGravity();
}
void SmartAI::SetSwim(bool swim)
{
if (swim)
me->AddUnitMovementFlag(MOVEMENTFLAG_SWIMMING);
else
me->RemoveUnitMovementFlag(MOVEMENTFLAG_SWIMMING);
me->SendMovementSwimming();
me->SetSwim(swim);
}
void SmartAI::sGossipHello(Player* player)
@@ -101,10 +101,10 @@ void BattlegroundIC::DoAction(uint32 action, uint64 var)
player->SetTransport(player->GetTeamId() == TEAM_ALLIANCE ? gunshipAlliance : gunshipHorde);
player->m_movementInfo.t_pos.m_positionX = TransportMovementInfo.GetPositionX();
player->m_movementInfo.t_pos.m_positionY = TransportMovementInfo.GetPositionY();
player->m_movementInfo.t_pos.m_positionZ = TransportMovementInfo.GetPositionZ();
player->m_movementInfo.t_guid = (player->GetTeamId() == TEAM_ALLIANCE ? gunshipAlliance : gunshipHorde)->GetGUID();
player->m_movementInfo.transport.pos.m_positionX = TransportMovementInfo.GetPositionX();
player->m_movementInfo.transport.pos.m_positionY = TransportMovementInfo.GetPositionY();
player->m_movementInfo.transport.pos.m_positionZ = TransportMovementInfo.GetPositionZ();
player->m_movementInfo.transport.guid = (player->GetTeamId() == TEAM_ALLIANCE ? gunshipAlliance : gunshipHorde)->GetGUID();
if (player->TeleportTo(GetMapId(), TeleportToTransportPosition.GetPositionX(),
TeleportToTransportPosition.GetPositionY(),
+1 -51
View File
@@ -2416,53 +2416,6 @@ bool Creature::IsDungeonBoss() const
return cinfo && (cinfo->flags_extra & CREATURE_FLAG_EXTRA_DUNGEON_BOSS);
}
bool Creature::SetWalk(bool enable)
{
if (!Unit::SetWalk(enable))
return false;
if (!movespline->Initialized())
return true;
SendMovementWalkMode();
return true;
}
bool Creature::SetDisableGravity(bool disable, bool packetOnly/*=false*/)
{
//! It's possible only a packet is sent but moveflags are not updated
//! Need more research on this
if (!packetOnly && !Unit::SetDisableGravity(disable))
return false;
if (!movespline->Initialized())
return true;
SendMovementDisableGravity();
return true;
}
bool Creature::SetHover(bool enable)
{
if (!Unit::SetHover(enable))
return false;
//! Unconfirmed for players:
if (enable)
SetByteFlag(UNIT_FIELD_BYTES_1, 3, UNIT_BYTE1_FLAG_HOVER);
else
RemoveByteFlag(UNIT_FIELD_BYTES_1, 3, UNIT_BYTE1_FLAG_HOVER);
if (!movespline->Initialized())
return true;
// If creature hovers using aura, the hover movement opcode is sent from aura handler
if (!HasAuraType(SPELL_AURA_HOVER))
SendMovementHover();
return true;
}
float Creature::GetAggroRange(Unit const* target) const
{
// Determines the aggro range for creatures (usually pets), used mainly for aggressive pet target selection.
@@ -2549,10 +2502,7 @@ void Creature::UpdateMovementFlags()
SetDisableGravity(false);
}
if (GetCreatureTemplate()->InhabitType & INHABIT_WATER && IsInWater())
AddUnitMovementFlag(MOVEMENTFLAG_SWIMMING);
else
RemoveUnitMovementFlag(MOVEMENTFLAG_SWIMMING);
SetSwim(GetCreatureTemplate()->InhabitType & INHABIT_WATER && IsInWater());
}
void Creature::SetObjectScale(float scale)
@@ -503,10 +503,6 @@ class Creature : public Unit, public GridObject<Creature>, public MapCreature
CreatureAI* AI() const { return (CreatureAI*)i_AI; }
bool SetWalk(bool enable);
bool SetDisableGravity(bool disable, bool packetOnly = false);
bool SetHover(bool enable);
SpellSchoolMask GetMeleeDamageSchoolMask() const { return m_meleeDamageSchoolMask; }
void SetMeleeDamageSchool(SpellSchools school) { m_meleeDamageSchoolMask = SpellSchoolMask(1 << school); }
@@ -17,22 +17,22 @@
*/
#include "GameObjectAI.h"
#include "ObjectMgr.h"
#include "GroupMgr.h"
#include "PoolMgr.h"
#include "SpellMgr.h"
#include "World.h"
#include "GridNotifiersImpl.h"
#include "CellImpl.h"
#include "OutdoorPvPMgr.h"
#include "BattlegroundAV.h"
#include "ScriptMgr.h"
#include "CellImpl.h"
#include "CreatureAISelector.h"
#include "Group.h"
#include "MapManager.h"
#include "GameObjectModel.h"
#include "DynamicTree.h"
#include "GameObjectModel.h"
#include "GridNotifiersImpl.h"
#include "Group.h"
#include "GroupMgr.h"
#include "ObjectMgr.h"
#include "OutdoorPvPMgr.h"
#include "PoolMgr.h"
#include "ScriptMgr.h"
#include "SpellMgr.h"
#include "UpdateFieldFlags.h"
#include "World.h"
#include "MapManager.h"
GameObject::GameObject(): WorldObject(false), m_model(NULL), m_goValue(), m_AI(NULL)
{
m_objectType |= TYPEMASK_GAMEOBJECT;
@@ -2084,3 +2084,71 @@ bool GameObject::IsLootAllowedFor(Player const* player) const
return true;
}
void GameObject::BuildValuesUpdate(uint8 updateType, ByteBuffer* data, Player* target) const
{
if (!target)
return;
bool forcedFlags = GetGoType() == GAMEOBJECT_TYPE_CHEST && GetGOInfo()->chest.groupLootRules && HasLootRecipient();
bool targetIsGM = target->IsGameMaster();
ByteBuffer fieldBuffer;
UpdateMask updateMask;
updateMask.SetCount(m_valuesCount);
uint32* flags = GameObjectUpdateFieldFlags;
uint32 visibleFlag = UF_FLAG_PUBLIC;
if (GetOwnerGUID() == target->GetGUID())
visibleFlag |= UF_FLAG_OWNER;
for (uint16 index = 0; index < m_valuesCount; ++index)
{
if (_fieldNotifyFlags & flags[index] ||
((updateType == UPDATETYPE_VALUES ? _changesMask.GetBit(index) : m_uint32Values[index]) && (flags[index] & visibleFlag)) ||
(index == GAMEOBJECT_FLAGS && forcedFlags))
{
updateMask.SetBit(index);
if (index == GAMEOBJECT_DYNAMIC)
{
uint16 dynFlags = 0;
switch (GetGoType())
{
case GAMEOBJECT_TYPE_CHEST:
case GAMEOBJECT_TYPE_GOOBER:
if (ActivateToQuest(target))
dynFlags |= GO_DYNFLAG_LO_ACTIVATE | GO_DYNFLAG_LO_SPARKLE;
else if (targetIsGM)
dynFlags |= GO_DYNFLAG_LO_ACTIVATE;
break;
case GAMEOBJECT_TYPE_GENERIC:
if (ActivateToQuest(target))
dynFlags |= GO_DYNFLAG_LO_SPARKLE;
break;
default:
break;
}
fieldBuffer << uint16(dynFlags);
fieldBuffer << uint16(-1);
}
else if (index == GAMEOBJECT_FLAGS)
{
uint32 flags = m_uint32Values[GAMEOBJECT_FLAGS];
if (GetGoType() == GAMEOBJECT_TYPE_CHEST)
if (GetGOInfo()->chest.groupLootRules && !IsLootAllowedFor(target))
flags |= GO_FLAG_LOCKED | GO_FLAG_NOT_SELECTABLE;
fieldBuffer << flags;
}
else
fieldBuffer << m_uint32Values[index]; // other cases
}
}
*data << uint8(updateMask.GetBlockCount());
updateMask.AppendToPacket(data);
data->append(fieldBuffer);
}
@@ -624,6 +624,8 @@ class GameObject : public WorldObject, public GridObject<GameObject>
explicit GameObject();
~GameObject();
void BuildValuesUpdate(uint8 updatetype, ByteBuffer* data, Player* target) const;
void AddToWorld();
void RemoveFromWorld();
void CleanupsBeforeDelete(bool finalCleanup = true);
+46 -340
View File
@@ -251,12 +251,8 @@ void Object::BuildCreateUpdateBlockForPlayer(UpdateData* data, Player* target) c
buf.append(GetPackGUID());
buf << uint8(m_objectTypeId);
_BuildMovementUpdate(&buf, flags);
UpdateMask updateMask;
updateMask.SetCount(valCount);
_SetCreateBits(&updateMask, target);
_BuildValuesUpdate(updateType, &buf, &updateMask, target);
BuildMovementUpdate(&buf, flags);
BuildValuesUpdate(updateType, &buf, target);
data->AddUpdateBlock(buf);
}
@@ -278,15 +274,7 @@ void Object::BuildValuesUpdateBlockForPlayer(UpdateData* data, Player* target) c
buf << uint8(UPDATETYPE_VALUES);
buf.append(GetPackGUID());
UpdateMask updateMask;
uint32 valCount = m_valuesCount;
if (GetTypeId() == TYPEID_PLAYER && target != this)
valCount = PLAYER_END_NOT_SELF;
updateMask.SetCount(valCount);
_SetUpdateBits(&updateMask, target);
_BuildValuesUpdate(UPDATETYPE_VALUES, &buf, &updateMask, target);
BuildValuesUpdate(UPDATETYPE_VALUES, &buf, target);
data->AddUpdateBlock(buf);
}
@@ -359,7 +347,7 @@ uint16 Object::GetUInt16Value(uint16 index, uint8 offset) const
return *(((uint16*)&m_uint32Values[index])+offset);
}
void Object::_BuildMovementUpdate(ByteBuffer* data, uint16 flags) const
void Object::BuildMovementUpdate(ByteBuffer* data, uint16 flags) const
{
Unit const* self = NULL;
ObjectGuid guid = GetGUID();
@@ -434,12 +422,12 @@ void Object::_BuildMovementUpdate(ByteBuffer* data, uint16 flags) const
data->WriteBit(hasFallData); // Has fall data
data->WriteBit(!hasSplineElevation); // Has spline elevation
data->WriteBit(guid[5]);
data->WriteBit(self->m_movementInfo.t_guid); // Has transport data
data->WriteBit(self->m_movementInfo.transport.guid); // Has transport data
data->WriteBit(0); // Is missing time
if (self->m_movementInfo.t_guid)
if (self->m_movementInfo.transport.guid)
{
ObjectGuid transGuid = self->m_movementInfo.t_guid;
ObjectGuid transGuid = self->m_movementInfo.transport.guid;
data->WriteBit(transGuid[1]);
data->WriteBit(hasTransportTime2); // Has transport time 2
@@ -473,7 +461,7 @@ void Object::_BuildMovementUpdate(ByteBuffer* data, uint16 flags) const
if (flags & UPDATEFLAG_GO_TRANSPORT_POSITION)
{
WorldObject const* self = static_cast<WorldObject const*>(this);
ObjectGuid transGuid = self->m_movementInfo.t_guid;
ObjectGuid transGuid = self->m_movementInfo.transport.guid;
data->WriteBit(transGuid[5]);
data->WriteBit(0); // Has GO transport time 3
data->WriteBit(transGuid[0]);
@@ -521,13 +509,13 @@ void Object::_BuildMovementUpdate(ByteBuffer* data, uint16 flags) const
{
if (hasFallDirection)
{
*data << float(self->m_movementInfo.j_cosAngle);
*data << float(self->m_movementInfo.j_xyspeed);
*data << float(self->m_movementInfo.j_sinAngle);
*data << float(self->m_movementInfo.jump.cosAngle);
*data << float(self->m_movementInfo.jump.xyspeed);
*data << float(self->m_movementInfo.jump.sinAngle);
}
*data << uint32(self->m_movementInfo.fallTime);
*data << float(self->m_movementInfo.j_zspeed);
*data << uint32(self->m_movementInfo.jump.fallTime);
*data << float(self->m_movementInfo.jump.zspeed);
}
*data << self->GetSpeed(MOVE_SWIM_BACK);
@@ -540,16 +528,16 @@ void Object::_BuildMovementUpdate(ByteBuffer* data, uint16 flags) const
*data << float(self->GetPositionZMinusOffset());
data->WriteByteSeq(guid[5]);
if (self->m_movementInfo.t_guid)
if (self->m_movementInfo.transport.guid)
{
ObjectGuid transGuid = self->m_movementInfo.t_guid;
ObjectGuid transGuid = self->m_movementInfo.transport.guid;
data->WriteByteSeq(transGuid[5]);
data->WriteByteSeq(transGuid[7]);
*data << uint32(self->GetTransTime());
*data << float(self->GetTransOffsetO());
if (hasTransportTime2)
*data << uint32(self->m_movementInfo.t_time2);
*data << uint32(self->m_movementInfo.transport.time2);
*data << float(self->GetTransOffsetY());
*data << float(self->GetTransOffsetX());
@@ -557,7 +545,7 @@ void Object::_BuildMovementUpdate(ByteBuffer* data, uint16 flags) const
*data << float(self->GetTransOffsetZ());
data->WriteByteSeq(transGuid[0]);
if (hasTransportTime3)
*data << uint32(self->m_movementInfo.t_time3);
*data << uint32(self->m_movementInfo.transport.time3);
*data << int8(self->GetTransSeat());
data->WriteByteSeq(transGuid[1]);
@@ -602,12 +590,12 @@ void Object::_BuildMovementUpdate(ByteBuffer* data, uint16 flags) const
if (flags & UPDATEFLAG_GO_TRANSPORT_POSITION)
{
WorldObject const* self = static_cast<WorldObject const*>(this);
ObjectGuid transGuid = self->m_movementInfo.t_guid;
ObjectGuid transGuid = self->m_movementInfo.transport.guid;
data->WriteBit(transGuid[0]);
data->WriteBit(transGuid[5]);
if (hasTransportTime3)
*data << uint32(self->m_movementInfo.t_time3);
*data << uint32(self->m_movementInfo.transport.time3);
data->WriteBit(transGuid[3]);
*data << float(self->GetTransOffsetX());
@@ -622,7 +610,7 @@ void Object::_BuildMovementUpdate(ByteBuffer* data, uint16 flags) const
*data << int8(self->GetTransSeat());
*data << float(self->GetTransOffsetO());
if (hasTransportTime2)
*data << uint32(self->m_movementInfo.t_time2);
*data << uint32(self->m_movementInfo.transport.time2);
}
if (flags & UPDATEFLAG_ROTATION)
@@ -688,286 +676,31 @@ void Object::_BuildMovementUpdate(ByteBuffer* data, uint16 flags) const
*data << uint32(getMSTime()); // Unknown - getMSTime is wrong.
}
void Object::_BuildValuesUpdate(uint8 updateType, ByteBuffer* data, UpdateMask* updateMask, Player* target) const
void Object::BuildValuesUpdate(uint8 updateType, ByteBuffer* data, Player* target) const
{
if (!target)
return;
bool IsActivateToQuest = false;
ByteBuffer fieldBuffer;
UpdateMask updateMask;
updateMask.SetCount(m_valuesCount);
// Before trying to convert to each type there is a check, so safe
Unit const* unit = ToUnit();
GameObject const* go = ToGameObject();
uint32* flags = NULL;
uint32 visibleFlag = GetUpdateFieldData(target, flags);
if (unit)
for (uint16 index = 0; index < m_valuesCount; ++index)
{
if (unit->HasFlag(UNIT_FIELD_AURASTATE, PER_CASTER_AURA_STATE_MASK))
updateMask->SetBit(UNIT_FIELD_AURASTATE);
}
else if (go)
{
if (updateType == UPDATETYPE_CREATE_OBJECT || updateType == UPDATETYPE_CREATE_OBJECT2)
if (_fieldNotifyFlags & flags[index] ||
((updateType == UPDATETYPE_VALUES ? _changesMask.GetBit(index) : m_uint32Values[index]) && (flags[index] & visibleFlag)))
{
if (!go->IsDynTransport())
{
if (go->ActivateToQuest(target) || target->IsGameMaster())
IsActivateToQuest = true;
if (go->GetGoArtKit())
updateMask->SetBit(GAMEOBJECT_BYTES_1);
}
}
else
{
if (!go->IsTransport())
{
if (go->ActivateToQuest(target) || target->IsGameMaster())
IsActivateToQuest = true;
updateMask->SetBit(GAMEOBJECT_BYTES_1);
if (go->GetGoType() == GAMEOBJECT_TYPE_CHEST && go->GetGOInfo()->chest.groupLootRules &&
go->HasLootRecipient())
{
updateMask->SetBit(GAMEOBJECT_FLAGS);
}
}
updateMask.SetBit(index);
fieldBuffer << m_uint32Values[index];
}
}
uint32 valCount = m_valuesCount;
if (GetTypeId() == TYPEID_PLAYER && target != this)
valCount = PLAYER_END_NOT_SELF;
ASSERT(updateMask && updateMask->GetCount() == valCount);
*data << uint8(updateMask->GetBlockCount());
updateMask->AppendToPacket(data);
// 2 specialized loops for speed optimization in non-unit case
if (unit) // unit (creature/player) case
{
Creature const* creature = ToCreature();
for (uint16 index = 0; index < valCount; ++index)
{
if (updateMask->GetBit(index))
{
if (index == UNIT_NPC_FLAGS)
{
// remove custom flag before sending
uint32 appendValue = m_uint32Values[index];
if (GetTypeId() == TYPEID_UNIT)
{
if (!target->CanSeeSpellClickOn(this->ToCreature()))
appendValue &= ~UNIT_NPC_FLAG_SPELLCLICK;
}
*data << uint32(appendValue);
}
else if (index == UNIT_FIELD_AURASTATE)
{
// Check per caster aura states to not enable using a spell in client if specified aura is not by target
*data << unit->BuildAuraStateUpdateForTarget(target);
}
// FIXME: Some values at server stored in float format but must be sent to client in uint32 format
else if (index >= UNIT_FIELD_BASEATTACKTIME && index <= UNIT_FIELD_RANGEDATTACKTIME)
{
// convert from float to uint32 and send
*data << uint32(m_floatValues[index] < 0 ? 0 : m_floatValues[index]);
}
// there are some float values which may be negative or can't get negative due to other checks
else if ((index >= UNIT_FIELD_NEGSTAT0 && index <= UNIT_FIELD_NEGSTAT4) ||
(index >= UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE && index <= (UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE + 6)) ||
(index >= UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE && index <= (UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE + 6)) ||
(index >= UNIT_FIELD_POSSTAT0 && index <= UNIT_FIELD_POSSTAT4))
{
*data << uint32(m_floatValues[index]);
}
// Gamemasters should be always able to select units - remove not selectable flag
else if (index == UNIT_FIELD_FLAGS)
{
if (target->IsGameMaster())
*data << (m_uint32Values[index] & ~UNIT_FLAG_NOT_SELECTABLE);
else
*data << m_uint32Values[index];
}
// use modelid_a if not gm, _h if gm for CREATURE_FLAG_EXTRA_TRIGGER creatures
else if (index == UNIT_FIELD_DISPLAYID)
{
if (GetTypeId() == TYPEID_UNIT)
{
CreatureTemplate const* cinfo = creature->GetCreatureTemplate();
// this also applies for transform auras
if (SpellInfo const* transform = sSpellMgr->GetSpellInfo(ToUnit()->getTransForm()))
for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
if (transform->Effects[i].IsAura(SPELL_AURA_TRANSFORM))
if (CreatureTemplate const* transformInfo = sObjectMgr->GetCreatureTemplate(transform->Effects[i].MiscValue))
{
cinfo = transformInfo;
break;
}
if (cinfo->flags_extra & CREATURE_FLAG_EXTRA_TRIGGER)
{
if (target->IsGameMaster())
{
if (cinfo->Modelid1)
*data << cinfo->Modelid1;//Modelid1 is a visible model for gms
else
*data << 17519; // world invisible trigger's model
}
else
{
if (cinfo->Modelid2)
*data << cinfo->Modelid2;//Modelid2 is an invisible model for players
else
*data << 11686; // world invisible trigger's model
}
}
else
*data << m_uint32Values[index];
}
else
*data << m_uint32Values[index];
}
// hide lootable animation for unallowed players
else if (index == UNIT_DYNAMIC_FLAGS)
{
uint32 dynamicFlags = m_uint32Values[index];
if (creature)
{
if (creature->hasLootRecipient())
{
if (creature->isTappedBy(target))
{
dynamicFlags |= (UNIT_DYNFLAG_TAPPED | UNIT_DYNFLAG_TAPPED_BY_PLAYER);
}
else
{
dynamicFlags |= UNIT_DYNFLAG_TAPPED;
dynamicFlags &= ~UNIT_DYNFLAG_TAPPED_BY_PLAYER;
}
}
else
{
dynamicFlags &= ~UNIT_DYNFLAG_TAPPED;
dynamicFlags &= ~UNIT_DYNFLAG_TAPPED_BY_PLAYER;
}
if (!target->isAllowedToLoot(creature))
dynamicFlags &= ~UNIT_DYNFLAG_LOOTABLE;
}
// unit UNIT_DYNFLAG_TRACK_UNIT should only be sent to caster of SPELL_AURA_MOD_STALKED auras
if (dynamicFlags & UNIT_DYNFLAG_TRACK_UNIT)
if (!unit->HasAuraTypeWithCaster(SPELL_AURA_MOD_STALKED, target->GetGUID()))
dynamicFlags &= ~UNIT_DYNFLAG_TRACK_UNIT;
*data << dynamicFlags;
}
// FG: pretend that OTHER players in own group are friendly ("blue")
else if (index == UNIT_FIELD_BYTES_2 || index == UNIT_FIELD_FACTIONTEMPLATE)
{
if (unit->IsControlledByPlayer() && target != this && sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GROUP) && unit->IsInRaidWith(target))
{
FactionTemplateEntry const* ft1 = unit->GetFactionTemplateEntry();
FactionTemplateEntry const* ft2 = target->GetFactionTemplateEntry();
if (ft1 && ft2 && !ft1->IsFriendlyTo(*ft2))
{
if (index == UNIT_FIELD_BYTES_2)
{
// Allow targetting opposite faction in party when enabled in config
*data << (m_uint32Values[index] & ((UNIT_BYTE2_FLAG_SANCTUARY /*| UNIT_BYTE2_FLAG_AURAS | UNIT_BYTE2_FLAG_UNK5*/) << 8)); // this flag is at uint8 offset 1 !!
}
else
{
// pretend that all other HOSTILE players have own faction, to allow follow, heal, rezz (trade wont work)
uint32 faction = target->getFaction();
*data << uint32(faction);
}
}
else
*data << m_uint32Values[index];
}
else
*data << m_uint32Values[index];
}
else
{
// send in current format (float as float, uint32 as uint32)
*data << m_uint32Values[index];
}
}
}
}
else if (go) // gameobject case
{
for (uint16 index = 0; index < valCount; ++index)
{
if (updateMask->GetBit(index))
{
// send in current format (float as float, uint32 as uint32)
if (index == GAMEOBJECT_DYNAMIC)
{
if (IsActivateToQuest)
{
switch (go->GetGoType())
{
case GAMEOBJECT_TYPE_CHEST:
if (target->IsGameMaster())
*data << uint16(GO_DYNFLAG_LO_ACTIVATE);
else
*data << uint16(GO_DYNFLAG_LO_ACTIVATE | GO_DYNFLAG_LO_SPARKLE);
break;
case GAMEOBJECT_TYPE_GENERIC:
if (target->IsGameMaster())
*data << uint16(0);
else
*data << uint16(GO_DYNFLAG_LO_SPARKLE);
break;
case GAMEOBJECT_TYPE_GOOBER:
if (target->IsGameMaster())
*data << uint16(GO_DYNFLAG_LO_ACTIVATE);
else
*data << uint16(GO_DYNFLAG_LO_ACTIVATE | GO_DYNFLAG_LO_SPARKLE);
break;
default:
*data << uint16(0); // unknown, not happen.
break;
}
}
else
*data << uint16(0); // disable quest object
*data << uint16(-1);
}
else if (index == GAMEOBJECT_FLAGS)
{
uint32 flags = m_uint32Values[index];
if (go->GetGoType() == GAMEOBJECT_TYPE_CHEST)
if (go->GetGOInfo()->chest.groupLootRules && !go->IsLootAllowedFor(target))
flags |= GO_FLAG_LOCKED | GO_FLAG_NOT_SELECTABLE;
*data << flags;
}
else
*data << m_uint32Values[index]; // other cases
}
}
}
else // other objects case (no special index checks)
{
for (uint16 index = 0; index < valCount; ++index)
{
if (updateMask->GetBit(index))
{
// send in current format (float as float, uint32 as uint32)
*data << m_uint32Values[index];
}
}
}
*data << uint8(updateMask.GetBlockCount());
updateMask.AppendToPacket(data);
data->append(fieldBuffer);
}
void Object::ClearUpdateMask(bool remove)
@@ -1069,33 +802,6 @@ void Object::_LoadIntoDataField(std::string const& data, uint32 startOffset, uin
}
}
void Object::_SetUpdateBits(UpdateMask* updateMask, Player* target) const
{
uint32* flags = NULL;
uint32 visibleFlag = GetUpdateFieldData(target, flags);
uint32 valCount = m_valuesCount;
if (GetTypeId() == TYPEID_PLAYER && target != this)
valCount = PLAYER_END_NOT_SELF;
for (uint16 index = 0; index < valCount; ++index)
if (_fieldNotifyFlags & flags[index] || ((flags[index] & visibleFlag) & UF_FLAG_SPECIAL_INFO) || (_changesMask.GetBit(index) && (flags[index] & visibleFlag)))
updateMask->SetBit(index);
}
void Object::_SetCreateBits(UpdateMask* updateMask, Player* target) const
{
uint32* value = m_uint32Values;
uint32* flags = NULL;
uint32 visibleFlag = GetUpdateFieldData(target, flags);
uint32 valCount = m_valuesCount;
if (GetTypeId() == TYPEID_PLAYER && target != this)
valCount = PLAYER_END_NOT_SELF;
for (uint16 index = 0; index < valCount; ++index, ++value)
if (_fieldNotifyFlags & flags[index] || ((flags[index] & visibleFlag) & UF_FLAG_SPECIAL_INFO) || (*value && (flags[index] & visibleFlag)))
updateMask->SetBit(index);
}
void Object::SetInt32Value(uint16 index, int32 value)
{
ASSERT(index < m_valuesCount || PrintIndexError(index, true));
@@ -1546,17 +1252,17 @@ void MovementInfo::OutDebug()
TC_LOG_INFO(LOG_FILTER_GENERAL, "flags2 %s (%u)", Movement::MovementFlagsExtra_ToString(flags2).c_str(), flags2);
TC_LOG_INFO(LOG_FILTER_GENERAL, "time %u current time %u", time, getMSTime());
TC_LOG_INFO(LOG_FILTER_GENERAL, "position: `%s`", pos.ToString().c_str());
if (t_guid)
if (transport.guid)
{
TC_LOG_INFO(LOG_FILTER_GENERAL, "TRANSPORT:");
TC_LOG_INFO(LOG_FILTER_GENERAL, "guid: " UI64FMTD, t_guid);
TC_LOG_INFO(LOG_FILTER_GENERAL, "position: `%s`", t_pos.ToString().c_str());
TC_LOG_INFO(LOG_FILTER_GENERAL, "seat: %i", t_seat);
TC_LOG_INFO(LOG_FILTER_GENERAL, "time: %u", t_time);
TC_LOG_INFO(LOG_FILTER_GENERAL, "guid: " UI64FMTD, transport.guid);
TC_LOG_INFO(LOG_FILTER_GENERAL, "position: `%s`", transport.pos.ToString().c_str());
TC_LOG_INFO(LOG_FILTER_GENERAL, "seat: %i", transport.seat);
TC_LOG_INFO(LOG_FILTER_GENERAL, "time: %u", transport.time);
if (flags2 & MOVEMENTFLAG2_INTERPOLATED_MOVEMENT)
TC_LOG_INFO(LOG_FILTER_GENERAL, "time2: %u", t_time2);
TC_LOG_INFO(LOG_FILTER_GENERAL, "time2: %u", transport.time2);
if (bits.hasTransportTime3)
TC_LOG_INFO(LOG_FILTER_GENERAL, "time3: %u", t_time3);
TC_LOG_INFO(LOG_FILTER_GENERAL, "time3: %u", transport.time3);
}
if ((flags & (MOVEMENTFLAG_SWIMMING | MOVEMENTFLAG_FLYING)) || (flags2 & MOVEMENTFLAG2_ALWAYS_ALLOW_PITCHING))
@@ -1564,9 +1270,9 @@ void MovementInfo::OutDebug()
if (flags & MOVEMENTFLAG_FALLING || bits.hasFallData)
{
TC_LOG_INFO(LOG_FILTER_GENERAL, "fallTime: %u j_zspeed: %f", fallTime, j_zspeed);
TC_LOG_INFO(LOG_FILTER_GENERAL, "fallTime: %u j_zspeed: %f", jump.fallTime, jump.zspeed);
if (flags & MOVEMENTFLAG_FALLING)
TC_LOG_INFO(LOG_FILTER_GENERAL, "j_sinAngle: %f j_cosAngle: %f j_xyspeed: %f", j_sinAngle, j_cosAngle, j_xyspeed);
TC_LOG_INFO(LOG_FILTER_GENERAL, "j_sinAngle: %f j_cosAngle: %f j_xyspeed: %f", jump.sinAngle, jump.cosAngle, jump.xyspeed);
}
if (flags & MOVEMENTFLAG_SPLINE_ELEVATION)
@@ -1692,12 +1398,12 @@ bool WorldObject::_IsWithinDist(WorldObject const* obj, float dist2compare, bool
if (m_transport && obj->GetTransport() && obj->GetTransport()->GetGUIDLow() == m_transport->GetGUIDLow())
{
float dtx = m_movementInfo.t_pos.m_positionX - obj->m_movementInfo.t_pos.m_positionX;
float dty = m_movementInfo.t_pos.m_positionY - obj->m_movementInfo.t_pos.m_positionY;
float dtx = m_movementInfo.transport.pos.m_positionX - obj->m_movementInfo.transport.pos.m_positionX;
float dty = m_movementInfo.transport.pos.m_positionY - obj->m_movementInfo.transport.pos.m_positionY;
float disttsq = dtx * dtx + dty * dty;
if (is3D)
{
float dtz = m_movementInfo.t_pos.m_positionZ - obj->m_movementInfo.t_pos.m_positionZ;
float dtz = m_movementInfo.transport.pos.m_positionZ - obj->m_movementInfo.transport.pos.m_positionZ;
disttsq += dtz * dtz;
}
return disttsq < (maxdist * maxdist);
+57 -25
View File
@@ -192,7 +192,7 @@ class Object
uint32 GetEntry() const { return GetUInt32Value(OBJECT_FIELD_ENTRY); }
void SetEntry(uint32 entry) { SetUInt32Value(OBJECT_FIELD_ENTRY, entry); }
void SetObjectScale(float scale) { SetFloatValue(OBJECT_FIELD_SCALE_X, scale); }
virtual void SetObjectScale(float scale) { SetFloatValue(OBJECT_FIELD_SCALE_X, scale); }
TypeID GetTypeId() const { return m_objectTypeId; }
bool isType(uint16 mask) const { return (mask & m_objectType); }
@@ -296,10 +296,8 @@ class Object
uint32 GetUpdateFieldData(Player const* target, uint32*& flags) const;
void _SetUpdateBits(UpdateMask* updateMask, Player* target) const;
void _SetCreateBits(UpdateMask* updateMask, Player* target) const;
void _BuildMovementUpdate(ByteBuffer * data, uint16 flags) const;
void _BuildValuesUpdate(uint8 updatetype, ByteBuffer *data, UpdateMask* updateMask, Player* target) const;
void BuildMovementUpdate(ByteBuffer* data, uint16 flags) const;
virtual void BuildValuesUpdate(uint8 updatetype, ByteBuffer* data, Player* target) const;
uint16 m_objectType;
@@ -469,19 +467,47 @@ struct MovementInfo
uint16 flags2;
Position pos;
uint32 time;
// transport
uint64 t_guid;
Position t_pos;
int8 t_seat;
uint32 t_time;
uint32 t_time2;
uint32 t_time3;
struct TransportInfo
{
void Reset()
{
guid = 0;
pos.Relocate(0.0f, 0.0f, 0.0f, 0.0f);
seat = -1;
time = 0;
time2 = 0;
time3 = 0;
}
uint64 guid;
Position pos;
int8 seat;
uint32 time;
uint32 time2;
uint32 time3;
} transport;
// swimming/flying
float pitch;
// falling
uint32 fallTime;
// jumping
float j_zspeed, j_sinAngle, j_cosAngle, j_xyspeed;
struct JumpInfo
{
void Reset()
{
fallTime = 0;
zspeed = sinAngle = cosAngle = xyspeed = 0.0f;
}
uint32 fallTime;
float zspeed, sinAngle, cosAngle, xyspeed;
} jump;
// spline
float splineElevation;
@@ -497,12 +523,11 @@ struct MovementInfo
} bits;
MovementInfo() :
guid(0), flags(0), flags2(0), time(0), t_guid(0),
t_seat(-1), t_time(0), t_time2(0), t_time3(0), pitch(0.0f), fallTime(0),
j_zspeed(0.0f), j_sinAngle(0.0f), j_cosAngle(0.0f), j_xyspeed(0.0f)
guid(0), flags(0), flags2(0), time(0), pitch(0.0f)
{
pos.Relocate(0.0f, 0.0f, 0.0f, 0.0f);
t_pos.Relocate(0.0f, 0.0f, 0.0f, 0.0f);
transport.Reset();
jump.Reset();
memset(&bits, 0, sizeof(bits));
}
@@ -513,18 +538,25 @@ struct MovementInfo
bool HasMovementFlag(uint32 flag) const { return flags & flag; }
uint16 GetExtraMovementFlags() const { return flags2; }
void SetExtraMovementFlags(uint16 flag) { flags2 = flag; }
void AddExtraMovementFlag(uint16 flag) { flags2 |= flag; }
void RemoveExtraMovementFlag(uint16 flag) { flags2 &= ~flag; }
bool HasExtraMovementFlag(uint16 flag) const { return flags2 & flag; }
void SetFallTime(uint32 time) { fallTime = time; }
void SetFallTime(uint32 time) { jump.fallTime = time; }
void ClearTransport()
void ResetTransport()
{
t_guid = 0;
t_pos.Relocate(0.0f, 0.0f, 0.0f, 0.0f);
t_seat = -1;
t_time = 0;
t_time2 = 0;
transport.Reset();
bits.hasTransportTime2 = false;
bits.hasTransportTime3 = false;
}
void ResetJump()
{
jump.Reset();
bits.hasFallData = false;
bits.hasFallDirection = false;
}
void OutDebug();
+2 -2
View File
@@ -2048,6 +2048,6 @@ void Pet::SetDisplayId(uint32 modelId)
if (Unit* owner = GetOwner())
if (Player* player = owner->ToPlayer())
if (owner->ToPlayer()->GetGroup())
owner->ToPlayer()->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_MODEL_ID);
if (player->GetGroup())
player->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_MODEL_ID);
}
+61 -48
View File
@@ -24,15 +24,14 @@
#include "Battlefield.h"
#include "BattlefieldMgr.h"
#include "BattlefieldWG.h"
#include "BattlegroundAV.h"
#include "Battleground.h"
#include "BattlegroundAV.h"
#include "BattlegroundMgr.h"
#include "CellImpl.h"
#include "Channel.h"
#include "ChannelMgr.h"
#include "CharacterDatabaseCleaner.h"
#include "Chat.h"
#include <cmath>
#include "Common.h"
#include "ConditionMgr.h"
#include "CreatureAI.h"
@@ -50,8 +49,8 @@
#include "GuildMgr.h"
#include "InstanceSaveMgr.h"
#include "InstanceScript.h"
#include "Language.h"
#include "LFGMgr.h"
#include "Language.h"
#include "Log.h"
#include "MapInstanced.h"
#include "MapManager.h"
@@ -60,17 +59,18 @@
#include "Opcodes.h"
#include "OutdoorPvP.h"
#include "OutdoorPvPMgr.h"
#include "ReputationMgr.h"
#include "Pet.h"
#include "QuestDef.h"
#include "ReputationMgr.h"
#include "SkillDiscovery.h"
#include "SocialMgr.h"
#include "Spell.h"
#include "SpellAuraEffects.h"
#include "SpellAuras.h"
#include "Spell.h"
#include "SpellMgr.h"
#include "Transport.h"
#include "UpdateData.h"
#include "UpdateFieldFlags.h"
#include "UpdateMask.h"
#include "Util.h"
#include "Vehicle.h"
@@ -2135,7 +2135,7 @@ bool Player::TeleportTo(uint32 mapid, float x, float y, float z, float orientati
{
m_transport->RemovePassenger(this);
m_transport = NULL;
m_movementInfo.ClearTransport();
m_movementInfo.ResetTransport();
RepopAtGraveyard(); // teleport to near graveyard if on transport, looks blizz like :)
}
@@ -2159,7 +2159,7 @@ bool Player::TeleportTo(uint32 mapid, float x, float y, float z, float orientati
{
m_transport->RemovePassenger(this);
m_transport = NULL;
m_movementInfo.ClearTransport();
m_movementInfo.ResetTransport();
}
}
@@ -2317,10 +2317,10 @@ bool Player::TeleportTo(uint32 mapid, float x, float y, float z, float orientati
if (m_transport)
{
final_x += m_movementInfo.t_pos.GetPositionX();
final_y += m_movementInfo.t_pos.GetPositionY();
final_z += m_movementInfo.t_pos.GetPositionZ();
final_o += m_movementInfo.t_pos.GetOrientation();
final_x += m_movementInfo.transport.pos.GetPositionX();
final_y += m_movementInfo.transport.pos.GetPositionY();
final_z += m_movementInfo.transport.pos.GetPositionZ();
final_o += m_movementInfo.transport.pos.GetOrientation();
}
m_teleport_dest = WorldLocation(mapid, final_x, final_y, final_z, final_o);
@@ -5137,8 +5137,7 @@ void Player::BuildPlayerRepop()
// convert player body to ghost
SetHealth(1);
AddUnitMovementFlag(MOVEMENTFLAG_WATERWALKING);
SendMovementWaterWalking();
SetWaterWalking(true);
if (!GetSession()->isLogingOut())
SetRooted(false);
@@ -5178,8 +5177,7 @@ void Player::ResurrectPlayer(float restore_percent, bool applySickness)
setDeathState(ALIVE);
RemoveUnitMovementFlag(MOVEMENTFLAG_WATERWALKING);
SendMovementWaterWalking();
SetWaterWalking(false);
SetRooted(false);
m_deathTimer = 0;
@@ -17244,18 +17242,18 @@ bool Player::LoadFromDB(uint32 guid, SQLQueryHolder *holder)
// currently we do not support transport in bg
else if (transGUID)
{
m_movementInfo.t_guid = MAKE_NEW_GUID(transGUID, 0, HIGHGUID_MO_TRANSPORT);
m_movementInfo.t_pos.Relocate(fields[27].GetFloat(), fields[28].GetFloat(), fields[29].GetFloat(), fields[30].GetFloat());
m_movementInfo.transport.guid = MAKE_NEW_GUID(transGUID, 0, HIGHGUID_MO_TRANSPORT);
m_movementInfo.transport.pos.Relocate(fields[27].GetFloat(), fields[28].GetFloat(), fields[29].GetFloat(), fields[30].GetFloat());
if (!Trinity::IsValidMapCoord(
GetPositionX()+m_movementInfo.t_pos.m_positionX, GetPositionY()+m_movementInfo.t_pos.m_positionY,
GetPositionZ()+m_movementInfo.t_pos.m_positionZ, GetOrientation()+m_movementInfo.t_pos.GetOrientation()) ||
GetPositionX()+m_movementInfo.transport.pos.GetPositionX(), GetPositionY()+m_movementInfo.transport.pos.GetPositionY(),
GetPositionZ()+m_movementInfo.transport.pos.GetPositionZ(), GetOrientation()+m_movementInfo.transport.pos.GetOrientation()) ||
// transport size limited
m_movementInfo.t_pos.m_positionX > 250 || m_movementInfo.t_pos.m_positionY > 250 || m_movementInfo.t_pos.m_positionZ > 250)
m_movementInfo.transport.pos.m_positionX > 250 || m_movementInfo.transport.pos.m_positionY > 250 || m_movementInfo.transport.pos.m_positionZ > 250)
{
TC_LOG_ERROR(LOG_FILTER_PLAYER, "Player (guidlow %d) have invalid transport coordinates (X: %f Y: %f Z: %f O: %f). Teleport to bind location.",
guid, GetPositionX()+m_movementInfo.t_pos.m_positionX, GetPositionY()+m_movementInfo.t_pos.m_positionY,
GetPositionZ()+m_movementInfo.t_pos.m_positionZ, GetOrientation()+m_movementInfo.t_pos.GetOrientation());
guid, GetPositionX()+m_movementInfo.transport.pos.GetPositionX(), GetPositionY()+m_movementInfo.transport.pos.GetPositionY(),
GetPositionZ()+m_movementInfo.transport.pos.GetPositionZ(), GetOrientation()+m_movementInfo.transport.pos.GetOrientation());
RelocateToHomebind();
}
@@ -22760,14 +22758,30 @@ void Player::UpdateTriggerVisibility()
{
if (IS_CREATURE_GUID(*itr))
{
Creature* obj = GetMap()->GetCreature(*itr);
if (!obj || !(obj->IsTrigger() || obj->HasAuraType(SPELL_AURA_TRANSFORM))) // can transform into triggers
Creature* creature = GetMap()->GetCreature(*itr);
// Update fields of triggers, transformed units or unselectable units (values dependent on GM state)
if (!creature || (!creature->IsTrigger() && !creature->HasAuraType(SPELL_AURA_TRANSFORM) && !creature->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE)))
continue;
obj->BuildValuesUpdateBlockForPlayer(&udata, this);
creature->SetFieldNotifyFlag(UF_FLAG_PUBLIC);
creature->BuildValuesUpdateBlockForPlayer(&udata, this);
creature->RemoveFieldNotifyFlag(UF_FLAG_PUBLIC);
}
else if (IS_GAMEOBJECT_GUID((*itr)))
{
GameObject* go = GetMap()->GetGameObject(*itr);
if (!go)
continue;
go->SetFieldNotifyFlag(UF_FLAG_PUBLIC);
go->BuildValuesUpdateBlockForPlayer(&udata, this);
go->RemoveFieldNotifyFlag(UF_FLAG_PUBLIC);
}
}
if (!udata.HasData())
return;
udata.BuildPacket(&packet);
GetSession()->SendPacket(&packet);
}
@@ -23387,13 +23401,13 @@ void Player::SendAurasForTarget(Unit* target)
These movement packets are usually found in SMSG_COMPRESSED_MOVES
*/
if (target->HasAuraType(SPELL_AURA_FEATHER_FALL))
target->SendMovementFeatherFall();
target->SetFeatherFall(true, true);
if (target->HasAuraType(SPELL_AURA_WATER_WALK))
target->SendMovementWaterWalking();
target->SetWaterWalking(true, true);
if (target->HasAuraType(SPELL_AURA_HOVER))
target->SendMovementHover();
target->SetHover(true, true);
WorldPacket data(SMSG_AURA_UPDATE_ALL);
data.append(target->GetPackGUID());
@@ -25319,7 +25333,7 @@ void Player::HandleFall(MovementInfo const& movementInfo)
}
//Z given by moveinfo, LastZ, FallTime, WaterZ, MapZ, Damage, Safefall reduction
TC_LOG_DEBUG(LOG_FILTER_PLAYER, "FALLDAMAGE z=%f sz=%f pZ=%f FallTime=%d mZ=%f damage=%d SF=%d", movementInfo.pos.GetPositionZ(), height, GetPositionZ(), movementInfo.fallTime, height, damage, safe_fall);
TC_LOG_DEBUG(LOG_FILTER_PLAYER, "FALLDAMAGE z=%f sz=%f pZ=%f FallTime=%d mZ=%f damage=%d SF=%d", movementInfo.pos.GetPositionZ(), height, GetPositionZ(), movementInfo.jump.fallTime, height, damage, safe_fall);
}
}
RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_LANDING); // No fly zone - Parachute
@@ -25659,8 +25673,8 @@ void Player::AddKnownCurrency(uint32 itemId)
void Player::UpdateFallInformationIfNeed(MovementInfo const& minfo, uint16 opcode)
{
if (m_lastFallTime >= minfo.fallTime || m_lastFallZ <= minfo.pos.GetPositionZ() || opcode == MSG_MOVE_FALL_LAND)
SetFallInformation(minfo.fallTime, minfo.pos.GetPositionZ());
if (m_lastFallTime >= minfo.jump.fallTime || m_lastFallZ <= minfo.pos.GetPositionZ() || opcode == MSG_MOVE_FALL_LAND)
SetFallInformation(minfo.jump.fallTime, minfo.pos.GetPositionZ());
}
void Player::UnsummonPetTemporaryIfAny()
@@ -26829,10 +26843,9 @@ void Player::_SaveInstanceTimeRestrictions(SQLTransaction& trans)
bool Player::IsInWhisperWhiteList(uint64 guid)
{
for (WhisperListContainer::const_iterator itr = WhisperList.begin(); itr != WhisperList.end(); ++itr)
{
if (*itr == guid)
return true;
}
return false;
}
@@ -27240,35 +27253,35 @@ void Player::ReadMovementInfo(WorldPacket& data, MovementInfo* mi, Movement::Ext
break;
case MSETransportPositionX:
if (hasTransportData)
data >> mi->t_pos.m_positionX;
data >> mi->transport.pos.m_positionX;
break;
case MSETransportPositionY:
if (hasTransportData)
data >> mi->t_pos.m_positionY;
data >> mi->transport.pos.m_positionY;
break;
case MSETransportPositionZ:
if (hasTransportData)
data >> mi->t_pos.m_positionZ;
data >> mi->transport.pos.m_positionZ;
break;
case MSETransportOrientation:
if (hasTransportData)
mi->t_pos.SetOrientation(data.read<float>());
mi->transport.pos.SetOrientation(data.read<float>());
break;
case MSETransportSeat:
if (hasTransportData)
data >> mi->t_seat;
data >> mi->transport.seat;
break;
case MSETransportTime:
if (hasTransportData)
data >> mi->t_time;
data >> mi->transport.time;
break;
case MSETransportTime2:
if (hasTransportData && mi->bits.hasTransportTime2)
data >> mi->t_time2;
data >> mi->transport.time2;
break;
case MSETransportTime3:
if (hasTransportData && mi->bits.hasTransportTime3)
data >> mi->t_time3;
data >> mi->transport.time3;
break;
case MSEPitch:
if (mi->bits.hasPitch)
@@ -27276,23 +27289,23 @@ void Player::ReadMovementInfo(WorldPacket& data, MovementInfo* mi, Movement::Ext
break;
case MSEFallTime:
if (mi->bits.hasFallData)
data >> mi->fallTime;
data >> mi->jump.fallTime;
break;
case MSEFallVerticalSpeed:
if (mi->bits.hasFallData)
data >> mi->j_zspeed;
data >> mi->jump.zspeed;
break;
case MSEFallCosAngle:
if (mi->bits.hasFallData && mi->bits.hasFallDirection)
data >> mi->j_cosAngle;
data >> mi->jump.cosAngle;
break;
case MSEFallSinAngle:
if (mi->bits.hasFallData && mi->bits.hasFallDirection)
data >> mi->j_sinAngle;
data >> mi->jump.sinAngle;
break;
case MSEFallHorizontalSpeed:
if (mi->bits.hasFallData && mi->bits.hasFallDirection)
data >> mi->j_xyspeed;
data >> mi->jump.xyspeed;
break;
case MSESplineElevation:
if (mi->bits.hasSplineElevation)
@@ -27315,9 +27328,9 @@ void Player::ReadMovementInfo(WorldPacket& data, MovementInfo* mi, Movement::Ext
}
mi->guid = guid;
mi->t_guid = tguid;
mi->transport.guid = tguid;
if (hasTransportData && mi->pos.m_positionX != mi->t_pos.m_positionX)
if (hasTransportData && mi->pos.m_positionX != mi->transport.pos.m_positionX)
if (GetTransport())
GetTransport()->UpdatePosition(mi);
@@ -634,8 +634,8 @@ uint32 Transport::AddNPCPassenger(uint32 tguid, uint32 entry, float x, float y,
}
creature->SetTransport(this);
creature->m_movementInfo.t_guid = GetGUID();
creature->m_movementInfo.t_pos.Relocate(x, y, z, o);
creature->m_movementInfo.transport.guid = GetGUID();
creature->m_movementInfo.transport.pos.Relocate(x, y, z, o);
if (anim)
creature->SetUInt32Value(UNIT_NPC_EMOTESTATE, anim);
@@ -647,7 +647,7 @@ uint32 Transport::AddNPCPassenger(uint32 tguid, uint32 entry, float x, float y,
o + GetOrientation());
creature->SetHomePosition(creature->GetPositionX(), creature->GetPositionY(), creature->GetPositionZ(), creature->GetOrientation());
creature->SetTransportHomePosition(creature->m_movementInfo.t_pos);
creature->SetTransportHomePosition(creature->m_movementInfo.transport.pos);
if (!creature->IsPositionValid())
{
@@ -674,10 +674,10 @@ uint32 Transport::AddNPCPassenger(uint32 tguid, uint32 entry, float x, float y,
void Transport::UpdatePosition(MovementInfo* mi)
{
float transport_o = mi->pos.GetOrientation() - mi->t_pos.GetOrientation();
float transport_x = mi->pos.m_positionX - (mi->t_pos.m_positionX * std::cos(transport_o) - mi->t_pos.m_positionY * std::sin(transport_o));
float transport_y = mi->pos.m_positionY - (mi->t_pos.m_positionY * std::cos(transport_o) + mi->t_pos.m_positionX * std::sin(transport_o));
float transport_z = mi->pos.m_positionZ - mi->t_pos.m_positionZ;
float transport_o = mi->pos.GetOrientation() - mi->transport.pos.GetOrientation();
float transport_x = mi->pos.m_positionX - (mi->transport.pos.m_positionX * std::cos(transport_o) - mi->transport.pos.m_positionY * std::sin(transport_o));
float transport_y = mi->pos.m_positionY - (mi->transport.pos.m_positionY * std::cos(transport_o) + mi->transport.pos.m_positionX * std::sin(transport_o));
float transport_z = mi->pos.m_positionZ - mi->transport.pos.m_positionZ;
Relocate(transport_x, transport_y, transport_z, transport_o);
UpdatePassengerPositions();
@@ -690,7 +690,7 @@ void Transport::UpdatePassengerPositions()
Creature* npc = *itr;
float x, y, z, o;
npc->m_movementInfo.t_pos.GetPosition(x, y, z, o);
npc->m_movementInfo.transport.pos.GetPosition(x, y, z, o);
CalculatePassengerPosition(x, y, z, &o);
GetMap()->CreatureRelocation(npc, x, y, z, o, false);
npc->GetTransportHomePosition(x, y, z, o);
+312 -109
View File
@@ -409,7 +409,7 @@ void Unit::UpdateSplinePosition()
Movement::Location loc = movespline->ComputePosition();
if (GetTransGUID())
{
Position& pos = m_movementInfo.t_pos;
Position& pos = m_movementInfo.transport.pos;
pos.m_positionX = loc.x;
pos.m_positionY = loc.y;
pos.m_positionZ = loc.z;
@@ -8594,10 +8594,7 @@ void Unit::SetCharm(Unit* charm, bool apply)
_isWalkingBeforeCharm = charm->IsWalking();
if (_isWalkingBeforeCharm)
{
charm->SetWalk(false);
charm->SendMovementWalkMode();
}
m_Controlled.insert(charm);
}
@@ -8632,10 +8629,7 @@ void Unit::SetCharm(Unit* charm, bool apply)
}
if (charm->IsWalking() != _isWalkingBeforeCharm)
{
charm->SetWalk(_isWalkingBeforeCharm);
charm->SendMovementWalkMode();
}
if (charm->GetTypeId() == TYPEID_PLAYER
|| !charm->ToCreature()->HasUnitTypeMask(UNIT_MASK_MINION)
@@ -16008,14 +16002,6 @@ bool Unit::IsFalling() const
return m_movementInfo.HasMovementFlag(MOVEMENTFLAG_FALLING | MOVEMENTFLAG_FALLING_FAR) || movespline->isFalling();
}
void Unit::SetCanFly(bool apply)
{
if (apply)
AddUnitMovementFlag(MOVEMENTFLAG_CAN_FLY);
else
RemoveUnitMovementFlag(MOVEMENTFLAG_CAN_FLY);
}
void Unit::NearTeleportTo(float x, float y, float z, float orientation, bool casting /*= false*/)
{
DisableSpline();
@@ -16218,11 +16204,11 @@ void Unit::WriteMovementInfo(WorldPacket& data, Movement::ExtraMovementStatusEle
break;
case MSETransportTime2:
if (hasTransportData && hasTransportTime2)
data << mi.t_time2;
data << mi.transport.time2;
break;
case MSETransportTime3:
if (hasTransportData && hasTransportTime3)
data << mi.t_time3;
data << mi.transport.time3;
break;
case MSEPitch:
if (hasPitch)
@@ -16230,23 +16216,23 @@ void Unit::WriteMovementInfo(WorldPacket& data, Movement::ExtraMovementStatusEle
break;
case MSEFallTime:
if (hasFallData)
data << mi.fallTime;
data << mi.jump.fallTime;
break;
case MSEFallVerticalSpeed:
if (hasFallData)
data << mi.j_zspeed;
data << mi.jump.zspeed;
break;
case MSEFallCosAngle:
if (hasFallData && hasFallDirection)
data << mi.j_cosAngle;
data << mi.jump.cosAngle;
break;
case MSEFallSinAngle:
if (hasFallData && hasFallDirection)
data << mi.j_sinAngle;
data << mi.jump.sinAngle;
break;
case MSEFallHorizontalSpeed:
if (hasFallData && hasFallDirection)
data << mi.j_xyspeed;
data << mi.jump.xyspeed;
break;
case MSESplineElevation:
if (hasSplineElevation)
@@ -16700,103 +16686,146 @@ bool Unit::SetWalk(bool enable)
else
RemoveUnitMovementFlag(MOVEMENTFLAG_WALKING);
return true;
}
bool Unit::SetDisableGravity(bool disable, bool /*packetOnly = false*/)
{
if (disable == IsLevitating())
return false;
if (disable)
AddUnitMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY);
else
RemoveUnitMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY);
return true;
}
bool Unit::SetHover(bool enable)
{
if (enable == HasUnitMovementFlag(MOVEMENTFLAG_HOVER))
return false;
if (enable)
{
//! No need to check height on ascent
AddUnitMovementFlag(MOVEMENTFLAG_HOVER);
if (float hh = GetFloatValue(UNIT_FIELD_HOVERHEIGHT))
UpdateHeight(GetPositionZ() + hh);
}
else
{
RemoveUnitMovementFlag(MOVEMENTFLAG_HOVER);
if (float hh = GetFloatValue(UNIT_FIELD_HOVERHEIGHT))
{
float newZ = GetPositionZ() - hh;
UpdateAllowedPositionZ(GetPositionX(), GetPositionY(), newZ);
UpdateHeight(newZ);
}
}
return true;
}
void Unit::SendMovementHover()
{
if (HasUnitMovementFlag(MOVEMENTFLAG_HOVER))
Movement::PacketSender(this, SMSG_SPLINE_MOVE_SET_HOVER, SMSG_MOVE_SET_HOVER).Send();
else
Movement::PacketSender(this, SMSG_SPLINE_MOVE_UNSET_HOVER, SMSG_MOVE_UNSET_HOVER).Send();
}
void Unit::SendMovementWaterWalking()
{
if (HasUnitMovementFlag(MOVEMENTFLAG_WATERWALKING))
Movement::PacketSender(this, SMSG_SPLINE_MOVE_SET_WATER_WALK, SMSG_MOVE_WATER_WALK).Send();
else
Movement::PacketSender(this, SMSG_SPLINE_MOVE_SET_LAND_WALK, SMSG_MOVE_LAND_WALK).Send();
}
void Unit::SendMovementFeatherFall()
{
if (HasUnitMovementFlag(MOVEMENTFLAG_FALLING_SLOW))
Movement::PacketSender(this, SMSG_SPLINE_MOVE_SET_FEATHER_FALL, SMSG_MOVE_FEATHER_FALL).Send();
else
Movement::PacketSender(this, SMSG_SPLINE_MOVE_SET_NORMAL_FALL, SMSG_MOVE_NORMAL_FALL).Send();
}
void Unit::SendMovementCanFlyChange()
{
if (HasUnitMovementFlag(MOVEMENTFLAG_CAN_FLY))
Movement::PacketSender(this, SMSG_SPLINE_MOVE_SET_FLYING, SMSG_MOVE_SET_CAN_FLY).Send();
else
Movement::PacketSender(this, SMSG_SPLINE_MOVE_UNSET_FLYING, SMSG_MOVE_UNSET_CAN_FLY).Send();
}
void Unit::SendMovementDisableGravity()
{
if (HasUnitMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY))
Movement::PacketSender(this, SMSG_SPLINE_MOVE_GRAVITY_DISABLE, SMSG_MOVE_GRAVITY_DISABLE).Send();
else
Movement::PacketSender(this, SMSG_SPLINE_MOVE_GRAVITY_ENABLE, SMSG_MOVE_GRAVITY_ENABLE).Send();
}
void Unit::SendMovementWalkMode()
{
///@ TODO: Find proper opcode for walk mode setting in player mind controlling a player case
if (HasUnitMovementFlag(MOVEMENTFLAG_WALKING))
if (enable)
Movement::PacketSender(this, SMSG_SPLINE_MOVE_SET_WALK_MODE, SMSG_SPLINE_MOVE_SET_WALK_MODE).Send();
else
Movement::PacketSender(this, SMSG_SPLINE_MOVE_SET_RUN_MODE, SMSG_SPLINE_MOVE_SET_WALK_MODE).Send();
return true;
}
void Unit::SendMovementSwimming()
bool Unit::SetDisableGravity(bool disable, bool packetOnly /*= false*/)
{
if (HasUnitMovementFlag(MOVEMENTFLAG_SWIMMING))
if (!packetOnly)
{
if (disable == IsLevitating())
return false;
if (disable)
AddUnitMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY);
else
RemoveUnitMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY);
}
if (disable)
Movement::PacketSender(this, SMSG_SPLINE_MOVE_GRAVITY_DISABLE, SMSG_MOVE_GRAVITY_DISABLE).Send();
else
Movement::PacketSender(this, SMSG_SPLINE_MOVE_GRAVITY_ENABLE, SMSG_MOVE_GRAVITY_ENABLE).Send();
return true;
}
bool Unit::SetSwim(bool enable)
{
if (enable == HasUnitMovementFlag(MOVEMENTFLAG_SWIMMING))
return false;
if (enable)
AddUnitMovementFlag(MOVEMENTFLAG_SWIMMING);
else
RemoveUnitMovementFlag(MOVEMENTFLAG_SWIMMING);
if (enable)
Movement::PacketSender(this, SMSG_SPLINE_MOVE_START_SWIM, NULL_OPCODE).Send();
else
Movement::PacketSender(this, SMSG_SPLINE_MOVE_STOP_SWIM, NULL_OPCODE).Send();
return true;
}
bool Unit::SetCanFly(bool enable)
{
if (enable == HasUnitMovementFlag(MOVEMENTFLAG_CAN_FLY))
return false;
if (enable)
AddUnitMovementFlag(MOVEMENTFLAG_CAN_FLY);
else
RemoveUnitMovementFlag(MOVEMENTFLAG_CAN_FLY);
if (enable)
Movement::PacketSender(this, SMSG_SPLINE_MOVE_SET_FLYING, SMSG_MOVE_SET_CAN_FLY).Send();
else
Movement::PacketSender(this, SMSG_SPLINE_MOVE_UNSET_FLYING, SMSG_MOVE_UNSET_CAN_FLY).Send();
return true;
}
bool Unit::SetWaterWalking(bool enable, bool packetOnly /*= false */)
{
if (!packetOnly)
{
if (enable == HasUnitMovementFlag(MOVEMENTFLAG_WATERWALKING))
return false;
if (enable)
AddUnitMovementFlag(MOVEMENTFLAG_WATERWALKING);
else
RemoveUnitMovementFlag(MOVEMENTFLAG_WATERWALKING);
}
if (enable)
Movement::PacketSender(this, SMSG_SPLINE_MOVE_SET_WATER_WALK, SMSG_MOVE_WATER_WALK).Send();
else
Movement::PacketSender(this, SMSG_SPLINE_MOVE_SET_LAND_WALK, SMSG_MOVE_LAND_WALK).Send();
return true;
}
bool Unit::SetFeatherFall(bool enable, bool packetOnly /*= false */)
{
if (!packetOnly)
{
if (enable == HasUnitMovementFlag(MOVEMENTFLAG_FALLING_SLOW))
return false;
if (enable)
AddUnitMovementFlag(MOVEMENTFLAG_FALLING_SLOW);
else
RemoveUnitMovementFlag(MOVEMENTFLAG_FALLING_SLOW);
}
if (enable)
Movement::PacketSender(this, SMSG_SPLINE_MOVE_SET_FEATHER_FALL, SMSG_MOVE_FEATHER_FALL).Send();
else
Movement::PacketSender(this, SMSG_SPLINE_MOVE_SET_NORMAL_FALL, SMSG_MOVE_NORMAL_FALL).Send();
return true;
}
bool Unit::SetHover(bool enable, bool packetOnly /*= false*/)
{
if (!packetOnly)
{
if (enable == HasUnitMovementFlag(MOVEMENTFLAG_HOVER))
return false;
if (enable)
{
//! No need to check height on ascent
AddUnitMovementFlag(MOVEMENTFLAG_HOVER);
if (float hh = GetFloatValue(UNIT_FIELD_HOVERHEIGHT))
UpdateHeight(GetPositionZ() + hh);
}
else
{
RemoveUnitMovementFlag(MOVEMENTFLAG_HOVER);
if (float hh = GetFloatValue(UNIT_FIELD_HOVERHEIGHT))
{
float newZ = GetPositionZ() - hh;
UpdateAllowedPositionZ(GetPositionX(), GetPositionY(), newZ);
UpdateHeight(newZ);
}
}
}
if (enable)
Movement::PacketSender(this, SMSG_SPLINE_MOVE_SET_HOVER, SMSG_MOVE_SET_HOVER).Send();
else
Movement::PacketSender(this, SMSG_SPLINE_MOVE_UNSET_HOVER, SMSG_MOVE_UNSET_HOVER).Send();
return true;
}
void Unit::SendSetPlayHoverAnim(bool enable)
@@ -16874,3 +16903,177 @@ void Unit::ReleaseFocus(Spell const* focusSpell)
if (focusSpell->GetSpellInfo()->AttributesEx5 & SPELL_ATTR5_DONT_TURN_DURING_CAST)
ClearUnitState(UNIT_STATE_ROTATING);
}
void Unit::BuildValuesUpdate(uint8 updateType, ByteBuffer* data, Player* target) const
{
if (!target)
return;
ByteBuffer fieldBuffer;
UpdateMask updateMask;
updateMask.SetCount(m_valuesCount);
uint32* flags = UnitUpdateFieldFlags;
uint32 visibleFlag = UF_FLAG_PUBLIC;
if (target == this)
visibleFlag |= UF_FLAG_PRIVATE;
Player* plr = GetCharmerOrOwnerPlayerOrPlayerItself();
if (GetOwnerGUID() == target->GetGUID())
visibleFlag |= UF_FLAG_OWNER;
if (HasFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_SPECIALINFO))
if (HasAuraTypeWithCaster(SPELL_AURA_EMPATHY, target->GetGUID()))
visibleFlag |= UF_FLAG_SPECIAL_INFO;
if (plr && plr->IsInSameRaidWith(target))
visibleFlag |= UF_FLAG_PARTY_MEMBER;
Creature const* creature = ToCreature();
for (uint16 index = 0; index < m_valuesCount; ++index)
{
if (_fieldNotifyFlags & flags[index] ||
((flags[index] & visibleFlag) & UF_FLAG_SPECIAL_INFO) ||
((updateType == UPDATETYPE_VALUES ? _changesMask.GetBit(index) : m_uint32Values[index]) && (flags[index] & visibleFlag)) ||
(index == UNIT_FIELD_AURASTATE && HasFlag(UNIT_FIELD_AURASTATE, PER_CASTER_AURA_STATE_MASK)))
{
updateMask.SetBit(index);
if (index == UNIT_NPC_FLAGS)
{
uint32 appendValue = m_uint32Values[UNIT_NPC_FLAGS];
if (creature)
if (!target->CanSeeSpellClickOn(creature))
appendValue &= ~UNIT_NPC_FLAG_SPELLCLICK;
fieldBuffer << uint32(appendValue);
}
else if (index == UNIT_FIELD_AURASTATE)
{
// Check per caster aura states to not enable using a spell in client if specified aura is not by target
fieldBuffer << BuildAuraStateUpdateForTarget(target);
}
// FIXME: Some values at server stored in float format but must be sent to client in uint32 format
else if (index >= UNIT_FIELD_BASEATTACKTIME && index <= UNIT_FIELD_RANGEDATTACKTIME)
{
// convert from float to uint32 and send
fieldBuffer << uint32(m_floatValues[index] < 0 ? 0 : m_floatValues[index]);
}
// there are some float values which may be negative or can't get negative due to other checks
else if ((index >= UNIT_FIELD_NEGSTAT0 && index <= UNIT_FIELD_NEGSTAT4) ||
(index >= UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE && index <= (UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE + 6)) ||
(index >= UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE && index <= (UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE + 6)) ||
(index >= UNIT_FIELD_POSSTAT0 && index <= UNIT_FIELD_POSSTAT4))
{
fieldBuffer << uint32(m_floatValues[index]);
}
// Gamemasters should be always able to select units - remove not selectable flag
else if (index == UNIT_FIELD_FLAGS)
{
uint32 appendValue = m_uint32Values[UNIT_FIELD_FLAGS];
if (target->IsGameMaster())
appendValue &= ~UNIT_FLAG_NOT_SELECTABLE;
fieldBuffer << uint32(appendValue);
}
// use modelid_a if not gm, _h if gm for CREATURE_FLAG_EXTRA_TRIGGER creatures
else if (index == UNIT_FIELD_DISPLAYID)
{
uint32 displayId = m_uint32Values[UNIT_FIELD_DISPLAYID];
if (creature)
{
CreatureTemplate const* cinfo = creature->GetCreatureTemplate();
// this also applies for transform auras
if (SpellInfo const* transform = sSpellMgr->GetSpellInfo(getTransForm()))
for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
if (transform->Effects[i].IsAura(SPELL_AURA_TRANSFORM))
if (CreatureTemplate const* transformInfo = sObjectMgr->GetCreatureTemplate(transform->Effects[i].MiscValue))
{
cinfo = transformInfo;
break;
}
if (cinfo->flags_extra & CREATURE_FLAG_EXTRA_TRIGGER)
{
if (target->IsGameMaster())
{
if (cinfo->Modelid1)
displayId = cinfo->Modelid1; // Modelid1 is a visible model for gms
else
displayId = 17519; // world visible trigger's model
}
else
{
if (cinfo->Modelid2)
displayId = cinfo->Modelid2; // Modelid2 is an invisible model for players
else
displayId = 11686; // world invisible trigger's model
}
}
}
fieldBuffer << uint32(displayId);
}
// hide lootable animation for unallowed players
else if (index == UNIT_DYNAMIC_FLAGS)
{
uint32 dynamicFlags = m_uint32Values[UNIT_DYNAMIC_FLAGS] & ~(UNIT_DYNFLAG_TAPPED | UNIT_DYNFLAG_TAPPED_BY_PLAYER);
if (creature)
{
if (creature->hasLootRecipient())
{
dynamicFlags |= UNIT_DYNFLAG_TAPPED;
if (creature->isTappedBy(target))
dynamicFlags |= UNIT_DYNFLAG_TAPPED_BY_PLAYER;
}
if (!target->isAllowedToLoot(creature))
dynamicFlags &= ~UNIT_DYNFLAG_LOOTABLE;
}
// unit UNIT_DYNFLAG_TRACK_UNIT should only be sent to caster of SPELL_AURA_MOD_STALKED auras
if (dynamicFlags & UNIT_DYNFLAG_TRACK_UNIT)
if (!HasAuraTypeWithCaster(SPELL_AURA_MOD_STALKED, target->GetGUID()))
dynamicFlags &= ~UNIT_DYNFLAG_TRACK_UNIT;
fieldBuffer << dynamicFlags;
}
// FG: pretend that OTHER players in own group are friendly ("blue")
else if (index == UNIT_FIELD_BYTES_2 || index == UNIT_FIELD_FACTIONTEMPLATE)
{
if (IsControlledByPlayer() && target != this && sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GROUP) && IsInRaidWith(target))
{
FactionTemplateEntry const* ft1 = GetFactionTemplateEntry();
FactionTemplateEntry const* ft2 = target->GetFactionTemplateEntry();
if (ft1 && ft2 && !ft1->IsFriendlyTo(*ft2))
{
if (index == UNIT_FIELD_BYTES_2)
// Allow targetting opposite faction in party when enabled in config
fieldBuffer << (m_uint32Values[UNIT_FIELD_BYTES_2] & ((UNIT_BYTE2_FLAG_SANCTUARY /*| UNIT_BYTE2_FLAG_AURAS | UNIT_BYTE2_FLAG_UNK5*/) << 8)); // this flag is at uint8 offset 1 !!
else
// pretend that all other HOSTILE players have own faction, to allow follow, heal, rezz (trade wont work)
fieldBuffer << uint32(target->getFaction());
}
else
fieldBuffer << m_uint32Values[index];
}
else
fieldBuffer << m_uint32Values[index];
}
else
{
// send in current format (float as float, uint32 as uint32)
fieldBuffer << m_uint32Values[index];
}
}
}
*data << uint8(updateMask.GetBlockCount());
updateMask.AppendToPacket(data);
data->append(fieldBuffer);
}
+25 -32
View File
@@ -1597,27 +1597,19 @@ class Unit : public WorldObject
void MonsterMoveWithSpeed(float x, float y, float z, float speed, bool generatePath = false, bool forceDestination = false);
/*! These methods send the same packet to the client in apply and unapply case.
The client-side interpretation of this packet depends on the presence of relevant movementflags
which are sent with movementinfo. Furthermore, these packets are broadcast to nearby players as well
as the current unit.
*/
void SendMovementHover();
void SendMovementFeatherFall();
void SendMovementWaterWalking();
void SendMovementCanFlyChange();
void SendMovementDisableGravity();
void SendMovementWalkMode();
void SendMovementSwimming();
void SendSetPlayHoverAnim(bool enable);
void SendMovementSetSplineAnim(Movement::AnimType anim);
bool IsLevitating() const { return m_movementInfo.HasMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY);}
bool IsWalking() const { return m_movementInfo.HasMovementFlag(MOVEMENTFLAG_WALKING);}
bool IsLevitating() const { return m_movementInfo.HasMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY); }
bool IsWalking() const { return m_movementInfo.HasMovementFlag(MOVEMENTFLAG_WALKING); }
virtual bool SetWalk(bool enable);
virtual bool SetDisableGravity(bool disable, bool packetOnly = false);
virtual bool SetHover(bool enable);
virtual bool SetSwim(bool enable);
virtual bool SetCanFly(bool enable);
virtual bool SetWaterWalking(bool enable, bool packetOnly = false);
virtual bool SetFeatherFall(bool enable, bool packetOnly = false);
virtual bool SetHover(bool enable, bool packetOnly = false);
void SetInFront(WorldObject const* target);
void SetFacingTo(float ori);
@@ -2026,17 +2018,17 @@ class Unit : public WorldObject
bool IsStopped() const { return !(HasUnitState(UNIT_STATE_MOVING)); }
void StopMoving();
void AddUnitMovementFlag(uint32 f) { m_movementInfo.flags |= f; }
void RemoveUnitMovementFlag(uint32 f) { m_movementInfo.flags &= ~f; }
bool HasUnitMovementFlag(uint32 f) const { return (m_movementInfo.flags & f) == f; }
uint32 GetUnitMovementFlags() const { return m_movementInfo.flags; }
void SetUnitMovementFlags(uint32 f) { m_movementInfo.flags = f; }
void AddUnitMovementFlag(uint32 f) { m_movementInfo.AddMovementFlag(f); }
void RemoveUnitMovementFlag(uint32 f) { m_movementInfo.RemoveMovementFlag(f); }
bool HasUnitMovementFlag(uint32 f) const { return m_movementInfo.HasMovementFlag(f); }
uint32 GetUnitMovementFlags() const { return m_movementInfo.GetMovementFlags(); }
void SetUnitMovementFlags(uint32 f) { m_movementInfo.SetMovementFlags(f); }
void AddExtraUnitMovementFlag(uint16 f) { m_movementInfo.flags2 |= f; }
void RemoveExtraUnitMovementFlag(uint16 f) { m_movementInfo.flags2 &= ~f; }
uint16 HasExtraUnitMovementFlag(uint16 f) const { return m_movementInfo.flags2 & f; }
uint16 GetExtraUnitMovementFlags() const { return m_movementInfo.flags2; }
void SetExtraUnitMovementFlags(uint16 f) { m_movementInfo.flags2 = f; }
void AddExtraUnitMovementFlag(uint16 f) { m_movementInfo.AddExtraMovementFlag(f); }
void RemoveExtraUnitMovementFlag(uint16 f) { m_movementInfo.RemoveExtraMovementFlag(f); }
uint16 HasExtraUnitMovementFlag(uint16 f) const { return m_movementInfo.HasExtraMovementFlag(f); }
uint16 GetExtraUnitMovementFlags() const { return m_movementInfo.GetExtraMovementFlags(); }
void SetExtraUnitMovementFlags(uint16 f) { m_movementInfo.SetExtraMovementFlags(f); }
bool IsSplineEnabled() const;
float GetPositionZMinusOffset() const;
@@ -2094,12 +2086,12 @@ class Unit : public WorldObject
bool IsOnVehicle(const Unit* vehicle) const;
Unit* GetVehicleBase() const;
Creature* GetVehicleCreatureBase() const;
float GetTransOffsetX() const { return m_movementInfo.t_pos.GetPositionX(); }
float GetTransOffsetY() const { return m_movementInfo.t_pos.GetPositionY(); }
float GetTransOffsetZ() const { return m_movementInfo.t_pos.GetPositionZ(); }
float GetTransOffsetO() const { return m_movementInfo.t_pos.GetOrientation(); }
uint32 GetTransTime() const { return m_movementInfo.t_time; }
int8 GetTransSeat() const { return m_movementInfo.t_seat; }
float GetTransOffsetX() const { return m_movementInfo.transport.pos.GetPositionX(); }
float GetTransOffsetY() const { return m_movementInfo.transport.pos.GetPositionY(); }
float GetTransOffsetZ() const { return m_movementInfo.transport.pos.GetPositionZ(); }
float GetTransOffsetO() const { return m_movementInfo.transport.pos.GetOrientation(); }
uint32 GetTransTime() const { return m_movementInfo.transport.time; }
int8 GetTransSeat() const { return m_movementInfo.transport.seat; }
uint64 GetTransGUID() const;
/// Returns the transport this unit is on directly (if on vehicle and transport, return vehicle)
TransportBase* GetDirectTransport() const;
@@ -2122,7 +2114,6 @@ class Unit : public WorldObject
virtual bool CanFly() const = 0;
bool IsFlying() const { return m_movementInfo.HasMovementFlag(MOVEMENTFLAG_FLYING | MOVEMENTFLAG_DISABLE_GRAVITY); }
bool IsFalling() const;
void SetCanFly(bool apply);
void RewardRage(uint32 baseRage, bool attacker);
@@ -2157,6 +2148,8 @@ class Unit : public WorldObject
protected:
explicit Unit (bool isWorldObject);
void BuildValuesUpdate(uint8 updatetype, ByteBuffer* data, Player* target) const;
UnitAI* i_AI, *i_disabledAI;
void _UpdateSpells(uint32 time);
+6 -6
View File
@@ -517,7 +517,7 @@ Vehicle* Vehicle::RemovePassenger(Unit* unit)
_me->RemoveCharmedBy(unit);
if (_me->IsInWorld())
unit->m_movementInfo.ClearTransport();
unit->m_movementInfo.ResetTransport();
// only for flyable vehicles
if (unit->IsFlying())
@@ -554,7 +554,7 @@ void Vehicle::RelocatePassengers()
ASSERT(passenger->IsInWorld());
float px, py, pz, po;
passenger->m_movementInfo.t_pos.GetPosition(px, py, pz, po);
passenger->m_movementInfo.transport.pos.GetPosition(px, py, pz, po);
CalculatePassengerPosition(px, py, pz, &po);
passenger->UpdatePosition(px, py, pz, po);
@@ -837,10 +837,10 @@ bool VehicleJoinEvent::Execute(uint64, uint32)
Passenger->AddUnitState(UNIT_STATE_ONVEHICLE);
VehicleSeatEntry const* veSeat = Seat->second.SeatInfo;
Passenger->m_movementInfo.t_pos.Relocate(veSeat->m_attachmentOffsetX, veSeat->m_attachmentOffsetY, veSeat->m_attachmentOffsetZ);
Passenger->m_movementInfo.t_time = 0; // 1 for player
Passenger->m_movementInfo.t_seat = Seat->first;
Passenger->m_movementInfo.t_guid = Target->GetBase()->GetGUID();
Passenger->m_movementInfo.transport.pos.Relocate(veSeat->m_attachmentOffsetX, veSeat->m_attachmentOffsetY, veSeat->m_attachmentOffsetZ);
Passenger->m_movementInfo.transport.time = 0;
Passenger->m_movementInfo.transport.seat = Seat->first;
Passenger->m_movementInfo.transport.guid = Target->GetBase()->GetGUID();
if (Target->GetBase()->GetTypeId() == TYPEID_UNIT && Passenger->GetTypeId() == TYPEID_PLAYER &&
Seat->second.SeatInfo->m_flags & VEHICLE_SEAT_FLAG_CAN_CONTROL)
+1 -1
View File
@@ -36,7 +36,7 @@ class AreaTrigger;
#define MAX_NUMBER_OF_GRIDS 64
#define SIZE_OF_GRIDS 533.33333f
#define SIZE_OF_GRIDS 533.3333f
#define CENTER_GRID_ID (MAX_NUMBER_OF_GRIDS/2)
#define CENTER_GRID_OFFSET (SIZE_OF_GRIDS/2)
@@ -1053,8 +1053,7 @@ void WorldSession::HandlePlayerLogin(LoginQueryHolder* holder)
pCurrChar->CastSpell(pCurrChar, 20584, true, 0);// auras SPELL_AURA_INCREASE_SPEED(+speed in wisp form), SPELL_AURA_INCREASE_SWIM_SPEED(+swim speed in wisp form), SPELL_AURA_TRANSFORM (to wisp form)
pCurrChar->CastSpell(pCurrChar, 8326, true, 0); // auras SPELL_AURA_GHOST, SPELL_AURA_INCREASE_SPEED(why?), SPELL_AURA_INCREASE_SWIM_SPEED(why?)
pCurrChar->AddUnitMovementFlag(MOVEMENTFLAG_WATERWALKING);
pCurrChar->SendMovementWaterWalking();
pCurrChar->SetWaterWalking(true);
}
pCurrChar->ContinueTaxiFlight();
+2 -2
View File
@@ -1154,7 +1154,7 @@ void WorldSession::BuildPartyMemberStatsChangedPacket(Player* player, WorldPacke
if (mask & GROUP_UPDATE_FLAG_VEHICLE_SEAT)
{
if (Vehicle* veh = player->GetVehicle())
*data << uint32(veh->GetVehicleInfo()->m_seatID[player->m_movementInfo.t_seat]);
*data << uint32(veh->GetVehicleInfo()->m_seatID[player->m_movementInfo.transport.seat]);
else
*data << uint32(0);
@@ -1335,7 +1335,7 @@ void WorldSession::HandleRequestPartyMemberStatsOpcode(WorldPacket& recvData)
data.put<uint64>(maskPos, petAuraMask); // GROUP_UPDATE_FLAG_PET_AURAS
if (updateFlags & GROUP_UPDATE_FLAG_VEHICLE_SEAT)
data << uint32(player->GetVehicle()->GetVehicleInfo()->m_seatID[player->m_movementInfo.t_seat]);
data << uint32(player->GetVehicle()->GetVehicleInfo()->m_seatID[player->m_movementInfo.transport.seat]);
SendPacket(&data);
}
+11 -13
View File
@@ -292,18 +292,18 @@ void WorldSession::HandleMovementOpcodes(WorldPacket& recvPacket)
}
/* handle special cases */
if (movementInfo.t_guid)
if (movementInfo.transport.guid)
{
// transports size limited
// (also received at zeppelin leave by some reason with t_* as absolute in continent coordinates, can be safely skipped)
if (movementInfo.t_pos.GetPositionX() > 50 || movementInfo.t_pos.GetPositionY() > 50 || movementInfo.t_pos.GetPositionZ() > 50)
if (movementInfo.transport.pos.GetPositionX() > 50 || movementInfo.transport.pos.GetPositionY() > 50 || movementInfo.transport.pos.GetPositionZ() > 50)
{
recvPacket.rfinish(); // prevent warnings spam
return;
}
if (!Trinity::IsValidMapCoord(movementInfo.pos.GetPositionX() + movementInfo.t_pos.GetPositionX(), movementInfo.pos.GetPositionY() + movementInfo.t_pos.GetPositionY(),
movementInfo.pos.GetPositionZ() + movementInfo.t_pos.GetPositionZ(), movementInfo.pos.GetOrientation() + movementInfo.t_pos.GetOrientation()))
if (!Trinity::IsValidMapCoord(movementInfo.pos.GetPositionX() + movementInfo.transport.pos.GetPositionX(), movementInfo.pos.GetPositionY() + movementInfo.transport.pos.GetPositionY(),
movementInfo.pos.GetPositionZ() + movementInfo.transport.pos.GetPositionZ(), movementInfo.pos.GetOrientation() + movementInfo.transport.pos.GetOrientation()))
{
recvPacket.rfinish(); // prevent warnings spam
return;
@@ -317,7 +317,7 @@ void WorldSession::HandleMovementOpcodes(WorldPacket& recvPacket)
// elevators also cause the client to send MOVEMENTFLAG_ONTRANSPORT - just dismount if the guid can be found in the transport list
for (MapManager::TransportSet::const_iterator iter = sMapMgr->m_Transports.begin(); iter != sMapMgr->m_Transports.end(); ++iter)
{
if ((*iter)->GetGUID() == movementInfo.t_guid)
if ((*iter)->GetGUID() == movementInfo.transport.guid)
{
plrMover->m_transport = *iter;
(*iter)->AddPassenger(plrMover);
@@ -325,13 +325,13 @@ void WorldSession::HandleMovementOpcodes(WorldPacket& recvPacket)
}
}
}
else if (plrMover->GetTransport()->GetGUID() != movementInfo.t_guid)
else if (plrMover->GetTransport()->GetGUID() != movementInfo.transport.guid)
{
bool foundNewTransport = false;
plrMover->m_transport->RemovePassenger(plrMover);
for (MapManager::TransportSet::const_iterator iter = sMapMgr->m_Transports.begin(); iter != sMapMgr->m_Transports.end(); ++iter)
{
if ((*iter)->GetGUID() == movementInfo.t_guid)
if ((*iter)->GetGUID() == movementInfo.transport.guid)
{
foundNewTransport = true;
plrMover->m_transport = *iter;
@@ -343,25 +343,23 @@ void WorldSession::HandleMovementOpcodes(WorldPacket& recvPacket)
if (!foundNewTransport)
{
plrMover->m_transport = NULL;
movementInfo.t_pos.Relocate(0.0f, 0.0f, 0.0f, 0.0f);
movementInfo.t_time = 0;
movementInfo.t_seat = -1;
movementInfo.ResetTransport();
}
}
}
if (!mover->GetTransport() && !mover->GetVehicle())
{
GameObject* go = mover->GetMap()->GetGameObject(movementInfo.t_guid);
GameObject* go = mover->GetMap()->GetGameObject(movementInfo.transport.guid);
if (!go || go->GetGoType() != GAMEOBJECT_TYPE_TRANSPORT)
movementInfo.t_guid = 0;
movementInfo.transport.guid = 0;
}
}
else if (plrMover && plrMover->GetTransport()) // if we were on a transport, leave
{
plrMover->m_transport->RemovePassenger(plrMover);
plrMover->m_transport = NULL;
movementInfo.ClearTransport();
movementInfo.ResetTransport();
}
// fall damage generation (ignore in flight case that can be triggered also at lags in moment teleportation to another map).
@@ -4047,7 +4047,7 @@ enum PartyResult
};
const uint32 MMAP_MAGIC = 0x4d4d4150; // 'MMAP'
#define MMAP_VERSION 3
#define MMAP_VERSION 4
struct MmapTileHeader
{
+17 -17
View File
@@ -97,7 +97,7 @@ dtPolyRef PathGenerator::GetPathPolyByPosition(dtPolyRef const* polyPath, uint32
for (uint32 i = 0; i < polyPathSize; ++i)
{
float closestPoint[VERTEX_SIZE];
if (DT_SUCCESS != _navMeshQuery->closestPointOnPoly(polyPath[i], point, closestPoint))
if (dtStatusFailed(_navMeshQuery->closestPointOnPoly(polyPath[i], point, closestPoint)))
continue;
float d = dtVdist2DSqr(point, closestPoint);
@@ -132,8 +132,7 @@ dtPolyRef PathGenerator::GetPolyByLocation(float const* point, float* distance)
// first try with low search box
float extents[VERTEX_SIZE] = {3.0f, 5.0f, 3.0f}; // bounds of poly search area
float closestPoint[VERTEX_SIZE] = {0.0f, 0.0f, 0.0f};
dtStatus result = _navMeshQuery->findNearestPoly(point, extents, &_filter, &polyRef, closestPoint);
if (DT_SUCCESS == result && polyRef != INVALID_POLYREF)
if (dtStatusSucceed(_navMeshQuery->findNearestPoly(point, extents, &_filter, &polyRef, closestPoint)) && polyRef != INVALID_POLYREF)
{
*distance = dtVdist(closestPoint, point);
return polyRef;
@@ -141,9 +140,10 @@ dtPolyRef PathGenerator::GetPolyByLocation(float const* point, float* distance)
// still nothing ..
// try with bigger search box
extents[1] = 200.0f;
result = _navMeshQuery->findNearestPoly(point, extents, &_filter, &polyRef, closestPoint);
if (DT_SUCCESS == result && polyRef != INVALID_POLYREF)
// Note that the extent should not overlap more than 128 polygons in the navmesh (see dtNavMeshQuery::findNearestPoly)
extents[1] = 50.0f;
if (dtStatusSucceed(_navMeshQuery->findNearestPoly(point, extents, &_filter, &polyRef, closestPoint)) && polyRef != INVALID_POLYREF)
{
*distance = dtVdist(closestPoint, point);
return polyRef;
@@ -228,7 +228,7 @@ void PathGenerator::BuildPolyPath(G3D::Vector3 const& startPos, G3D::Vector3 con
{
float closestPoint[VERTEX_SIZE];
// we may want to use closestPointOnPolyBoundary instead
if (DT_SUCCESS == _navMeshQuery->closestPointOnPoly(endPoly, endPoint, closestPoint))
if (dtStatusSucceed(_navMeshQuery->closestPointOnPoly(endPoly, endPoint, closestPoint)))
{
dtVcopy(endPoint, closestPoint);
SetActualEndPosition(G3D::Vector3(endPoint[2], endPoint[0], endPoint[1]));
@@ -319,13 +319,13 @@ void PathGenerator::BuildPolyPath(G3D::Vector3 const& startPos, G3D::Vector3 con
// we need any point on our suffix start poly to generate poly-path, so we need last poly in prefix data
float suffixEndPoint[VERTEX_SIZE];
if (DT_SUCCESS != _navMeshQuery->closestPointOnPoly(suffixStartPoly, endPoint, suffixEndPoint))
if (dtStatusFailed(_navMeshQuery->closestPointOnPoly(suffixStartPoly, endPoint, suffixEndPoint)))
{
// we can hit offmesh connection as last poly - closestPointOnPoly() don't like that
// try to recover by using prev polyref
--prefixPolyLength;
suffixStartPoly = _pathPolyRefs[prefixPolyLength-1];
if (DT_SUCCESS != _navMeshQuery->closestPointOnPoly(suffixStartPoly, endPoint, suffixEndPoint))
if (dtStatusFailed(_navMeshQuery->closestPointOnPoly(suffixStartPoly, endPoint, suffixEndPoint)))
{
// suffixStartPoly is still invalid, error state
BuildShortcut();
@@ -346,7 +346,7 @@ void PathGenerator::BuildPolyPath(G3D::Vector3 const& startPos, G3D::Vector3 con
(int*)&suffixPolyLength,
MAX_PATH_LENGTH-prefixPolyLength); // max number of polygons in output path
if (!suffixPolyLength || dtResult != DT_SUCCESS)
if (!suffixPolyLength || dtStatusFailed(dtResult))
{
// this is probably an error state, but we'll leave it
// and hopefully recover on the next Update
@@ -380,7 +380,7 @@ void PathGenerator::BuildPolyPath(G3D::Vector3 const& startPos, G3D::Vector3 con
(int*)&_polyLength,
MAX_PATH_LENGTH); // max number of polygons in output path
if (!_polyLength || dtResult != DT_SUCCESS)
if (!_polyLength || dtStatusFailed(dtResult))
{
// only happens if we passed bad data to findPath(), or navmesh is messed up
TC_LOG_ERROR(LOG_FILTER_MAPS, "%u's Path Build failed: 0 length path", _sourceUnit->GetGUIDLow());
@@ -430,7 +430,7 @@ void PathGenerator::BuildPointPath(const float *startPoint, const float *endPoin
_pointPathLimit); // maximum number of points
}
if (pointCount < 2 || dtResult != DT_SUCCESS)
if (pointCount < 2 || dtStatusFailed(dtResult))
{
// only happens if pass bad data to findStraightPath or navmesh is broken
// single point paths can be generated here
@@ -577,7 +577,7 @@ bool PathGenerator::HaveTile(const G3D::Vector3& p) const
if (tx < 0 || ty < 0)
return false;
return (_navMesh->getTileAt(tx, ty) != NULL);
return (_navMesh->getTileAt(tx, ty, 0) != NULL);
}
uint32 PathGenerator::FixupCorridor(dtPolyRef* path, uint32 npath, uint32 maxPath, dtPolyRef const* visited, uint32 nvisited)
@@ -637,7 +637,7 @@ bool PathGenerator::GetSteerTarget(float const* startPos, float const* endPos,
uint32 nsteerPath = 0;
dtStatus dtResult = _navMeshQuery->findStraightPath(startPos, endPos, path, pathSize,
steerPath, steerPathFlags, steerPathPolys, (int*)&nsteerPath, MAX_STEER_POINTS);
if (!nsteerPath || DT_SUCCESS != dtResult)
if (!nsteerPath || dtStatusFailed(dtResult))
return false;
// Find vertex far enough to steer to.
@@ -674,10 +674,10 @@ dtStatus PathGenerator::FindSmoothPath(float const* startPos, float const* endPo
uint32 npolys = polyPathSize;
float iterPos[VERTEX_SIZE], targetPos[VERTEX_SIZE];
if (DT_SUCCESS != _navMeshQuery->closestPointOnPolyBoundary(polys[0], startPos, iterPos))
if (dtStatusFailed(_navMeshQuery->closestPointOnPolyBoundary(polys[0], startPos, iterPos)))
return DT_FAILURE;
if (DT_SUCCESS != _navMeshQuery->closestPointOnPolyBoundary(polys[npolys-1], endPos, targetPos))
if (dtStatusFailed(_navMeshQuery->closestPointOnPolyBoundary(polys[npolys-1], endPos, targetPos)))
return DT_FAILURE;
dtVcopy(&smoothPath[nsmoothPath*VERTEX_SIZE], iterPos);
@@ -756,7 +756,7 @@ dtStatus PathGenerator::FindSmoothPath(float const* startPos, float const* endPo
// Handle the connection.
float startPos[VERTEX_SIZE], endPos[VERTEX_SIZE];
if (DT_SUCCESS == _navMesh->getOffMeshConnectionPolyEndPoints(prevRef, polyRef, startPos, endPos))
if (dtStatusSucceed(_navMesh->getOffMeshConnectionPolyEndPoints(prevRef, polyRef, startPos, endPos)))
{
if (nsmoothPath < maxSmoothPathSize)
{
+5 -12
View File
@@ -23,10 +23,6 @@
namespace Movement{
extern float computeFallTime(float path_length, bool isSafeFall);
extern float computeFallElevation(float time_passed, bool isSafeFall, float start_velocy);
extern float computeFallElevation(float time_passed);
Location MoveSpline::ComputePosition() const
{
ASSERT(Initialized());
@@ -84,12 +80,9 @@ void MoveSpline::computeParabolicElevation(float& el) const
void MoveSpline::computeFallElevation(float& el) const
{
float z_now = spline.getPoint(spline.first()).z - Movement::computeFallElevation(MSToSec(time_passed));
float z_now = spline.getPoint(spline.first()).z - Movement::computeFallElevation(MSToSec(time_passed), false);
float final_z = FinalDestination().z;
if (z_now < final_z)
el = final_z;
else
el = z_now;
el = std::max(z_now, final_z);
}
inline uint32 computeDuration(float length, float velocity)
@@ -160,7 +153,7 @@ void MoveSpline::init_spline(const MoveSplineInitArgs& args)
point_Idx = spline.first();
}
void MoveSpline::Initialize(const MoveSplineInitArgs& args)
void MoveSpline::Initialize(MoveSplineInitArgs const& args)
{
splineflags = args.flags;
facing = args.facing;
@@ -168,7 +161,6 @@ void MoveSpline::Initialize(const MoveSplineInitArgs& args)
point_Idx_offset = args.path_Idx_offset;
initialOrientation = args.initialOrientation;
onTransport = false;
time_passed = 0;
vertical_acceleration = 0.f;
effect_start_time = 0;
@@ -196,7 +188,8 @@ void MoveSpline::Initialize(const MoveSplineInitArgs& args)
}
MoveSpline::MoveSpline() : m_Id(0), time_passed(0),
vertical_acceleration(0.f), initialOrientation(0.f), effect_start_time(0), point_Idx(0), point_Idx_offset(0)
vertical_acceleration(0.f), initialOrientation(0.f), effect_start_time(0), point_Idx(0), point_Idx_offset(0),
onTransport(false)
{
splineflags.done = true;
}
+10 -9
View File
@@ -49,6 +49,7 @@ namespace Movement
Result_NextSegment = 0x08
};
friend class PacketBuilder;
protected:
MySpline spline;
@@ -69,30 +70,30 @@ namespace Movement
int32 point_Idx_offset;
void init_spline(const MoveSplineInitArgs& args);
protected:
const MySpline::ControlArray& getPath() const { return spline.getPoints(); }
protected:
MySpline::ControlArray const& getPath() const { return spline.getPoints(); }
void computeParabolicElevation(float& el) const;
void computeFallElevation(float& el) const;
UpdateResult _updateState(int32& ms_time_diff);
int32 next_timestamp() const { return spline.length(point_Idx+1); }
int32 segment_time_elapsed() const { return next_timestamp()-time_passed; }
int32 next_timestamp() const { return spline.length(point_Idx + 1); }
int32 segment_time_elapsed() const { return next_timestamp() - time_passed; }
int32 timeElapsed() const { return Duration() - time_passed; }
int32 timePassed() const { return time_passed; }
public:
int32 Duration() const { return spline.length(); }
const MySpline& _Spline() const { return spline; }
MySpline const& _Spline() const { return spline; }
int32 _currentSplineIdx() const { return point_Idx; }
void _Finalize();
void _Interrupt() { splineflags.done = true;}
void _Interrupt() { splineflags.done = true; }
public:
void Initialize(const MoveSplineInitArgs&);
bool Initialized() const { return !spline.empty(); }
explicit MoveSpline();
MoveSpline();
template<class UpdateHandler>
void updateState(int32 difftime, UpdateHandler& handler)
@@ -116,8 +117,8 @@ namespace Movement
bool Finalized() const { return splineflags.done; }
bool isCyclic() const { return splineflags.cyclic; }
bool isFalling() const { return splineflags.falling; }
const Vector3 FinalDestination() const { return Initialized() ? spline.getPoint(spline.last()) : Vector3(); }
const Vector3 CurrentDestination() const { return Initialized() ? spline.getPoint(point_Idx+1) : Vector3(); }
Vector3 FinalDestination() const { return Initialized() ? spline.getPoint(spline.last()) : Vector3(); }
Vector3 CurrentDestination() const { return Initialized() ? spline.getPoint(point_Idx + 1) : Vector3(); }
int32 currentPathIdx() const;
bool onTransport;
@@ -104,7 +104,8 @@ namespace Movement
void EnableAnimation(uint8 anim) { raw() = (raw() & ~(Mask_Animations | Falling | Parabolic | FallingSlow)) | Animation | (anim & Mask_Animations); }
void EnableParabolic() { raw() = (raw() & ~(Mask_Animations | Falling | Animation | FallingSlow)) | Parabolic; }
void EnableFalling() { raw() = (raw() & ~(Mask_Animations | Parabolic | Animation)) | Falling; }
void EnableFlying() { raw() = (raw() & ~(Falling)) | Flying; }
void EnableFalling() { raw() = (raw() & ~(Mask_Animations | Parabolic | Animation | Flying)) | Falling; }
void EnableCatmullRom() { raw() = (raw() & ~SmoothGroundPath) | Catmullrom; }
void EnableFacingPoint() { raw() = (raw() & ~Mask_Final_Facing) | Final_Point; }
void EnableFacingAngle() { raw() = (raw() & ~Mask_Final_Facing) | Final_Angle; }
@@ -98,6 +98,8 @@ namespace Movement
uint32 moveFlagsForSpeed = moveFlags;
if (args.flags.walkmode)
moveFlagsForSpeed |= MOVEMENTFLAG_WALKING;
else
moveFlagsForSpeed &= ~MOVEMENTFLAG_WALKING;
args.velocity = unit->GetSpeed(SelectSpeedType(moveFlagsForSpeed));
}
@@ -157,7 +157,7 @@ namespace Movement
Unit* unit;
};
inline void MoveSplineInit::SetFly() { args.flags.flying = true; }
inline void MoveSplineInit::SetFly() { args.flags.EnableFlying(); }
inline void MoveSplineInit::SetWalk(bool enable) { args.flags.walkmode = enable; }
inline void MoveSplineInit::SetSmooth() { args.flags.EnableCatmullRom(); }
inline void MoveSplineInit::SetUncompressed() { args.flags.uncompressedPath = true; }
@@ -30,9 +30,9 @@ namespace Movement
union FacingInfo
{
struct{
struct {
float x, y, z;
}f;
} f;
uint64 target;
float angle;
@@ -43,8 +43,8 @@ namespace Movement
struct MoveSplineInitArgs
{
MoveSplineInitArgs(size_t path_capacity = 16) : path_Idx_offset(0),
velocity(0.f), parabolic_amplitude(0.f), time_perc(0.f), splineId(0), initialOrientation(0.f),
MoveSplineInitArgs(size_t path_capacity = 16) : path_Idx_offset(0), velocity(0.f),
parabolic_amplitude(0.f), time_perc(0.f), splineId(0), initialOrientation(0.f),
HasVelocity(false), TransformForTransport(true)
{
path.reserve(path_capacity);
@@ -64,6 +64,7 @@ namespace Movement
/** Returns true to show that the arguments were configured correctly and MoveSpline initialization will succeed. */
bool Validate(Unit* unit) const;
private:
bool _checkPathBounds() const;
};
@@ -44,6 +44,9 @@ namespace Movement
return ms / 1000.f;
}
float computeFallTime(float path_length, bool isSafeFall);
float computeFallElevation(float t_passed, bool isSafeFall, float start_velocity = 0.0f);
#ifndef static_assert
#define CONCAT(x, y) CONCAT1 (x, y)
#define CONCAT1(x, y) x##y
@@ -75,7 +78,6 @@ namespace Movement
typedef counter<uint32, 0xFFFFFFFF> UInt32Counter;
extern double gravity;
extern float computeFallElevation(float t_passed, bool isSafeFall, float start_velocity);
extern UInt32Counter splineIdGen;
extern std::string MovementFlags_ToString(uint32 flags);
extern std::string MovementFlagsExtra_ToString(uint32 flags);
@@ -30,8 +30,9 @@ namespace Movement
float terminalSafefallVelocity = 7.0f;
const float terminal_length = float(terminalVelocity * terminalVelocity) / (2.0f * gravity);
const float terminal_safefall_length = (terminalSafefallVelocity * terminalSafefallVelocity) / (2.0f * gravity);
const float terminalFallTime = float(terminalVelocity / gravity); // the time that needed to reach terminalVelocity
const float terminal_safeFall_length = (terminalSafefallVelocity * terminalSafefallVelocity) / (2.0f * gravity);
const float terminal_fallTime = float(terminalVelocity / gravity); // the time that needed to reach terminalVelocity
const float terminal_safeFall_fallTime = float(terminalSafefallVelocity / gravity); // the time that needed to reach terminalVelocity with safefall
float computeFallTime(float path_length, bool isSafeFall)
{
@@ -41,15 +42,15 @@ namespace Movement
float time;
if (isSafeFall)
{
if (path_length >= terminal_safefall_length)
time = (path_length - terminal_safefall_length) / terminalSafefallVelocity + terminalSafefallVelocity / gravity;
if (path_length >= terminal_safeFall_length)
time = (path_length - terminal_safeFall_length) / terminalSafefallVelocity + terminal_safeFall_fallTime;
else
time = sqrtf(2.0f * path_length / gravity);
}
else
{
if (path_length >= terminal_length)
time = (path_length - terminal_length) / terminalVelocity + terminalFallTime;
time = (path_length - terminal_length) / terminalVelocity + terminal_fallTime;
else
time = sqrtf(2.0f * path_length / gravity);
}
@@ -57,7 +58,7 @@ namespace Movement
return time;
}
float computeFallElevation(float t_passed, bool isSafeFall, float start_velocity)
float computeFallElevation(float t_passed, bool isSafeFall, float start_velocity /*= 0.0f*/)
{
float termVel;
float result;
@@ -70,11 +71,11 @@ namespace Movement
if (start_velocity > termVel)
start_velocity = termVel;
float terminal_time = terminalFallTime - start_velocity / gravity; // the time that needed to reach terminalVelocity
float terminal_time = (isSafeFall ? terminal_safeFall_fallTime : terminal_fallTime) - start_velocity / gravity; // the time that needed to reach terminalVelocity
if (t_passed > terminal_time)
{
result = terminalVelocity * (t_passed - terminal_time) +
result = termVel * (t_passed - terminal_time) +
start_velocity * terminal_time +
gravity * terminal_time * terminal_time*0.5f;
}
@@ -84,22 +85,6 @@ namespace Movement
return result;
}
float computeFallElevation(float t_passed)
{
float result;
if (t_passed > terminalFallTime)
{
//result = terminalVelocity * (t_passed - terminal_time) + gravity*terminal_time*terminal_time*0.5f;
// simplified view:
result = terminalVelocity * (t_passed - terminalFallTime) + terminal_length;
}
else
result = t_passed * t_passed * gravity * 0.5f;
return result;
}
#define STR(x) #x
char const* g_MovementFlag_names[] =
@@ -1216,7 +1216,6 @@ void OpcodeTable::Initialize()
DEFINE_OPCODE_HANDLER(SMSG_SPLINE_MOVE_UNROOT, STATUS_NEVER, PROCESS_INPLACE, &WorldSession::Handle_ServerSide );
DEFINE_OPCODE_HANDLER(SMSG_SPLINE_MOVE_UNSET_FLYING, STATUS_UNHANDLED, PROCESS_INPLACE, &WorldSession::Handle_ServerSide );
DEFINE_OPCODE_HANDLER(SMSG_SPLINE_MOVE_UNSET_HOVER, STATUS_NEVER, PROCESS_INPLACE, &WorldSession::Handle_ServerSide );
DEFINE_OPCODE_HANDLER(SMSG_SPLINE_MOVE_WATER_WALK, STATUS_UNHANDLED, PROCESS_INPLACE, &WorldSession::Handle_ServerSide );
DEFINE_OPCODE_HANDLER(SMSG_STABLE_RESULT, STATUS_UNHANDLED, PROCESS_INPLACE, &WorldSession::Handle_ServerSide );
DEFINE_OPCODE_HANDLER(SMSG_STANDSTATE_UPDATE, STATUS_NEVER, PROCESS_INPLACE, &WorldSession::Handle_ServerSide );
DEFINE_OPCODE_HANDLER(SMSG_START_MIRROR_TIMER, STATUS_NEVER, PROCESS_INPLACE, &WorldSession::Handle_ServerSide );
+1 -1
View File
@@ -1295,7 +1295,7 @@ enum Opcodes
SMSG_SPLINE_MOVE_SET_TURN_RATE = 0x78B5,
SMSG_SPLINE_MOVE_SET_WALK_MODE = 0x54B6,
SMSG_SPLINE_MOVE_SET_WALK_SPEED = 0x34A5,
SMSG_SPLINE_MOVE_SET_WATER_WALK = 0x0000,
SMSG_SPLINE_MOVE_SET_WATER_WALK = 0x50A2,
SMSG_SPLINE_MOVE_START_SWIM = 0x31A5,
SMSG_SPLINE_MOVE_STOP_SWIM = 0x1DA2,
SMSG_SPLINE_MOVE_UNROOT = 0x75B6,
@@ -2650,23 +2650,17 @@ void AuraEffect::HandleAuraAllowFlight(AuraApplication const* aurApp, uint8 mode
}
//! Not entirely sure if this should be sent for creatures as well, but I don't think so.
target->SetCanFly(apply);
if (!apply)
{
target->RemoveUnitMovementFlag(MOVEMENTFLAG_MASK_MOVING_FLY);
target->GetMotionMaster()->MoveFall();
target->m_movementInfo.SetFallTime(0);
target->RemoveUnitMovementFlag(MOVEMENTFLAG_MASK_MOVING_FLY);
target->AddUnitMovementFlag(MOVEMENTFLAG_FALLING);
}
Player* player = target->ToPlayer();
if (!player)
player = target->m_movedPlayer;
target->SetCanFly(apply);
if (player)
player->SendMovementCanFlyChange();
//! We still need to initiate a server-side MoveFall here,
//! which requires MSG_MOVE_FALL_LAND on landing.
if (target->GetTypeId() == TYPEID_UNIT)
target->GetMotionMaster()->MoveFall();
}
void AuraEffect::HandleAuraWaterWalk(AuraApplication const* aurApp, uint8 mode, bool apply) const
@@ -2683,12 +2677,7 @@ void AuraEffect::HandleAuraWaterWalk(AuraApplication const* aurApp, uint8 mode,
return;
}
if (apply)
target->AddUnitMovementFlag(MOVEMENTFLAG_WATERWALKING);
else
target->RemoveUnitMovementFlag(MOVEMENTFLAG_WATERWALKING);
target->SendMovementWaterWalking();
target->SetWaterWalking(apply);
}
void AuraEffect::HandleAuraFeatherFall(AuraApplication const* aurApp, uint8 mode, bool apply) const
@@ -2705,12 +2694,7 @@ void AuraEffect::HandleAuraFeatherFall(AuraApplication const* aurApp, uint8 mode
return;
}
if (apply)
target->AddUnitMovementFlag(MOVEMENTFLAG_FALLING_SLOW);
else
target->RemoveUnitMovementFlag(MOVEMENTFLAG_FALLING_SLOW);
target->SendMovementFeatherFall();
target->SetFeatherFall(apply);
// start fall from current height
if (!apply && target->GetTypeId() == TYPEID_PLAYER)
@@ -2732,7 +2716,6 @@ void AuraEffect::HandleAuraHover(AuraApplication const* aurApp, uint8 mode, bool
}
target->SetHover(apply); //! Sets movementflags
target->SendMovementHover();
}
void AuraEffect::HandleWaterBreathing(AuraApplication const* aurApp, uint8 mode, bool /*apply*/) const
@@ -3054,6 +3037,8 @@ void AuraEffect::HandleAuraModIncreaseFlightSpeed(AuraApplication const* aurApp,
return;
Unit* target = aurApp->GetTarget();
if (mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK)
target->UpdateSpeed(MOVE_FLIGHT, true);
//! Update ability to fly
if (GetAuraType() == SPELL_AURA_MOD_INCREASE_MOUNTED_FLIGHT_SPEED)
@@ -3061,22 +3046,17 @@ void AuraEffect::HandleAuraModIncreaseFlightSpeed(AuraApplication const* aurApp,
// do not remove unit flag if there are more than this auraEffect of that kind on unit on unit
if (mode & AURA_EFFECT_HANDLE_SEND_FOR_CLIENT_MASK && (apply || (!target->HasAuraType(SPELL_AURA_MOD_INCREASE_MOUNTED_FLIGHT_SPEED) && !target->HasAuraType(SPELL_AURA_FLY))))
{
target->SetCanFly(apply);
if (!apply)
{
target->m_movementInfo.SetFallTime(0);
target->RemoveUnitMovementFlag(MOVEMENTFLAG_MASK_MOVING_FLY);
target->AddUnitMovementFlag(MOVEMENTFLAG_FALLING);
}
Player* player = target->ToPlayer();
if (!player)
player = target->m_movedPlayer;
target->SetCanFly(apply);
if (player)
player->SendMovementCanFlyChange();
//! We still need to initiate a server-side MoveFall here,
//! which requires MSG_MOVE_FALL_LAND on landing.
if (target->GetTypeId() == TYPEID_UNIT)
target->GetMotionMaster()->MoveFall();
}
//! Someone should clean up these hacks and remove it from this function. It doesn't even belong here.
@@ -3091,9 +3071,6 @@ void AuraEffect::HandleAuraModIncreaseFlightSpeed(AuraApplication const* aurApp,
target->SetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID, 16314);
}
}
if (mode & AURA_EFFECT_HANDLE_CHANGE_AMOUNT_MASK)
target->UpdateSpeed(MOVE_FLIGHT, true);
}
void AuraEffect::HandleAuraModIncreaseSwimSpeed(AuraApplication const* aurApp, uint8 mode, bool /*apply*/) const
+2 -4
View File
@@ -198,16 +198,14 @@ public:
if (argstr == "off")
{
target->SetCommandStatusOff(CHEAT_WATERWALK);
target->RemoveUnitMovementFlag(MOVEMENTFLAG_WATERWALKING);
target->SendMovementWaterWalking(); // OFF
target->SetWaterWalking(false);
handler->SendSysMessage("Waterwalking is OFF. You can't walk on water.");
return true;
}
else if (argstr == "on")
{
target->SetCommandStatusOn(CHEAT_WATERWALK);
target->AddUnitMovementFlag(MOVEMENTFLAG_WATERWALKING);
target->SendMovementWaterWalking(); // ON
target->SetWaterWalking(true);
handler->SendSysMessage("Waterwalking is ON. You can walk on water.");
return true;
}
+2 -8
View File
@@ -103,15 +103,9 @@ public:
WorldPacket data;
if (strncmp(args, "on", 3) == 0)
{
target->AddUnitMovementFlag(MOVEMENTFLAG_CAN_FLY);
target->SendMovementCanFlyChange();
}
target->SetCanFly(true);
else if (strncmp(args, "off", 4) == 0)
{
target->RemoveUnitMovementFlag(MOVEMENTFLAG_CAN_FLY);
target->SendMovementCanFlyChange();
}
target->SetCanFly(false);
else
{
handler->SendSysMessage(LANG_USE_BOL);
+15 -6
View File
@@ -153,7 +153,11 @@ public:
// navmesh poly -> navmesh tile location
dtQueryFilter filter = dtQueryFilter();
dtPolyRef polyRef = INVALID_POLYREF;
navmeshquery->findNearestPoly(location, extents, &filter, &polyRef, NULL);
if (dtStatusFailed(navmeshquery->findNearestPoly(location, extents, &filter, &polyRef, NULL)))
{
handler->PSendSysMessage("Dt [??,??] (invalid poly, probably no tile loaded)");
return true;
}
if (polyRef == INVALID_POLYREF)
handler->PSendSysMessage("Dt [??, ??] (invalid poly, probably no tile loaded)");
@@ -161,11 +165,16 @@ public:
{
dtMeshTile const* tile;
dtPoly const* poly;
navmesh->getTileAndPolyByRef(polyRef, &tile, &poly);
if (tile)
handler->PSendSysMessage("Dt [%02i, %02i]", tile->header->x, tile->header->y);
else
handler->PSendSysMessage("Dt [??, ??] (no tile loaded)");
if (dtStatusSucceed(navmesh->getTileAndPolyByRef(polyRef, &tile, &poly)))
{
if (tile)
{
handler->PSendSysMessage("Dt [%02i,%02i]", tile->header->x, tile->header->y);
return false;
}
}
handler->PSendSysMessage("Dt [??,??] (no tile loaded)");
}
return true;
@@ -443,7 +443,7 @@ public:
{
me->SetVisible(false);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
me->AddUnitMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY);
me->SetDisableGravity(true);
me->SetSpeed(MOVE_WALK, 5.0f, true);
wp_reached = false;
count = 0;
@@ -476,7 +476,7 @@ public:
instance->SetData(GAMEOBJECT_PUMPKIN_SHRINE, 0); //hide gameobject
break;
case 19:
me->RemoveUnitMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY);
me->SetDisableGravity(false);
break;
case 20:
{
@@ -248,7 +248,7 @@ public:
case PHASE_GROUND:
me->CastStop(SPELL_FOG_BREATH);
me->RemoveAurasDueToSpell(SPELL_FOG_BREATH);
me->SetUnitMovementFlags(MOVEMENTFLAG_NONE);
me->StopMoving();
me->SetSpeed(MOVE_RUN, 2.0f);
events.ScheduleEvent(EVENT_CLEAVE, urand(5000, 10000));
@@ -258,7 +258,7 @@ public:
events.ScheduleEvent(EVENT_FLIGHT, 60000);
break;
case PHASE_FLIGHT:
me->SetUnitMovementFlags(MOVEMENTFLAG_DISABLE_GRAVITY);
me->SetDisableGravity(true);
events.ScheduleEvent(EVENT_FLIGHT_SEQUENCE, 1000);
uiFlightCount = 0;
uiBreathCount = 0;
@@ -254,7 +254,7 @@ public:
{
OrbsEmpowered = 0;
EmpowerCount = 0;
me->AddUnitMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY);
me->SetDisableGravity(true);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->setActive(true);
@@ -442,7 +442,7 @@ public:
summoned->CastSpell(summoned, SPELL_SHADOW_CHANNELING, false);
break;
case CREATURE_ANVEENA:
summoned->AddUnitMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY);
summoned->SetDisableGravity(true);
summoned->CastSpell(summoned, SPELL_ANVEENA_PRISON, true);
summoned->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
break;
@@ -25,7 +25,6 @@ EndScriptData */
/* ContentData
mob_jadespine_basilisk
npc_lore_keeper_of_norgannon
go_keystone_chamber
at_map_chamber
EndContentData */
@@ -479,8 +479,7 @@ public:
{
if (temp->IsAlive() && !temp->GetVictim())
{
if (temp->HasUnitMovementFlag(MOVEMENTFLAG_WALKING))
temp->SetWalk(false);
temp->SetWalk(false);
if (temp->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE))
temp->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
@@ -132,9 +132,9 @@ bool GrandChampionsOutVehicle(Creature* me)
if (pGrandChampion1 && pGrandChampion2 && pGrandChampion3)
{
if (!pGrandChampion1->m_movementInfo.t_guid &&
!pGrandChampion2->m_movementInfo.t_guid &&
!pGrandChampion3->m_movementInfo.t_guid)
if (!pGrandChampion1->m_movementInfo.transport.guid &&
!pGrandChampion2->m_movementInfo.transport.guid &&
!pGrandChampion3->m_movementInfo.transport.guid)
return true;
}
@@ -386,7 +386,7 @@ public:
}
}else uiPhaseTimer -= uiDiff;
if (!UpdateVictim() || me->m_movementInfo.t_guid)
if (!UpdateVictim() || me->m_movementInfo.transport.guid)
return;
if (uiInterceptTimer <= uiDiff)
@@ -530,7 +530,7 @@ public:
uiFireBallTimer = 5000;
} else uiFireBallTimer -= uiDiff;
if (!UpdateVictim() || me->m_movementInfo.t_guid)
if (!UpdateVictim() || me->m_movementInfo.transport.guid)
return;
if (uiFireBallTimer <= uiDiff)
@@ -668,7 +668,7 @@ public:
}
}else uiPhaseTimer -= uiDiff;
if (!UpdateVictim() || me->m_movementInfo.t_guid)
if (!UpdateVictim() || me->m_movementInfo.transport.guid)
return;
if (uiChainLightningTimer <= uiDiff)
@@ -814,7 +814,7 @@ public:
}
}else uiPhaseTimer -= uiDiff;
if (!UpdateVictim() || me->m_movementInfo.t_guid)
if (!UpdateVictim() || me->m_movementInfo.transport.guid)
return;
if (uiLightningArrowsTimer <= uiDiff)
@@ -962,7 +962,7 @@ public:
}
} else uiPhaseTimer -= uiDiff;
if (!UpdateVictim() || me->m_movementInfo.t_guid)
if (!UpdateVictim() || me->m_movementInfo.transport.guid)
return;
if (uiEviscerateTimer <= uiDiff)
@@ -431,7 +431,7 @@ class npc_jaina_or_sylvanas_hor : public CreatureScript
// Spawn LK in front of door, and make him move to the sword.
if (Creature* lichking = me->SummonCreature(NPC_LICH_KING_PART1, LichKingSpawnPos, TEMPSUMMON_MANUAL_DESPAWN))
{
lichking->SetUnitMovementFlags(MOVEMENTFLAG_WALKING);
lichking->SetWalk(true);
lichking->GetMotionMaster()->MovePoint(0, LichKingMoveThronePos);
//lichking->SetReactState(REACT_PASSIVE);
lichkingGUID = lichking->GetGUID();
@@ -494,7 +494,7 @@ class npc_jaina_or_sylvanas_hor : public CreatureScript
if (Creature* lichking = me->GetCreature(*me, lichkingGUID))
{
lichking->AI()->Talk(SAY_LK_INTRO_3);
lichking->SetUnitMovementFlags(MOVEMENTFLAG_WALKING);
lichking->SetWalk(true);
lichking->GetMotionMaster()->MovePoint(0, LichKingMoveAwayPos);
}
events.ScheduleEvent(EVENT_INTRO_LK_7, 10000);
@@ -554,7 +554,7 @@ class npc_jaina_or_sylvanas_hor : public CreatureScript
/// @todo Loralen/Koreln shall run also
if (Creature* lichking = me->SummonCreature(NPC_LICH_KING_PART1, LichKingSpawnPos, TEMPSUMMON_MANUAL_DESPAWN))
{
lichking->SetUnitMovementFlags(MOVEMENTFLAG_WALKING);
lichking->SetWalk(true);
lichking->GetMotionMaster()->MovePoint(0, LichKingMoveThronePos);
lichking->SetReactState(REACT_PASSIVE);
lichkingGUID = lichking->GetGUID();
@@ -277,7 +277,7 @@ public:
me->NearTeleportTo(pPos.GetPositionX(), pPos.GetPositionY(), pPos.GetPositionZ(), pPos.GetOrientation());
me->GetMotionMaster()->MoveChase(me->GetVictim(), 0, 0);
me->SetUnitMovementFlags(MOVEMENTFLAG_WALKING);
me->SetWalk(true);
Talk(EMOTE_ARCANE_EXPLOSION);
Talk(SAY_ARCANE_EXPLOSION);
@@ -311,11 +311,7 @@ public:
void Reset()
{
//! HACK: Creature's can't have MOVEMENTFLAG_FLYING
me->AddUnitMovementFlag(MOVEMENTFLAG_FLYING | MOVEMENTFLAG_HOVER);
me->SetSpeed(MOVE_SWIM, 1.0f);
me->SetSpeed(MOVE_RUN, 1.0f);
me->SetSpeed(MOVE_WALK, 1.0f);
//me->SetSpeed(MOVE_FLIGHT, 1.0f);
me->SetHover(true);
me->GetPosition(x, y, z);
DoTeleportTo(x+1, y, z+30);
@@ -812,7 +812,10 @@ public:
struct npc_nexus_drake_hatchlingAI : public FollowerAI //The spell who makes the npc follow the player is missing, also we can use FollowerAI!
{
npc_nexus_drake_hatchlingAI(Creature* creature) : FollowerAI(creature) {}
npc_nexus_drake_hatchlingAI(Creature* creature) : FollowerAI(creature)
{
HarpoonerGUID = 0;
}
uint64 HarpoonerGUID;
bool WithRedDragonBlood;
@@ -27,33 +27,34 @@
## Quest 12027: Mr. Floppy's Perilous Adventure
######*/
enum eFloppy
enum Floppy
{
// Creature
NPC_MRFLOPPY = 26589,
NPC_HUNGRY_WORG = 26586,
NPC_RAVENOUS_WORG = 26590, //RWORG
NPC_RAVENOUS_WORG = 26590, // RWORG
NPC_EMILY = 26588,
// Quest
QUEST_PERILOUS_ADVENTURE = 12027,
SPELL_MRFLOPPY = 47184, //vehicle aura
SAY_WORGHAGGRO1 = 0, //Um... I think one of those wolves is back...
SAY_WORGHAGGRO2 = 1, //He's going for Mr. Floppy!
SAY_WORGRAGGRO3 = 2, //Oh, no! Look, it's another wolf, and it's a biiiiiig one!
SAY_WORGRAGGRO4 = 3, //He's gonna eat Mr. Floppy! You gotta help Mr. Floppy! You just gotta!
SAY_RANDOMAGGRO = 4, //There's a big meanie attacking Mr. Floppy! Help!
SAY_VICTORY1 = 5, //Let's get out of here before more wolves find us!
SAY_VICTORY2 = 6, //Don't go toward the light, Mr. Floppy!
SAY_VICTORY3 = 7, //Mr. Floppy, you're ok! Thank you so much for saving Mr. Floppy!
SAY_VICTORY4 = 8, //I think I see the camp! We're almost home, Mr. Floppy! Let's go!
TEXT_EMOTE_WP1 = 9, //Mr. Floppy revives
TEXT_EMOTE_AGGRO = 10, //The Ravenous Worg chomps down on Mr. Floppy
SAY_QUEST_ACCEPT = 11, //Are you ready, Mr. Floppy? Stay close to me and watch out for those wolves!
SAY_QUEST_COMPLETE = 12 //Thank you for helping me get back to the camp. Go tell Walter that I'm safe now!
// Spell
SPELL_MRFLOPPY = 47184, // vehicle aura
// Text
SAY_WORGHAGGRO1 = 0, // Um... I think one of those wolves is back...
SAY_WORGHAGGRO2 = 1, // He's going for Mr. Floppy!
SAY_WORGRAGGRO3 = 2, // Oh, no! Look, it's another wolf, and it's a biiiiiig one!
SAY_WORGRAGGRO4 = 3, // He's gonna eat Mr. Floppy! You gotta help Mr. Floppy! You just gotta!
SAY_RANDOMAGGRO = 4, // There's a big meanie attacking Mr. Floppy! Help!
SAY_VICTORY1 = 5, // Let's get out of here before more wolves find us!
SAY_VICTORY2 = 6, // Don't go toward the light, Mr. Floppy!
SAY_VICTORY3 = 7, // Mr. Floppy, you're ok! Thank you so much for saving Mr. Floppy!
SAY_VICTORY4 = 8, // I think I see the camp! We're almost home, Mr. Floppy! Let's go!
TEXT_EMOTE_WP1 = 9, // Mr. Floppy revives
TEXT_EMOTE_AGGRO = 10, // The Ravenous Worg chomps down on Mr. Floppy
SAY_QUEST_ACCEPT = 11, // Are you ready, Mr. Floppy? Stay close to me and watch out for those wolves!
SAY_QUEST_COMPLETE = 12 // Thank you for helping me get back to the camp. Go tell Walter that I'm safe now!
};
//emily
// emily
class npc_emily : public CreatureScript
{
public:
@@ -63,13 +64,6 @@ public:
{
npc_emilyAI(Creature* creature) : npc_escortAI(creature) { }
uint32 m_uiChatTimer;
uint64 RWORGGUID;
uint64 MrfloppyGUID;
bool Completed;
void JustSummoned(Creature* summoned)
{
if (Creature* Mrfloppy = GetClosestCreatureWithEntry(me, NPC_MRFLOPPY, 50.0f))
@@ -88,55 +82,55 @@ public:
{
case 9:
if (Creature* Mrfloppy = GetClosestCreatureWithEntry(me, NPC_MRFLOPPY, 100.0f))
MrfloppyGUID = Mrfloppy->GetGUID();
_mrfloppyGUID = Mrfloppy->GetGUID();
break;
case 10:
if (Unit::GetCreature(*me, MrfloppyGUID))
if (Unit::GetCreature(*me, _mrfloppyGUID))
{
Talk(SAY_WORGHAGGRO1);
me->SummonCreature(NPC_HUNGRY_WORG, me->GetPositionX()+5, me->GetPositionY()+2, me->GetPositionZ()+1, 3.229f, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, 120000);
}
break;
case 11:
if (Creature* Mrfloppy = Unit::GetCreature(*me, MrfloppyGUID))
if (Creature* Mrfloppy = Unit::GetCreature(*me, _mrfloppyGUID))
Mrfloppy->GetMotionMaster()->MoveFollow(me, PET_FOLLOW_DIST, PET_FOLLOW_ANGLE);
break;
case 17:
if (Creature* Mrfloppy = Unit::GetCreature(*me, MrfloppyGUID))
if (Creature* Mrfloppy = Unit::GetCreature(*me, _mrfloppyGUID))
Mrfloppy->GetMotionMaster()->MovePoint(0, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ());
Talk(SAY_WORGRAGGRO3);
if (Creature* RWORG = me->SummonCreature(NPC_RAVENOUS_WORG, me->GetPositionX()+10, me->GetPositionY()+8, me->GetPositionZ()+2, 3.229f, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, 120000))
{
RWORG->setFaction(35);
RWORGGUID = RWORG->GetGUID();
_RavenousworgGUID = RWORG->GetGUID();
}
break;
case 18:
if (Creature* Mrfloppy = Unit::GetCreature(*me, MrfloppyGUID))
if (Creature* Mrfloppy = Unit::GetCreature(*me, _mrfloppyGUID))
{
if (Creature* RWORG = Unit::GetCreature(*me, RWORGGUID))
if (Creature* RWORG = Unit::GetCreature(*me, _RavenousworgGUID))
RWORG->GetMotionMaster()->MovePoint(0, Mrfloppy->GetPositionX(), Mrfloppy->GetPositionY(), Mrfloppy->GetPositionZ());
DoCast(Mrfloppy, SPELL_MRFLOPPY);
}
break;
case 19:
if (Creature* Mrfloppy = Unit::GetCreature(*me, MrfloppyGUID))
if (Creature* Mrfloppy = Unit::GetCreature(*me, _mrfloppyGUID))
{
if (Mrfloppy->HasAura(SPELL_MRFLOPPY, 0))
{
if (Creature* RWORG = Unit::GetCreature(*me, RWORGGUID))
if (Creature* RWORG = Unit::GetCreature(*me, _RavenousworgGUID))
Mrfloppy->EnterVehicle(RWORG);
}
}
break;
case 20:
if (Creature* RWORG = Unit::GetCreature(*me, RWORGGUID))
if (Creature* RWORG = Unit::GetCreature(*me, _RavenousworgGUID))
RWORG->HandleEmoteCommand(34);
break;
case 21:
if (Creature* Mrfloppy = Unit::GetCreature(*me, MrfloppyGUID))
if (Creature* Mrfloppy = Unit::GetCreature(*me, _mrfloppyGUID))
{
if (Creature* RWORG = Unit::GetCreature(*me, RWORGGUID))
if (Creature* RWORG = Unit::GetCreature(*me, _RavenousworgGUID))
{
RWORG->Kill(Mrfloppy);
Mrfloppy->ExitVehicle();
@@ -147,11 +141,11 @@ public:
}
break;
case 22:
if (Creature* Mrfloppy = Unit::GetCreature(*me, MrfloppyGUID))
if (Creature* Mrfloppy = Unit::GetCreature(*me, _mrfloppyGUID))
{
if (Mrfloppy->isDead())
{
if (Creature* RWORG = Unit::GetCreature(*me, RWORGGUID))
if (Creature* RWORG = Unit::GetCreature(*me, _RavenousworgGUID))
RWORG->DisappearAndDie();
me->GetMotionMaster()->MovePoint(0, Mrfloppy->GetPositionX(), Mrfloppy->GetPositionY(), Mrfloppy->GetPositionZ());
Mrfloppy->setDeathState(ALIVE);
@@ -163,7 +157,6 @@ public:
case 24:
if (player)
{
Completed = true;
player->GroupEventHappens(QUEST_PERILOUS_ADVENTURE, me);
Talk(SAY_QUEST_COMPLETE, player->GetGUID());
}
@@ -174,7 +167,7 @@ public:
break;
case 27:
me->DisappearAndDie();
if (Creature* Mrfloppy = Unit::GetCreature(*me, MrfloppyGUID))
if (Creature* Mrfloppy = Unit::GetCreature(*me, _mrfloppyGUID))
Mrfloppy->DisappearAndDie();
break;
}
@@ -187,23 +180,13 @@ public:
void Reset()
{
m_uiChatTimer = 4000;
MrfloppyGUID = 0;
RWORGGUID = 0;
_mrfloppyGUID = 0;
_RavenousworgGUID = 0;
}
void UpdateAI(uint32 uiDiff)
{
npc_escortAI::UpdateAI(uiDiff);
if (HasEscortState(STATE_ESCORT_ESCORTING))
{
if (m_uiChatTimer <= uiDiff)
m_uiChatTimer = 12000;
else
m_uiChatTimer -= uiDiff;
}
}
private:
uint64 _RavenousworgGUID;
uint64 _mrfloppyGUID;
};
bool OnQuestAccept(Player* player, Creature* creature, Quest const* quest)
@@ -226,7 +209,7 @@ public:
}
};
//mrfloppy
// mrfloppy
class npc_mrfloppy : public CreatureScript
{
public:
@@ -236,10 +219,6 @@ public:
{
npc_mrfloppyAI(Creature* creature) : ScriptedAI(creature) {}
uint64 EmilyGUID;
uint64 RWORGGUID;
uint64 HWORGGUID;
void Reset() {}
void EnterCombat(Unit* Who)
@@ -277,21 +256,21 @@ public:
}
};
// Outhouse Bunny
/*######
## Quest 12227: Doing Your Duty
######*/
enum eOuthouseBunny
enum Outhouse
{
// Sound
SOUND_FEMALE = 12671,
SOUND_MALE = 12670,
// Spell
SPELL_OUTHOUSE_GROANS = 48382,
SPELL_CAMERA_SHAKE = 47533,
SPELL_DUST_FIELD = 48329
};
enum eSounds
{
SOUND_FEMALE = 12671,
SOUND_MALE = 12670
};
class npc_outhouse_bunny : public CreatureScript
{
public:
@@ -301,32 +280,29 @@ public:
{
npc_outhouse_bunnyAI(Creature* creature) : ScriptedAI(creature) {}
uint8 m_counter;
uint8 m_gender;
void Reset()
{
m_counter = 0;
m_gender = 0;
_counter = 0;
_gender = 0;
}
void SetData(uint32 uiType, uint32 uiData)
void SetData(uint32 Type, uint32 Data)
{
if (uiType == 1)
m_gender = uiData;
if (Type == 1)
_gender = Data;
}
void SpellHit(Unit* pCaster, const SpellInfo* pSpell)
void SpellHit(Unit* Caster, const SpellInfo* Spell)
{
if (pSpell->Id == SPELL_OUTHOUSE_GROANS)
if (Spell->Id == SPELL_OUTHOUSE_GROANS)
{
++m_counter;
if (m_counter < 5)
DoCast(pCaster, SPELL_CAMERA_SHAKE, true);
++_counter;
if (_counter < 5)
DoCast(Caster, SPELL_CAMERA_SHAKE, true);
else
m_counter = 0;
_counter = 0;
DoCast(me, SPELL_DUST_FIELD, true);
switch (m_gender)
switch (_gender)
{
case GENDER_FEMALE:
DoPlaySoundToSet(me, SOUND_FEMALE);
@@ -338,6 +314,9 @@ public:
}
}
}
private:
uint8 _counter;
uint8 _gender;
};
CreatureAI* GetAI(Creature* creature) const
@@ -348,8 +327,9 @@ public:
// Tallhorn Stage
enum etallhornstage
enum TallhornStage
{
//Gameobject
OBJECT_HAUNCH = 188665
};
@@ -362,16 +342,14 @@ public:
{
npc_tallhorn_stagAI(Creature* creature) : ScriptedAI(creature) {}
uint8 m_uiPhase;
void Reset()
{
m_uiPhase = 1;
_phase = 1;
}
void UpdateAI(uint32 /*uiDiff*/)
void UpdateAI(uint32 /*diff*/)
{
if (m_uiPhase == 1)
if (_phase == 1)
{
if (me->FindNearestGameObject(OBJECT_HAUNCH, 2.0f))
{
@@ -379,10 +357,12 @@ public:
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC);
me->SetUInt32Value(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_DEAD);
}
m_uiPhase = 0;
_phase = 0;
}
DoMeleeAttackIfReady();
}
private:
uint8 _phase;
};
CreatureAI* GetAI(Creature* creature) const
@@ -393,9 +373,16 @@ public:
// Amberpine Woodsman
enum eamberpinewoodsman
enum AmberpineWoodsman
{
TALLHORN_STAG = 26363
// Creature
NPC_TALLHORN_STAG = 26363
};
enum AmberpineWoodsmanEvents
{
EVENT_WOODSMAN_1 = 1,
EVENT_WOODSMAN_2 = 2
};
class npc_amberpine_woodsman : public CreatureScript
@@ -407,48 +394,40 @@ public:
{
npc_amberpine_woodsmanAI(Creature* creature) : ScriptedAI(creature) {}
uint8 m_uiPhase;
uint32 m_uiTimer;
void Reset()
{
m_uiTimer = 0;
m_uiPhase = 1;
}
void UpdateAI(uint32 uiDiff)
{
// call this each update tick?
if (me->FindNearestCreature(TALLHORN_STAG, 0.2f))
if (me->FindNearestCreature(NPC_TALLHORN_STAG, 0.2f))
{
me->SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_STATE_USE_STANDING);
}
else
if (m_uiPhase)
{
if (m_uiTimer <= uiDiff)
{
switch (m_uiPhase)
{
case 1:
me->SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_STATE_LOOT);
m_uiTimer = 3000;
m_uiPhase = 2;
break;
case 2:
me->SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_ONESHOT_ATTACK1H);
m_uiTimer = 4000;
m_uiPhase = 1;
break;
}
}
else
m_uiTimer -= uiDiff;
}
ScriptedAI::UpdateAI(uiDiff);
_events.ScheduleEvent(EVENT_WOODSMAN_1, 0);
}
void UpdateAI(uint32 diff)
{
_events.Update(diff);
while (uint32 eventId = _events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_WOODSMAN_1:
me->SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_STATE_LOOT);
_events.ScheduleEvent(EVENT_WOODSMAN_2, 3000);
break;
case EVENT_WOODSMAN_2:
me->SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_ONESHOT_ATTACK1H);
_events.ScheduleEvent(EVENT_WOODSMAN_1, 4000);
break;
default:
break;
}
}
UpdateVictim();
}
private:
EventMap _events;
};
CreatureAI* GetAI(Creature* creature) const
@@ -456,16 +435,20 @@ public:
return new npc_amberpine_woodsmanAI(creature);
}
};
/*######
## Quest 12288: Overwhelmed!
######*/
enum eSkirmisher
enum Skirmisher
{
// Quest
QUEST_OVERWHELMED = 12288,
// Spell
SPELL_RENEW_SKIRMISHER = 48812,
CREDIT_NPC = 27466,
RANDOM_SAY = 0,
SPELL_KILL_CREDIT = 48813,
// Text
SAY_RANDOM = 0
};
class npc_wounded_skirmisher : public CreatureScript
@@ -477,35 +460,31 @@ public:
{
npc_wounded_skirmisherAI(Creature* creature) : ScriptedAI(creature) {}
uint64 uiPlayerGUID;
uint32 DespawnTimer;
void Reset()
{
DespawnTimer = 5000;
uiPlayerGUID = 0;
_despawnTimer = 5000;
_playerGUID = 0;
}
void MovementInform(uint32, uint32 id)
{
if (id == 1)
me->DespawnOrUnsummon(DespawnTimer);
me->DespawnOrUnsummon(_despawnTimer);
}
void SpellHit(Unit* caster, const SpellInfo* spell)
{
if (spell->Id == SPELL_RENEW_SKIRMISHER && caster->GetTypeId() == TYPEID_PLAYER
&& caster->ToPlayer()->GetQuestStatus(12288) == QUEST_STATUS_INCOMPLETE)
&& caster->ToPlayer()->GetQuestStatus(QUEST_OVERWHELMED) == QUEST_STATUS_INCOMPLETE)
{
caster->ToPlayer()->KilledMonsterCredit(CREDIT_NPC, 0);
sCreatureTextMgr->SendChat(me, RANDOM_SAY, 0, CHAT_MSG_ADDON, LANG_ADDON, TEXT_RANGE_NORMAL, 0, TEAM_OTHER, false, caster->ToPlayer());
DoCast(caster, SPELL_KILL_CREDIT);
Talk(SAY_RANDOM);
if (me->IsStandState())
me->GetMotionMaster()->MovePoint(1, me->GetPositionX()+7, me->GetPositionY()+7, me->GetPositionZ());
else
{
me->SetStandState(UNIT_STAND_STATE_STAND);
me->DespawnOrUnsummon(DespawnTimer);
me->DespawnOrUnsummon(_despawnTimer);
}
}
}
@@ -517,6 +496,9 @@ public:
DoMeleeAttackIfReady();
}
private:
uint64 _playerGUID;
uint32 _despawnTimer;
};
CreatureAI* GetAI(Creature* creature) const
@@ -526,15 +508,22 @@ public:
};
/*Lightning Sentry - if you kill it when you have your Minion with you, you will get a quest credit*/
enum eSentry
enum Sentry
{
QUEST_OR_MAYBE_WE_DONT_A = 12138,
QUEST_OR_MAYBE_WE_DONT_H = 12198,
//Creature
NPC_LIGHTNING_SENTRY = 26407,
NPC_WAR_GOLEM = 27017,
// Quest
QUEST_OR_MAYBE_WE_DONT_A = 12138,
QUEST_OR_MAYBE_WE_DONT_H = 12198,
// Spell
SPELL_CHARGED_SENTRY_TOTEM = 52703,
SPELL_WAR_GOLEM_CHARGE_CREDIT = 47797,
};
NPC_LIGHTNING_SENTRY = 26407,
NPC_WAR_GOLEM = 27017,
SPELL_CHARGED_SENTRY_TOTEM = 52703,
enum SentryEvents
{
EVENT_SENTRY = 1
};
class npc_lightning_sentry : public CreatureScript
@@ -542,34 +531,37 @@ class npc_lightning_sentry : public CreatureScript
public:
npc_lightning_sentry() : CreatureScript("npc_lightning_sentry") { }
CreatureAI* GetAI(Creature* creature) const
{
return new npc_lightning_sentryAI(creature);
}
struct npc_lightning_sentryAI : public ScriptedAI
{
npc_lightning_sentryAI(Creature* creature) : ScriptedAI(creature) { }
uint32 uiChargedSentryTotem;
void Reset()
{
uiChargedSentryTotem = urand(10000, 12000);
_events.ScheduleEvent(EVENT_SENTRY, urand(10000, 12000));
}
void UpdateAI(uint32 uiDiff)
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
if (uiChargedSentryTotem <= uiDiff)
_events.Update(diff);
while (uint32 eventId = _events.ExecuteEvent())
{
DoCast(SPELL_CHARGED_SENTRY_TOTEM);
uiChargedSentryTotem = urand(10000, 12000);
switch (eventId)
{
case EVENT_SENTRY:
DoCast(SPELL_CHARGED_SENTRY_TOTEM);
_events.ScheduleEvent(EVENT_SENTRY, urand(10000, 12000));
break;
default:
break;
}
}
else
uiChargedSentryTotem -= uiDiff;
if (!UpdateVictim())
return;
DoMeleeAttackIfReady();
}
@@ -582,108 +574,117 @@ public:
{
if (killer->ToPlayer()->GetQuestStatus(QUEST_OR_MAYBE_WE_DONT_A) == QUEST_STATUS_INCOMPLETE ||
killer->ToPlayer()->GetQuestStatus(QUEST_OR_MAYBE_WE_DONT_H) == QUEST_STATUS_INCOMPLETE)
killer->ToPlayer()->KilledMonsterCredit(NPC_WAR_GOLEM, 0);
DoCast(killer, SPELL_WAR_GOLEM_CHARGE_CREDIT);
}
}
}
private:
EventMap _events;
};
CreatureAI* GetAI(Creature* creature) const
{
return new npc_lightning_sentryAI(creature);
}
};
/*Venture co. Straggler - when you cast Smoke Bomb, he will yell and run away*/
enum eSmokeEmOut
enum SmokeEmOut
{
SAY_SEO = 0,
// Quest
QUEST_SMOKE_EM_OUT_A = 12323,
QUEST_SMOKE_EM_OUT_H = 12324,
// Spell
SPELL_SMOKE_BOMB = 49075,
SPELL_CHOP = 43410,
SPELL_VENTURE_STRAGGLER_CREDIT = 49093,
// Text
SAY_SEO = 0
};
enum StragglerEvents
{
EVENT_STRAGGLER_1 = 1,
EVENT_STRAGGLER_2 = 2,
EVENT_STRAGGLER_3 = 3,
EVENT_STRAGGLER_4 = 4,
EVENT_CHOP = 5
};
class npc_venture_co_straggler : public CreatureScript
{
public:
npc_venture_co_straggler() : CreatureScript("npc_venture_co_straggler") { }
public:
npc_venture_co_straggler() : CreatureScript("npc_venture_co_straggler") { }
struct npc_venture_co_stragglerAI : public ScriptedAI
struct npc_venture_co_stragglerAI : public ScriptedAI
{
npc_venture_co_stragglerAI(Creature* creature) : ScriptedAI(creature) { }
void Reset()
{
npc_venture_co_stragglerAI(Creature* creature) : ScriptedAI(creature) { }
_playerGUID = 0;
uint64 uiPlayerGUID;
uint32 uiRunAwayTimer;
uint32 uiTimer;
uint32 uiChopTimer;
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_IMMUNE_TO_PC);
me->SetReactState(REACT_AGGRESSIVE);
}
void Reset()
void UpdateAI(uint32 diff)
{
_events.Update(diff);
while (uint32 eventId = _events.ExecuteEvent())
{
uiPlayerGUID = 0;
uiTimer = 0;
uiRunAwayTimer = 0;
uiChopTimer = urand(10000, 12500);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_IMMUNE_TO_PC);
me->SetReactState(REACT_AGGRESSIVE);
}
void UpdateAI(uint32 uiDiff)
{
if (uiPlayerGUID && uiRunAwayTimer <= uiDiff)
switch (eventId)
{
if (Player* player = Unit::GetPlayer(*me, uiPlayerGUID))
{
switch (uiTimer)
{
case 0:
DoCast(player, SPELL_VENTURE_STRAGGLER_CREDIT);
me->GetMotionMaster()->MovePoint(0, me->GetPositionX()-7, me->GetPositionY()+7, me->GetPositionZ());
uiRunAwayTimer = 2500;
++uiTimer;
break;
case 1:
Talk(SAY_SEO);
me->GetMotionMaster()->MovePoint(0, me->GetPositionX()-7, me->GetPositionY()-5, me->GetPositionZ());
uiRunAwayTimer = 2500;
++uiTimer;
break;
case 2:
me->GetMotionMaster()->MovePoint(0, me->GetPositionX()-5, me->GetPositionY()-5, me->GetPositionZ());
uiRunAwayTimer = 2500;
++uiTimer;
break;
case 3:
me->DisappearAndDie();
uiTimer = 0;
break;
}
}
}
else if (uiRunAwayTimer)
uiRunAwayTimer -= uiDiff;
if (!UpdateVictim())
return;
if (uiChopTimer <= uiDiff)
{
DoCast(me->GetVictim(), SPELL_CHOP);
uiChopTimer = urand(10000, 12000);
}
else
uiChopTimer -= uiDiff;
DoMeleeAttackIfReady();
}
void SpellHit(Unit* caster, SpellInfo const* spell)
{
if (spell->Id == SPELL_SMOKE_BOMB && caster->GetTypeId() == TYPEID_PLAYER)
{
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_IMMUNE_TO_PC);
me->SetReactState(REACT_PASSIVE);
me->CombatStop(false);
uiPlayerGUID = caster->GetGUID();
uiRunAwayTimer = 3500;
case EVENT_STRAGGLER_1:
if (Player* player = Unit::GetPlayer(*me, _playerGUID))
DoCast(player, SPELL_VENTURE_STRAGGLER_CREDIT);
me->GetMotionMaster()->MovePoint(0, me->GetPositionX()-7, me->GetPositionY()+7, me->GetPositionZ());
_events.ScheduleEvent(EVENT_STRAGGLER_2, 2500);
break;
case EVENT_STRAGGLER_2:
Talk(SAY_SEO);
me->GetMotionMaster()->MovePoint(0, me->GetPositionX()-7, me->GetPositionY()-5, me->GetPositionZ());
_events.ScheduleEvent(EVENT_STRAGGLER_3, 2500);
break;
case EVENT_STRAGGLER_3:
me->GetMotionMaster()->MovePoint(0, me->GetPositionX()-5, me->GetPositionY()-5, me->GetPositionZ());
_events.ScheduleEvent(EVENT_STRAGGLER_4, 2500);
break;
case EVENT_STRAGGLER_4:
me->DisappearAndDie();
break;
case EVENT_CHOP:
if (UpdateVictim())
DoCast(me->GetVictim(), SPELL_CHOP);
_events.ScheduleEvent(EVENT_CHOP, 10000, 12000);
break;
default:
break;
}
}
if (!UpdateVictim())
return;
DoMeleeAttackIfReady();
}
void SpellHit(Unit* caster, SpellInfo const* spell)
{
if (spell->Id == SPELL_SMOKE_BOMB && caster->GetTypeId() == TYPEID_PLAYER)
{
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_IMMUNE_TO_PC);
me->SetReactState(REACT_PASSIVE);
me->CombatStop(false);
_playerGUID = caster->GetGUID();
_events.ScheduleEvent(EVENT_STRAGGLER_1, 3500);
}
}
private:
EventMap _events;
uint64 _playerGUID;
};
CreatureAI* GetAI(Creature* creature) const
@@ -693,26 +694,24 @@ class npc_venture_co_straggler : public CreatureScript
};
/*######
## Quest A Blade Fit For A Champion
## Quest: A Blade Fit For A Champion
######*/
enum LakeFrog
{
// Creature
NPC_LAKE_FROG = 33211,
NPC_LAKE_FROG_QUEST = 33224,
NPC_MAIDEN_OF_ASHWOOD_LAKE = 33220,
// Items
ITEM_WARTS_B_GONE_LIP_BALM = 44986,
// Spells
SPELL_WARTSBGONE_LIP_BALM = 62574,
SPELL_FROG_LOVE = 62537, // for 1 minute !
SPELL_WARTS = 62581,
SPELL_MAIDEN_OF_ASHWOOD_LAKE_TRANSFORM = 62550,
SPELL_SUMMON_ASHWOOD_BRAND = 62554,
// Items
ITEM_WARTS_B_GONE_LIP_BALM = 44986,
// Creature
NPC_LAKE_FROG = 33211,
NPC_LAKE_FROG_QUEST = 33224,
NPC_MAIDEN_OF_ASHWOOD_LAKE = 33220,
SPELL_FROG_KISS = 62536,
// Text
SAY_MAIDEN_0 = 0,
SAY_MAIDEN_1 = 1
@@ -720,17 +719,17 @@ enum LakeFrog
enum LakeFrogEvents
{
EVENT_SCRIPT_1 = 1,
EVENT_SCRIPT_2 = 2,
EVENT_SCRIPT_3 = 3,
EVENT_SCRIPT_4 = 4,
EVENT_SCRIPT_5 = 5
EVENT_LAKEFROG_1 = 1,
EVENT_LAKEFROG_2 = 2,
EVENT_LAKEFROG_3 = 3,
EVENT_LAKEFROG_4 = 4,
EVENT_LAKEFROG_5 = 5
};
class npc_lake_frog : public CreatureScript
{
public:
npc_lake_frog() : CreatureScript("npc_lake_frog") { }
public:
npc_lake_frog() : CreatureScript("npc_lake_frog") { }
struct npc_lake_frogAI : public ScriptedAI
{
@@ -756,24 +755,24 @@ class npc_lake_frog : public CreatureScript
{
switch (eventId)
{
case EVENT_SCRIPT_1:
case EVENT_LAKEFROG_1:
DoCast(me, SPELL_MAIDEN_OF_ASHWOOD_LAKE_TRANSFORM);
me->SetEntry(NPC_MAIDEN_OF_ASHWOOD_LAKE);
_events.ScheduleEvent(EVENT_SCRIPT_2, 2000);
_events.ScheduleEvent(EVENT_LAKEFROG_2, 2000);
break;
case EVENT_SCRIPT_2:
case EVENT_LAKEFROG_2:
Talk(SAY_MAIDEN_0);
_events.ScheduleEvent(EVENT_SCRIPT_3, 3000);
_events.ScheduleEvent(EVENT_LAKEFROG_3, 3000);
break;
case EVENT_SCRIPT_3:
case EVENT_LAKEFROG_3:
me->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
_events.ScheduleEvent(EVENT_SCRIPT_4, 25000);
_events.ScheduleEvent(EVENT_LAKEFROG_4, 25000);
break;
case EVENT_SCRIPT_4:
case EVENT_LAKEFROG_4:
me->RemoveFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
_events.ScheduleEvent(EVENT_SCRIPT_5, 2000);
_events.ScheduleEvent(EVENT_LAKEFROG_5, 2000);
break;
case EVENT_SCRIPT_5:
case EVENT_LAKEFROG_5:
Talk(SAY_MAIDEN_1);
me->DespawnOrUnsummon(4000);
break;
@@ -794,7 +793,7 @@ class npc_lake_frog : public CreatureScript
player->AddAura(SPELL_WARTS, player);
else
{
player->RemoveAura(SPELL_WARTSBGONE_LIP_BALM);
DoCast(player, SPELL_FROG_KISS); // Removes SPELL_WARTSBGONE_LIP_BALM
if (me->GetEntry() == NPC_LAKE_FROG)
{
@@ -807,7 +806,7 @@ class npc_lake_frog : public CreatureScript
me->GetMotionMaster()->MoveIdle();
me->SetFacingToObject(player);
_runningScript = true;
_events.ScheduleEvent(EVENT_SCRIPT_1, 2000);
_events.ScheduleEvent(EVENT_LAKEFROG_1, 2000);
}
}
}
@@ -186,7 +186,7 @@ public:
if (!summonerGUID)
return;
me->SetUnitMovementFlags(MOVEMENTFLAG_WALKING);
me->SetWalk(true);
Start(false, false, summonerGUID);
}
@@ -98,13 +98,13 @@ public:
case 16:
case 17:
case 18:
me->RemoveUnitMovementFlag(MOVEMENTFLAG_SWIMMING);
me->RemoveUnitMovementFlag(MOVEMENTFLAG_FALLING);
me->SetSpeed(MOVE_SWIM, 0.85f, true);
me->AddUnitMovementFlag(MOVEMENTFLAG_SWIMMING | MOVEMENTFLAG_DISABLE_GRAVITY);
me->SetSwim(true);
me->SetDisableGravity(true);
break;
case 19:
me->SetUnitMovementFlags(MOVEMENTFLAG_FALLING);
me->GetMotionMaster()->MoveFall();
break;
case 28:
player->GroupEventHappens(QUEST_FORTUNATE_MISUNDERSTANDINGS, me);
@@ -148,7 +148,6 @@ public:
{
CAST_AI(npc_escortAI, (creature->AI()))->Start(true, false, player->GetGUID());
CAST_AI(npc_escortAI, (creature->AI()))->SetMaxPlayerDistance(35.0f);
creature->SetUnitMovementFlags(MOVEMENTFLAG_FALLING);
creature->AI()->Talk(SAY_START_IRO);
switch (player->GetTeam()){
+539 -4
View File
@@ -21,12 +21,15 @@
#include "ScriptedEscortAI.h"
#include "Player.h"
#include "SpellInfo.h"
#include "SpellScript.h"
#include "SpellAuras.h"
#include "SpellAuraEffects.h"
/*####
## npc_drakuru_shackles
####*/
enum eDrakuruShackles
enum DrakuruShackles
{
SPELL_LEFT_CHAIN = 59951,
SPELL_RIGHT_CHAIN = 59952,
@@ -34,7 +37,7 @@ enum eDrakuruShackles
SPELL_FREE_RAGECLAW = 55223,
NPC_RAGECLAW = 29686,
QUEST_TROLLS_IS_GONE_CRAZY = 12861,
QUEST_TROLLS_IS_GONE_CRAZY = 12861
};
class npc_drakuru_shackles : public CreatureScript
@@ -115,7 +118,7 @@ public:
## npc_captured_rageclaw
####*/
enum eRageclaw
enum Rageclaw
{
SPELL_UNSHACKLED = 55085,
SPELL_KNEEL = 39656
@@ -1384,7 +1387,7 @@ public:
## go_scourge_enclosure
######*/
enum eScourgeEnclosure
enum ScourgeEnclosure
{
QUEST_OUR_ONLY_HOPE = 12916,
NPC_GYMER_DUMMY = 29928 //from quest template
@@ -1412,6 +1415,532 @@ public:
}
};
/*######
## Quest: Troll Patrol: The Alchemist's Apprentice
######*/
enum Finklestein
{
// Creature
NPC_FINKLESTEIN = 28205,
// Item
ITEM_KNOTROOT = 38338,
ITEM_PICKLED_EAGLE_EGG = 38341,
ITEM_SPECKLED_GUANO = 38337,
ITEM_WITHERED_BATWING = 38339,
ITEM_SEASONED_SLIDER_CIDER = 38381,
ITEM_PULVERIZED_GARGOYLE_TEETH = 38384,
ITEM_MUDDY_MIRE_MAGGOT = 38386,
ITEM_SPIKY_SPIDER_EGG = 38393,
ITEM_HAIRY_HERRING_HEAD = 38396,
ITEM_PUTRID_PIRATE_PERSPIRATION = 38397,
ITEM_ICECROWN_BOTTLED_WATER = 38398,
ITEM_WASPS_WINGS = 38369,
ITEM_PRISMATIC_MOJO = 38343,
ITEM_RAPTOR_CLAW = 38370,
ITEM_AMBERSEED = 38340,
ITEM_SHRUNKEN_DRAGONS_CLAW = 38344,
ITEM_CHILLED_SERPENT_MUCUS = 38346,
ITEM_CRYSTALLIZED_HOGSNOT = 38336,
ITEM_CRUSHED_BASILISK_CRYSTALS = 38379,
ITEM_TROLLBANE = 38342,
ITEM_FROZEN_SPIDER_ICHOR = 38345,
// Quest
QUEST_THE_ALCHEMIST_APPRENTICE_DAILY = 12541,
// Spells
SPELL_ALCHEMIST_APPRENTICE_INVISBUFF = 51216,
SPELL_RANDOM_INGREDIENT_EASY_AURA = 51015,
SPELL_RANDOM_INGREDIENT_MEDIUM_AURA = 51154,
SPELL_RANDOM_INGREDIENT_HARD_AURA = 51157,
SPELL_RANDOM_INGREDIENT_EASY = 51134,
SPELL_RANDOM_INGREDIENT_MEDIUM = 51105,
SPELL_RANDOM_INGREDIENT_HARD = 51107,
SPELL_NEXT_INGREDIENT = 51049,
SPELL_POT_CHECK = 51046,
SPELL_THROW_INGREDIENT = 51025,
SPELL_KILL_CREDIT = 51111,
// Spell Fetch Easy
SPELL_FETCH_KNOTROOT = 51018,
SPELL_FETCH_PICKLED_EAGLE_EGG = 51055,
SPELL_FETCH_SPECKLED_GUANO = 51057,
SPELL_FETCH_WITHERED_BATWING = 51059,
SPELL_FETCH_SEASONED_SLIDER_CIDER = 51062,
SPELL_FETCH_PULVERIZED_GARGOYLE_TEETH = 51064,
SPELL_FETCH_MUDDY_MIRE_MAGGOT = 51067,
SPELL_FETCH_SPIKY_SPIDER_EGG = 51069,
SPELL_FETCH_HAIRY_HERRING_HEAD = 51072,
SPELL_FETCH_PUTRID_PIRATE_PERSPIRATION = 51077,
SPELL_FETCH_ICECROWN_BOTTLED_WATER = 51079,
// Spell Have Easy
SPELL_HAVE_KNOTROOT = 51047,
SPELL_HAVE_PICKLED_EAGLE_EGG = 51056,
SPELL_HAVE_SPECKLED_GUANO = 51058,
SPELL_HAVE_WITHERED_BATWING = 51060,
SPELL_HAVE_SEASONED_SLIDER_CIDER = 51063,
SPELL_HAVE_PULVERIZED_GARGOYLE_TEETH = 51065,
SPELL_HAVE_MUDDY_MIRE_MAGGOT = 51068,
SPELL_HAVE_SPIKY_SPIDER_EGG = 51070,
SPELL_HAVE_HAIRY_HERRING_HEAD = 51075,
SPELL_HAVE_PUTRID_PIRATE_PERSPIRATION = 51078,
SPELL_HAVE_ICECROWN_BOTTLED_WATER = 51080,
// Spell Fetch Medium
SPELL_FETCH_WASPS_WINGS = 51081,
SPELL_FETCH_PRISMATIC_MOJO = 51083,
SPELL_FETCH_RAPTOR_CLAW = 51085,
SPELL_FETCH_AMBERSEED = 51087,
SPELL_FETCH_SHRUNKEN_DRAGONS_CLAW = 51091,
// Spell Have Medium
SPELL_HAVE_WASPS_WINGS = 51082,
SPELL_HAVE_PRISMATIC_MOJO = 51084,
SPELL_HAVE_RAPTOR_CLAW = 51086,
SPELL_HAVE_AMBERSEED = 51088,
SPELL_HAVE_SHRUNKEN_DRAGONS_CLAW = 51092,
// Spell Fetch Hard
SPELL_FETCH_CHILLED_SERPENT_MUCUS = 51093,
SPELL_FETCH_CRYSTALLIZED_HOGSNOT = 51095,
SPELL_FETCH_CRUSHED_BASILISK_CRYSTALS = 51097,
SPELL_FETCH_TROLLBANE = 51100,
SPELL_FETCH_FROZEN_SPIDER_ICHOR = 51102,
// Spell Have Hard
SPELL_HAVE_CHILLED_SERPENT_MUCUS = 51094,
SPELL_HAVE_CRYSTALLIZED_HOGSNOT = 51096,
SPELL_HAVE_CRUSHED_BASILISK_CRYSTALS = 51098,
SPELL_HAVE_TROLLBANE = 51101,
SPELL_HAVE_FROZEN_SPIDER_ICHOR = 51104,
// Text
SAY_EASY_123 = 0,
SAY_MEDIUM_4 = 1,
SAY_MEDIUM_5 = 2,
SAY_HARD_6 = 3,
SAY_RUINED = 4,
// Text Easy
SAY_KNOTROOT = 5,
SAY_PICKLED_EAGLE_EGG = 6,
SAY_SPECKLED_GUANO = 7,
SAY_WITHERED_BATWING = 8,
SAY_SEASONED_SLIDER_CIDER = 9,
SAY_PULVERIZED_GARGOYLE_TEETH = 10,
SAY_MUDDY_MIRE_MAGGOT = 11,
SAY_SPIKY_SPIDER_EGG = 12,
SAY_HAIRY_HERRING_HEAD = 13,
SAY_PUTRID_PIRATE_PERSPIRATION = 14,
SAY_ICECROWN_BOTTLED_WATER = 15,
// Text Medium
SAY_WASPS_WINGS = 16,
SAY_PRISMATIC_MOJO = 17,
SAY_RAPTOR_CLAW = 18,
SAY_AMBERSEED = 19,
SAY_SHRUNKEN_DRAGONS_CLAW = 20,
// Text Hard
SAY_CHILLED_SERPENT_MUCUS = 21,
SAY_CRYSTALLIZED_HOGSNOT = 22,
SAY_CRUSHED_BASILISK_CRYSTALS = 23,
SAY_TROLLBANE = 24,
SAY_FROZEN_SPIDER_ICHOR = 25
};
enum FinklesteinEvents
{
EVENT_TURN_TO_POT = 1,
EVENT_TURN_BACK = 2,
EVENT_EASY_123 = 3,
EVENT_MEDIUM_4 = 4,
EVENT_MEDIUM_5 = 5,
EVENT_HARD_6 = 6
};
class npc_alchemist_finklestein : public CreatureScript
{
public:
npc_alchemist_finklestein() : CreatureScript("npc_alchemist_finklestein") { }
struct npc_alchemist_finklesteinAI : public ScriptedAI
{
npc_alchemist_finklesteinAI(Creature* creature) : ScriptedAI(creature) { }
void Reset()
{
_events.ScheduleEvent(EVENT_TURN_TO_POT, urand(15000, 26000));
}
void SetData(uint32 Type, uint32 Data)
{
if (Type == 1 && Data == 1)
switch (_getingredienttry)
{
case 2:
case 3:
_events.ScheduleEvent(EVENT_EASY_123, 100);
break;
case 4:
_events.ScheduleEvent(EVENT_MEDIUM_4, 100);
break;
case 5:
_events.ScheduleEvent(EVENT_MEDIUM_5, 100);
break;
case 6:
_events.ScheduleEvent(EVENT_HARD_6, 100);
break;
default:
break;
}
}
void UpdateAI(uint32 diff)
{
_events.Update(diff);
while (uint32 eventId = _events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_TURN_TO_POT:
me->SetFacingTo(6.230825f);
me->SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_STATE_USE_STANDING_NO_SHEATHE);
_events.ScheduleEvent(EVENT_TURN_BACK, 11000);
break;
case EVENT_TURN_BACK:
me->SetFacingTo(4.886922f);
me->SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_STATE_NONE);
_events.ScheduleEvent(EVENT_TURN_TO_POT, urand(25000, 41000));
break;
case EVENT_EASY_123:
if (Player* player = Unit::GetPlayer(*me, _playerGUID))
{
Talk(SAY_EASY_123, _playerGUID);
DoCast(player, SPELL_RANDOM_INGREDIENT_EASY_AURA);
++_getingredienttry;
}
break;
case EVENT_MEDIUM_4:
if (Player* player = Unit::GetPlayer(*me, _playerGUID))
{
Talk(SAY_MEDIUM_4, _playerGUID);
DoCast(player, SPELL_RANDOM_INGREDIENT_MEDIUM_AURA);
++_getingredienttry;
}
break;
case EVENT_MEDIUM_5:
if (Player* player = Unit::GetPlayer(*me, _playerGUID))
{
Talk(SAY_MEDIUM_5, _playerGUID);
DoCast(player, SPELL_RANDOM_INGREDIENT_MEDIUM_AURA);
++_getingredienttry;
}
break;
case EVENT_HARD_6:
if (Player* player = Unit::GetPlayer(*me, _playerGUID))
{
Talk(SAY_HARD_6, _playerGUID);
DoCast(player, SPELL_RANDOM_INGREDIENT_HARD_AURA);
++_getingredienttry;
}
break;
default:
break;
}
}
}
void sGossipSelect(Player* player, uint32 /*sender*/, uint32 /*action*/)
{
player->CLOSE_GOSSIP_MENU();
DoCast(player, SPELL_ALCHEMIST_APPRENTICE_INVISBUFF);
_playerGUID = player->GetGUID();
_getingredienttry = 1;
_events.ScheduleEvent(EVENT_EASY_123, 100);
}
private:
EventMap _events;
uint64 _playerGUID;
uint8 _getingredienttry;
};
CreatureAI* GetAI(Creature* creature) const
{
return new npc_alchemist_finklesteinAI(creature);
}
};
class go_finklesteins_cauldron : public GameObjectScript
{
public:
go_finklesteins_cauldron() : GameObjectScript("go_finklesteins_cauldron") { }
bool OnGossipHello(Player* player, GameObject* /*go*/)
{
player->CastSpell(player, SPELL_POT_CHECK);
return true;
}
};
uint32 const FetchIngredients[21] [4] =
{
{ SPELL_FETCH_KNOTROOT, SPELL_HAVE_KNOTROOT, ITEM_KNOTROOT, SAY_KNOTROOT },
{ SPELL_FETCH_PICKLED_EAGLE_EGG, SPELL_HAVE_PICKLED_EAGLE_EGG, ITEM_PICKLED_EAGLE_EGG, SAY_PICKLED_EAGLE_EGG },
{ SPELL_FETCH_SPECKLED_GUANO, SPELL_HAVE_SPECKLED_GUANO, ITEM_SPECKLED_GUANO, SAY_SPECKLED_GUANO },
{ SPELL_FETCH_WITHERED_BATWING, SPELL_HAVE_WITHERED_BATWING, ITEM_WITHERED_BATWING, SAY_WITHERED_BATWING },
{ SPELL_FETCH_SEASONED_SLIDER_CIDER, SPELL_HAVE_SEASONED_SLIDER_CIDER, ITEM_SEASONED_SLIDER_CIDER, SAY_SEASONED_SLIDER_CIDER },
{ SPELL_FETCH_PULVERIZED_GARGOYLE_TEETH, SPELL_HAVE_PULVERIZED_GARGOYLE_TEETH, ITEM_PULVERIZED_GARGOYLE_TEETH, SAY_PULVERIZED_GARGOYLE_TEETH },
{ SPELL_FETCH_MUDDY_MIRE_MAGGOT, SPELL_HAVE_MUDDY_MIRE_MAGGOT, ITEM_MUDDY_MIRE_MAGGOT, SAY_MUDDY_MIRE_MAGGOT },
{ SPELL_FETCH_SPIKY_SPIDER_EGG, SPELL_HAVE_SPIKY_SPIDER_EGG, ITEM_SPIKY_SPIDER_EGG, SAY_SPIKY_SPIDER_EGG },
{ SPELL_FETCH_HAIRY_HERRING_HEAD, SPELL_HAVE_HAIRY_HERRING_HEAD, ITEM_HAIRY_HERRING_HEAD, SAY_HAIRY_HERRING_HEAD },
{ SPELL_FETCH_PUTRID_PIRATE_PERSPIRATION, SPELL_HAVE_PUTRID_PIRATE_PERSPIRATION, ITEM_PUTRID_PIRATE_PERSPIRATION, SAY_PUTRID_PIRATE_PERSPIRATION },
{ SPELL_FETCH_ICECROWN_BOTTLED_WATER, SPELL_HAVE_ICECROWN_BOTTLED_WATER, ITEM_ICECROWN_BOTTLED_WATER, SAY_ICECROWN_BOTTLED_WATER },
{ SPELL_FETCH_WASPS_WINGS, SPELL_HAVE_WASPS_WINGS, ITEM_WASPS_WINGS, SAY_WASPS_WINGS },
{ SPELL_FETCH_PRISMATIC_MOJO, SPELL_HAVE_PRISMATIC_MOJO, ITEM_PRISMATIC_MOJO, SAY_PRISMATIC_MOJO },
{ SPELL_FETCH_RAPTOR_CLAW, SPELL_HAVE_RAPTOR_CLAW, ITEM_RAPTOR_CLAW, SAY_RAPTOR_CLAW },
{ SPELL_FETCH_AMBERSEED, SPELL_HAVE_AMBERSEED, ITEM_AMBERSEED, SAY_AMBERSEED },
{ SPELL_FETCH_SHRUNKEN_DRAGONS_CLAW, SPELL_HAVE_SHRUNKEN_DRAGONS_CLAW, ITEM_SHRUNKEN_DRAGONS_CLAW, SAY_SHRUNKEN_DRAGONS_CLAW },
{ SPELL_FETCH_CHILLED_SERPENT_MUCUS, SPELL_HAVE_CHILLED_SERPENT_MUCUS, ITEM_CHILLED_SERPENT_MUCUS, SAY_CHILLED_SERPENT_MUCUS },
{ SPELL_FETCH_CRYSTALLIZED_HOGSNOT, SPELL_HAVE_CRYSTALLIZED_HOGSNOT, ITEM_CRYSTALLIZED_HOGSNOT, SAY_CRYSTALLIZED_HOGSNOT },
{ SPELL_FETCH_CRUSHED_BASILISK_CRYSTALS, SPELL_HAVE_CRUSHED_BASILISK_CRYSTALS, ITEM_CRUSHED_BASILISK_CRYSTALS, SAY_CRUSHED_BASILISK_CRYSTALS },
{ SPELL_FETCH_TROLLBANE, SPELL_HAVE_TROLLBANE, ITEM_TROLLBANE, SAY_TROLLBANE },
{ SPELL_FETCH_FROZEN_SPIDER_ICHOR, SPELL_HAVE_FROZEN_SPIDER_ICHOR, ITEM_FROZEN_SPIDER_ICHOR, SAY_FROZEN_SPIDER_ICHOR }
};
/*#####
# spell_random_ingredient_aura
#####*/
class spell_random_ingredient_aura : public SpellScriptLoader
{
public: spell_random_ingredient_aura() : SpellScriptLoader("spell_random_ingredient_aura") { }
class spell_random_ingredient_aura_AuraScript : public AuraScript
{
PrepareAuraScript(spell_random_ingredient_aura_AuraScript);
bool Validate(SpellInfo const* /*spellEntry*/)
{
if (!sSpellMgr->GetSpellInfo(SPELL_RANDOM_INGREDIENT_EASY) || !sSpellMgr->GetSpellInfo(SPELL_RANDOM_INGREDIENT_MEDIUM) || !sSpellMgr->GetSpellInfo(SPELL_RANDOM_INGREDIENT_HARD))
return false;
return true;
}
void PeriodicTick(AuraEffect const* /*aurEff*/)
{
switch (GetSpellInfo()->Id)
{
case SPELL_RANDOM_INGREDIENT_EASY_AURA:
GetTarget()->CastSpell(GetTarget(), SPELL_RANDOM_INGREDIENT_EASY);
break;
case SPELL_RANDOM_INGREDIENT_MEDIUM_AURA:
GetTarget()->CastSpell(GetTarget(), SPELL_RANDOM_INGREDIENT_MEDIUM);
break;
case SPELL_RANDOM_INGREDIENT_HARD_AURA:
GetTarget()->CastSpell(GetTarget(), SPELL_RANDOM_INGREDIENT_HARD);
break;
}
}
void Register()
{
OnEffectPeriodic += AuraEffectPeriodicFn(spell_random_ingredient_aura_AuraScript::PeriodicTick, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
}
};
AuraScript* GetAuraScript() const
{
return new spell_random_ingredient_aura_AuraScript();
}
};
/*#####
# spell_random_ingredient
#####*/
class spell_random_ingredient : public SpellScriptLoader
{
public: spell_random_ingredient() : SpellScriptLoader("spell_random_ingredient") { }
class spell_random_ingredient_SpellScript : public SpellScript
{
PrepareSpellScript(spell_random_ingredient_SpellScript);
bool Validate(SpellInfo const* /*spellEntry*/)
{
if (!sSpellMgr->GetSpellInfo(SPELL_FETCH_KNOTROOT) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_PICKLED_EAGLE_EGG) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_SPECKLED_GUANO) ||
!sSpellMgr->GetSpellInfo(SPELL_FETCH_WITHERED_BATWING) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_SEASONED_SLIDER_CIDER) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_PULVERIZED_GARGOYLE_TEETH) ||
!sSpellMgr->GetSpellInfo(SPELL_FETCH_MUDDY_MIRE_MAGGOT) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_SPIKY_SPIDER_EGG) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_HAIRY_HERRING_HEAD) ||
!sSpellMgr->GetSpellInfo(SPELL_FETCH_PUTRID_PIRATE_PERSPIRATION) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_ICECROWN_BOTTLED_WATER) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_WASPS_WINGS) ||
!sSpellMgr->GetSpellInfo(SPELL_FETCH_PRISMATIC_MOJO) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_RAPTOR_CLAW) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_AMBERSEED) ||
!sSpellMgr->GetSpellInfo(SPELL_FETCH_SHRUNKEN_DRAGONS_CLAW) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_CHILLED_SERPENT_MUCUS) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_CRYSTALLIZED_HOGSNOT) ||
!sSpellMgr->GetSpellInfo(SPELL_FETCH_CRUSHED_BASILISK_CRYSTALS) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_TROLLBANE) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_FROZEN_SPIDER_ICHOR))
return false;
return true;
}
void HandleScriptEffect(SpellEffIndex /* effIndex */)
{
if (Player* player = GetHitPlayer())
{
uint8 ingredient = 0;
switch (GetSpellInfo()->Id)
{
case SPELL_RANDOM_INGREDIENT_EASY:
ingredient = urand(0, 10);
break;
case SPELL_RANDOM_INGREDIENT_MEDIUM:
ingredient = urand(11, 15);
break;
case SPELL_RANDOM_INGREDIENT_HARD:
ingredient = urand(16, 20);
break;
}
if (Creature* finklestein = GetClosestCreatureWithEntry(player, NPC_FINKLESTEIN, 25.0f))
{
finklestein->CastSpell(player, FetchIngredients[ingredient] [0], true, NULL);
finklestein->AI()->Talk(FetchIngredients[ingredient] [3], player->GetGUID());
}
}
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_random_ingredient_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
}
};
SpellScript* GetSpellScript() const
{
return new spell_random_ingredient_SpellScript();
}
};
/*#####
# spell_pot_check
#####*/
class spell_pot_check : public SpellScriptLoader
{
public: spell_pot_check() : SpellScriptLoader("spell_pot_check") { }
class spell_pot_check_SpellScript : public SpellScript
{
PrepareSpellScript(spell_pot_check_SpellScript);
bool Validate(SpellInfo const* /*spellEntry*/)
{
if (!sSpellMgr->GetSpellInfo(SPELL_FETCH_KNOTROOT) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_PICKLED_EAGLE_EGG) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_SPECKLED_GUANO) ||
!sSpellMgr->GetSpellInfo(SPELL_FETCH_WITHERED_BATWING) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_SEASONED_SLIDER_CIDER) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_PULVERIZED_GARGOYLE_TEETH) ||
!sSpellMgr->GetSpellInfo(SPELL_FETCH_MUDDY_MIRE_MAGGOT) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_SPIKY_SPIDER_EGG) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_HAIRY_HERRING_HEAD) ||
!sSpellMgr->GetSpellInfo(SPELL_FETCH_PUTRID_PIRATE_PERSPIRATION) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_ICECROWN_BOTTLED_WATER) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_WASPS_WINGS) ||
!sSpellMgr->GetSpellInfo(SPELL_FETCH_PRISMATIC_MOJO) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_RAPTOR_CLAW) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_AMBERSEED) ||
!sSpellMgr->GetSpellInfo(SPELL_FETCH_SHRUNKEN_DRAGONS_CLAW) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_CHILLED_SERPENT_MUCUS) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_CRYSTALLIZED_HOGSNOT) ||
!sSpellMgr->GetSpellInfo(SPELL_FETCH_CRUSHED_BASILISK_CRYSTALS) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_TROLLBANE) || !sSpellMgr->GetSpellInfo(SPELL_FETCH_FROZEN_SPIDER_ICHOR) ||
!sSpellMgr->GetSpellInfo(SPELL_HAVE_KNOTROOT) || !sSpellMgr->GetSpellInfo(SPELL_HAVE_PICKLED_EAGLE_EGG) || !sSpellMgr->GetSpellInfo(SPELL_HAVE_SPECKLED_GUANO) ||
!sSpellMgr->GetSpellInfo(SPELL_HAVE_WITHERED_BATWING) || !sSpellMgr->GetSpellInfo(SPELL_HAVE_SEASONED_SLIDER_CIDER) || !sSpellMgr->GetSpellInfo(SPELL_HAVE_PULVERIZED_GARGOYLE_TEETH) ||
!sSpellMgr->GetSpellInfo(SPELL_HAVE_MUDDY_MIRE_MAGGOT) || !sSpellMgr->GetSpellInfo(SPELL_HAVE_SPIKY_SPIDER_EGG) || !sSpellMgr->GetSpellInfo(SPELL_HAVE_HAIRY_HERRING_HEAD) ||
!sSpellMgr->GetSpellInfo(SPELL_HAVE_PUTRID_PIRATE_PERSPIRATION) || !sSpellMgr->GetSpellInfo(SPELL_HAVE_ICECROWN_BOTTLED_WATER) || !sSpellMgr->GetSpellInfo(SPELL_HAVE_WASPS_WINGS) ||
!sSpellMgr->GetSpellInfo(SPELL_HAVE_PRISMATIC_MOJO) || !sSpellMgr->GetSpellInfo(SPELL_HAVE_RAPTOR_CLAW) || !sSpellMgr->GetSpellInfo(SPELL_HAVE_AMBERSEED) ||
!sSpellMgr->GetSpellInfo(SPELL_HAVE_SHRUNKEN_DRAGONS_CLAW) || !sSpellMgr->GetSpellInfo(SPELL_HAVE_CHILLED_SERPENT_MUCUS) || !sSpellMgr->GetSpellInfo(SPELL_HAVE_CRYSTALLIZED_HOGSNOT) ||
!sSpellMgr->GetSpellInfo(SPELL_HAVE_CRUSHED_BASILISK_CRYSTALS) || !sSpellMgr->GetSpellInfo(SPELL_HAVE_TROLLBANE) || !sSpellMgr->GetSpellInfo(SPELL_HAVE_FROZEN_SPIDER_ICHOR))
return false;
return true;
}
void HandleScriptEffect(SpellEffIndex /* effIndex */)
{
if (Player* player = GetHitPlayer())
{
for (uint8 i = 0; i < 21; ++i)
{
if(player->HasAura(FetchIngredients[i] [0]))
{
player->CastSpell(player, SPELL_THROW_INGREDIENT);
player->RemoveAura(FetchIngredients[i] [0]);
if(player->HasAura(FetchIngredients[i] [1]))
{
player->RemoveAura(FetchIngredients[i] [1]);
player->DestroyItemCount(FetchIngredients[i] [2], 1, true);
if (i < 15)
{
if (Creature* finklestein = GetClosestCreatureWithEntry(player, NPC_FINKLESTEIN, 25.0f))
finklestein->AI()->SetData(1, 1);
return;
}
else
{
if (player->GetQuestStatus(QUEST_THE_ALCHEMIST_APPRENTICE_DAILY) == QUEST_STATUS_INCOMPLETE)
{
player->RemoveAura(SPELL_ALCHEMIST_APPRENTICE_INVISBUFF);
player->CastSpell(player, SPELL_KILL_CREDIT);
}
}
}
else
{
RemoveItems(player);
player->RemoveAura(SPELL_ALCHEMIST_APPRENTICE_INVISBUFF);
if (Creature* finklestein = GetClosestCreatureWithEntry(player, NPC_FINKLESTEIN, 25.0f))
finklestein->AI()->Talk(SAY_RUINED, player->GetGUID());
return;
}
}
}
}
}
void RemoveItems(Player* player)
{
for (uint8 i = 0; i < 21; ++i)
if (player->HasItemCount(FetchIngredients[i] [2], 1, true))
player->DestroyItemCount(FetchIngredients[i] [2], 1, true);
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_pot_check_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
}
};
SpellScript* GetSpellScript() const
{
return new spell_pot_check_SpellScript();
}
};
/*#####
# spell_fetch_ingredient_aura
#####*/
class spell_fetch_ingredient_aura : public SpellScriptLoader
{
public: spell_fetch_ingredient_aura() : SpellScriptLoader("spell_fetch_ingredient_aura") { }
class spell_fetch_ingredient_aura_AuraScript : public AuraScript
{
PrepareAuraScript(spell_fetch_ingredient_aura_AuraScript);
void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
{
if (GetTargetApplication()->GetRemoveMode() == AURA_REMOVE_BY_EXPIRE)
if (Unit* target = GetTarget())
if (target->HasAura(SPELL_ALCHEMIST_APPRENTICE_INVISBUFF))
if (Creature* finklestein = GetClosestCreatureWithEntry(target, NPC_FINKLESTEIN, 100.0f))
{
target->RemoveAura(SPELL_ALCHEMIST_APPRENTICE_INVISBUFF);
finklestein->AI()->Talk(SAY_RUINED, target->GetGUID());
}
}
void Register()
{
OnEffectRemove += AuraEffectRemoveFn(spell_fetch_ingredient_aura_AuraScript::OnRemove, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_fetch_ingredient_aura_AuraScript();
}
};
void AddSC_zuldrak()
{
new npc_drakuru_shackles;
@@ -1427,4 +1956,10 @@ void AddSC_zuldrak()
new npc_elemental_lord;
new npc_fiend_elemental;
new go_scourge_enclosure;
new npc_alchemist_finklestein;
new go_finklesteins_cauldron;
new spell_random_ingredient_aura;
new spell_random_ingredient;
new spell_pot_check;
new spell_fetch_ingredient_aura;
}
@@ -16,12 +16,12 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/* ScriptData
SDName: Boss_Blackheart_the_Inciter
SD%Complete: 75
SDComment: Incite Chaos not functional since core lacks Mind Control support
SDCategory: Auchindoun, Shadow Labyrinth
EndScriptData */
/*
Name: Boss_Blackheart_the_Inciter
%Complete: 75
Comment: Incite Chaos not functional since core lacks Mind Control support
Category: Auchindoun, Shadow Labyrinth
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
@@ -48,38 +48,26 @@ enum BlackheartTheInciter
SAY2_DEATH = 9
};
enum Events
{
EVENT_INCITE_CHAOS_WAIT = 1,
EVENT_INCITE_CHAOS = 2,
EVENT_CHARGE_ATTACK = 3,
EVENT_WAR_STOMP = 4
};
class boss_blackheart_the_inciter : public CreatureScript
{
public:
boss_blackheart_the_inciter() : CreatureScript("boss_blackheart_the_inciter") { }
CreatureAI* GetAI(Creature* creature) const
struct boss_blackheart_the_inciterAI : public BossAI
{
return new boss_blackheart_the_inciterAI (creature);
}
struct boss_blackheart_the_inciterAI : public ScriptedAI
{
boss_blackheart_the_inciterAI(Creature* creature) : ScriptedAI(creature)
{
instance = creature->GetInstanceScript();
}
InstanceScript* instance;
bool InciteChaos;
uint32 InciteChaos_Timer;
uint32 InciteChaosWait_Timer;
uint32 Charge_Timer;
uint32 Knockback_Timer;
boss_blackheart_the_inciterAI(Creature* creature) : BossAI(creature, DATA_BLACKHEARTTHEINCITEREVENT) { }
void Reset()
{
InciteChaos = false;
InciteChaos_Timer = 20000;
InciteChaosWait_Timer = 15000;
Charge_Timer = 5000;
Knockback_Timer = 15000;
if (instance)
instance->SetData(DATA_BLACKHEARTTHEINCITEREVENT, NOT_STARTED);
@@ -100,6 +88,11 @@ public:
void EnterCombat(Unit* /*who*/)
{
events.ScheduleEvent(EVENT_INCITE_CHAOS_WAIT, 15000);
events.ScheduleEvent(EVENT_INCITE_CHAOS, 20000);
events.ScheduleEvent(EVENT_CHARGE_ATTACK, 5000);
events.ScheduleEvent(EVENT_WAR_STOMP, 15000);
Talk(SAY_AGGRO);
if (instance)
@@ -108,56 +101,60 @@ public:
void UpdateAI(uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
if (InciteChaos)
{
if (InciteChaosWait_Timer <= diff)
{
InciteChaos = false;
InciteChaosWait_Timer = 15000;
} else InciteChaosWait_Timer -= diff;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
if (InciteChaos_Timer <= diff)
while (uint32 eventId = events.ExecuteEvent())
{
DoCast(me, SPELL_INCITE_CHAOS);
std::list<HostileReference*> t_list = me->getThreatManager().getThreatList();
for (std::list<HostileReference*>::const_iterator itr = t_list.begin(); itr!= t_list.end(); ++itr)
switch (eventId)
{
Unit* target = Unit::GetUnit(*me, (*itr)->getUnitGuid());
if (target && target->GetTypeId() == TYPEID_PLAYER)
me->CastSpell(target, SPELL_INCITE_CHAOS_B, true);
case EVENT_INCITE_CHAOS_WAIT:
InciteChaos = false;
events.ScheduleEvent(EVENT_INCITE_CHAOS_WAIT, 15000);
break;
case EVENT_INCITE_CHAOS:
{
DoCast(me, SPELL_INCITE_CHAOS);
std::list<HostileReference*> t_list = me->getThreatManager().getThreatList();
for (std::list<HostileReference*>::const_iterator itr = t_list.begin(); itr!= t_list.end(); ++itr)
{
Unit* target = Unit::GetUnit(*me, (*itr)->getUnitGuid());
if (target && target->GetTypeId() == TYPEID_PLAYER)
me->CastSpell(target, SPELL_INCITE_CHAOS_B, true);
}
DoResetThreat();
InciteChaos = true;
events.ScheduleEvent(EVENT_INCITE_CHAOS, 40000);
break;
}
case EVENT_CHARGE_ATTACK:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_CHARGE);
events.ScheduleEvent(EVENT_CHARGE, urand(15000, 25000));
break;
case EVENT_WAR_STOMP:
DoCast(me, SPELL_WAR_STOMP);
events.ScheduleEvent(EVENT_WAR_STOMP, urand(18000, 24000));
break;
}
DoResetThreat();
InciteChaos = true;
InciteChaos_Timer = 40000;
return;
} else InciteChaos_Timer -= diff;
//Charge_Timer
if (Charge_Timer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_CHARGE);
Charge_Timer = urand(15000, 25000);
} else Charge_Timer -= diff;
//Knockback_Timer
if (Knockback_Timer <= diff)
{
DoCast(me, SPELL_WAR_STOMP);
Knockback_Timer = urand(18000, 24000);
} else Knockback_Timer -= diff;
}
DoMeleeAttackIfReady();
}
private:
bool InciteChaos;
CreatureAI* GetAI(Creature* creature) const
{
return new boss_blackheart_the_inciterAI (creature);
}
};
};
@@ -16,12 +16,11 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/* ScriptData
SDName: Boss_Grandmaster_Vorpil
SD%Complete: 100
SDComment:
SDCategory: Auchindoun, Shadow Labyrinth
EndScriptData */
/*
Name: Boss_Grandmaster_Vorpil
%Complete: 100
Category: Auchindoun, Shadow Labyrinth
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
@@ -43,13 +42,13 @@ enum GrandmasterVorpil
SPELL_SHADOWBOLT_VOLLEY = 33841,
SPELL_BANISH = 38791,
MOB_VOID_TRAVELER = 19226,
NPC_VOID_TRAVELER = 19226,
SPELL_SACRIFICE = 33587,
SPELL_SHADOW_NOVA = 33846,
SPELL_EMPOWERING_SHADOWS = 33783,
H_SPELL_EMPOWERING_SHADOWS = 39364,
MOB_VOID_PORTAL = 19224,
NPC_VOID_PORTAL = 19224,
SPELL_VOID_PORTAL_VISUAL = 33569
};
@@ -64,21 +63,22 @@ float VoidPortalCoords[5][3] =
{-261.4533f, -297.3298f, 17.1f}
};
class mob_voidtraveler : public CreatureScript
enum Events
{
EVENT_SHADOWBOLT_VOLLEY = 1,
EVENT_BANISH = 2,
EVENT_DRAW_SHADOWS = 3,
EVENT_SUMMON_TRAVELER = 4
};
class npc_voidtraveler : public CreatureScript
{
public:
mob_voidtraveler() : CreatureScript("mob_voidtraveler") { }
npc_voidtraveler() : CreatureScript("npc_voidtraveler") { }
CreatureAI* GetAI(Creature* creature) const
struct npc_voidtravelerAI : public ScriptedAI
{
return new mob_voidtravelerAI (creature);
}
struct mob_voidtravelerAI : public ScriptedAI
{
mob_voidtravelerAI(Creature* creature) : ScriptedAI(creature)
{
}
npc_voidtravelerAI(Creature* creature) : ScriptedAI(creature) {}
uint64 VorpilGUID;
uint32 move;
@@ -133,6 +133,11 @@ public:
move = 1000;
} else move -= diff;
}
CreatureAI* GetAI(Creature* creature) const
{
return new npc_voidtravelerAI (creature);
}
};
};
@@ -142,35 +147,15 @@ class boss_grandmaster_vorpil : public CreatureScript
public:
boss_grandmaster_vorpil() : CreatureScript("boss_grandmaster_vorpil") { }
CreatureAI* GetAI(Creature* creature) const
struct boss_grandmaster_vorpilAI : public BossAI
{
return new boss_grandmaster_vorpilAI (creature);
}
struct boss_grandmaster_vorpilAI : public ScriptedAI
{
boss_grandmaster_vorpilAI(Creature* creature) : ScriptedAI(creature)
boss_grandmaster_vorpilAI(Creature* creature) : BossAI(creature, DATA_GRANDMASTERVORPIL)
{
instance = creature->GetInstanceScript();
Intro = false;
}
InstanceScript* instance;
bool Intro, HelpYell;
bool sumportals;
uint32 ShadowBoltVolley_Timer;
uint32 DrawShadows_Timer;
uint32 summonTraveler_Timer;
uint32 banish_Timer;
uint64 PortalsGuid[5];
void Reset()
{
ShadowBoltVolley_Timer = urand(7000, 14000);
DrawShadows_Timer = 45000;
summonTraveler_Timer = 90000;
banish_Timer = 17000;
HelpYell = false;
sumportals = false;
destroyPortals();
@@ -186,7 +171,7 @@ public:
for (uint8 i = 0; i < 5; ++i)
{
Creature* Portal = NULL;
Portal = me->SummonCreature(MOB_VOID_PORTAL, VoidPortalCoords[i][0], VoidPortalCoords[i][1], VoidPortalCoords[i][2], 0, TEMPSUMMON_CORPSE_DESPAWN, 3000000);
Portal = me->SummonCreature(NPC_VOID_PORTAL, VoidPortalCoords[i][0], VoidPortalCoords[i][1], VoidPortalCoords[i][2], 0, TEMPSUMMON_CORPSE_DESPAWN, 3000000);
if (Portal)
{
PortalsGuid[i] = Portal->GetGUID();
@@ -194,7 +179,7 @@ public:
}
}
sumportals = true;
summonTraveler_Timer = 5000;
events.ScheduleEvent(EVENT_SUMMON_TRAVELER, 5000);
}
}
@@ -216,7 +201,7 @@ public:
void spawnVoidTraveler()
{
int pos = urand(0, 4);
me->SummonCreature(MOB_VOID_TRAVELER, VoidPortalCoords[pos][0], VoidPortalCoords[pos][1], VoidPortalCoords[pos][2], 0, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 5000);
me->SummonCreature(NPC_VOID_TRAVELER, VoidPortalCoords[pos][0], VoidPortalCoords[pos][1], VoidPortalCoords[pos][2], 0, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 5000);
if (!HelpYell)
{
Talk(SAY_HELP);
@@ -226,8 +211,8 @@ public:
void JustSummoned(Creature* summoned)
{
if (summoned && summoned->GetEntry() == MOB_VOID_TRAVELER)
CAST_AI(mob_voidtraveler::mob_voidtravelerAI, summoned->AI())->VorpilGUID = me->GetGUID();
if (summoned && summoned->GetEntry() == NPC_VOID_TRAVELER)
CAST_AI(npc_voidtraveler::npc_voidtravelerAI, summoned->AI())->VorpilGUID = me->GetGUID();
}
void KilledUnit(Unit* /*victim*/)
@@ -246,11 +231,18 @@ public:
void EnterCombat(Unit* /*who*/)
{
events.ScheduleEvent(EVENT_SHADOWBOLT_VOLLEY, urand(7000, 14000));
if (IsHeroic())
events.ScheduleEvent(EVENT_BANISH, 17000);
events.ScheduleEvent(EVENT_DRAW_SHADOWS, 45000);
events.ScheduleEvent(EVENT_SUMMON_TRAVELER, 90000);
Talk(SAY_AGGRO);
summonPortals();
if (instance)
instance->SetData(DATA_GRANDMASTERVORPILEVENT, IN_PROGRESS);
_EnterCombat();
}
void MoveInLineOfSight(Unit* who)
@@ -269,51 +261,61 @@ public:
if (!UpdateVictim())
return;
if (ShadowBoltVolley_Timer <= diff)
{
DoCast(me, SPELL_SHADOWBOLT_VOLLEY);
ShadowBoltVolley_Timer = urand(15000, 30000);
} else ShadowBoltVolley_Timer -= diff;
events.Update(diff);
if (IsHeroic() && banish_Timer <= diff)
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 30, false);
if (target)
switch (eventId)
{
DoCast(target, SPELL_BANISH);
banish_Timer = 16000;
case EVENT_SHADOWBOLT_VOLLEY:
DoCast(me, SPELL_SHADOWBOLT_VOLLEY);
events.ScheduleEvent(EVENT_SHADOWBOLT_VOLLEY, urand(15000, 30000));
break;
case EVENT_BANISH:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 30, false))
DoCast(target, SPELL_BANISH);
events.ScheduleEvent(EVENT_BANISH, 16000);
break;
case EVENT_DRAW_SHADOWS:
{
Map* map = me->GetMap();
Map::PlayerList const &PlayerList = map->GetPlayers();
for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
if (Player* i_pl = i->GetSource())
if (i_pl->IsAlive() && !i_pl->HasAura(SPELL_BANISH))
i_pl->TeleportTo(me->GetMapId(), VorpilPosition[0], VorpilPosition[1], VorpilPosition[2], 0, TELE_TO_NOT_LEAVE_COMBAT);
me->SetPosition(VorpilPosition[0], VorpilPosition[1], VorpilPosition[2], 0.0f);
DoCast(me, SPELL_DRAW_SHADOWS, true);
DoCast(me, SPELL_RAIN_OF_FIRE);
events.ScheduleEvent(EVENT_SHADOWBOLT_VOLLEY, 6000);
events.ScheduleEvent(EVENT_DRAW_SHADOWS, 30000);
break;
}
case EVENT_SUMMON_TRAVELER:
spawnVoidTraveler();
events.ScheduleEvent(EVENT_SUMMON_TRAVELER, 10000);
//enrage at 20%
if (HealthBelowPct(20))
events.ScheduleEvent(EVENT_SUMMON_TRAVELER, 5000);
break;
}
} else banish_Timer -= diff;
if (DrawShadows_Timer <= diff)
{
Map* map = me->GetMap();
Map::PlayerList const &PlayerList = map->GetPlayers();
for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
if (Player* i_pl = i->GetSource())
if (i_pl->IsAlive() && !i_pl->HasAura(SPELL_BANISH))
i_pl->TeleportTo(me->GetMapId(), VorpilPosition[0], VorpilPosition[1], VorpilPosition[2], 0, TELE_TO_NOT_LEAVE_COMBAT);
me->SetPosition(VorpilPosition[0], VorpilPosition[1], VorpilPosition[2], 0.0f);
DoCast(me, SPELL_DRAW_SHADOWS, true);
DoCast(me, SPELL_RAIN_OF_FIRE);
ShadowBoltVolley_Timer = 6000;
DrawShadows_Timer = 30000;
} else DrawShadows_Timer -= diff;
if (summonTraveler_Timer <= diff)
{
spawnVoidTraveler();
summonTraveler_Timer = 10000;
//enrage at 20%
if (HealthBelowPct(20))
summonTraveler_Timer = 5000;
} else summonTraveler_Timer -=diff;
}
DoMeleeAttackIfReady();
}
private:
bool Intro, HelpYell;
bool sumportals;
uint64 PortalsGuid[5];
CreatureAI* GetAI(Creature* creature) const
{
return new boss_grandmaster_vorpilAI (creature);
}
};
};
@@ -321,5 +323,5 @@ public:
void AddSC_boss_grandmaster_vorpil()
{
new boss_grandmaster_vorpil();
new mob_voidtraveler();
new npc_voidtraveler();
}
@@ -30,53 +30,51 @@ EndScriptData */
enum Murmur
{
// Spell
SPELL_RESONANCE = 33657,
SPELL_MAGNETIC_PULL = 33689,
SPELL_SONIC_SHOCK = 38797,
SPELL_THUNDERING_STORM = 39365,
SPELL_SONIC_BOOM_CAST = 33923,
SPELL_SONIC_BOOM_EFFECT = 33666,
SPELL_MURMURS_TOUCH = 33711,
// Text
EMOTE_SONIC_BOOM = 0
};
#define SPELL_SONIC_BOOM_CAST DUNGEON_MODE(33923, 38796)
#define SPELL_SONIC_BOOM_EFFECT DUNGEON_MODE(33666, 38795)
#define SPELL_MURMURS_TOUCH DUNGEON_MODE(33711, 38794)
enum Events
{
EVENT_SONIC_BOOM = 1,
EVENT_MURMURS_TOUCH = 2,
EVENT_RESONANCE = 3,
EVENT_MAGNETIC_PULL = 4,
EVENT_THUNDERING_STORM = 5,
EVENT_SONIC_SHOCK = 6
};
class boss_murmur : public CreatureScript
{
public:
boss_murmur() : CreatureScript("boss_murmur") { }
CreatureAI* GetAI(Creature* creature) const
struct boss_murmurAI : public BossAI
{
return new boss_murmurAI (creature);
}
struct boss_murmurAI : public ScriptedAI
{
boss_murmurAI(Creature* creature) : ScriptedAI(creature)
boss_murmurAI(Creature* creature) : BossAI(creature, DATA_MURMUREVENT)
{
SetCombatMovement(false);
}
uint32 SonicBoom_Timer;
uint32 MurmursTouch_Timer;
uint32 Resonance_Timer;
uint32 MagneticPull_Timer;
uint32 SonicShock_Timer;
uint32 ThunderingStorm_Timer;
bool SonicBoom;
void Reset()
{
SonicBoom_Timer = 30000;
MurmursTouch_Timer = urand(8000, 20000);
Resonance_Timer = 5000;
MagneticPull_Timer = urand(15000, 30000);
ThunderingStorm_Timer = 15000;
SonicShock_Timer = 10000;
SonicBoom = false;
events.ScheduleEvent(EVENT_SONIC_BOOM, 30000);
events.ScheduleEvent(EVENT_MURMURS_TOUCH, urand(8000, 20000));
events.ScheduleEvent(EVENT_RESONANCE, 5000);
events.ScheduleEvent(EVENT_MAGNETIC_PULL, urand(15000, 30000));
if (IsHeroic())
{
events.ScheduleEvent(EVENT_THUNDERING_STORM, 15000);
events.ScheduleEvent(EVENT_SONIC_SHOCK, 10000);
}
//database should have `RegenHealth`=0 to prevent regen
uint32 hp = me->CountPctFromMaxHealth(40);
@@ -117,81 +115,65 @@ public:
if (!UpdateVictim() || me->IsNonMeleeSpellCasted(false))
return;
// Sonic Boom
if (SonicBoom)
{
DoCast(me, SPELL_SONIC_BOOM_EFFECT, true);
SonicBoomEffect();
events.Update(diff);
SonicBoom = false;
Resonance_Timer = 1500;
}
if (SonicBoom_Timer <= diff)
while (uint32 eventId = events.ExecuteEvent())
{
Talk(EMOTE_SONIC_BOOM);
DoCast(me, SPELL_SONIC_BOOM_CAST);
SonicBoom_Timer = 30000;
SonicBoom = true;
return;
} else SonicBoom_Timer -= diff;
// Murmur's Touch
if (MurmursTouch_Timer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 80, true))
DoCast(target, SPELL_MURMURS_TOUCH);
MurmursTouch_Timer = urand(25000, 35000);
} else MurmursTouch_Timer -= diff;
// Resonance
if (!SonicBoom && !(me->IsWithinMeleeRange(me->GetVictim())))
{
if (Resonance_Timer <= diff)
switch (eventId)
{
DoCast(me, SPELL_RESONANCE);
Resonance_Timer = 5000;
} else Resonance_Timer -= diff;
}
// Magnetic Pull
if (MagneticPull_Timer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
if (target->GetTypeId() == TYPEID_PLAYER && target->IsAlive())
case EVENT_SONIC_BOOM:
Talk(EMOTE_SONIC_BOOM);
DoCast(me, SPELL_SONIC_BOOM_CAST);
DoCast(me, SPELL_SONIC_BOOM_EFFECT, true);
SonicBoomEffect();
events.ScheduleEvent(EVENT_SONIC_BOOM, 30000);
events.ScheduleEvent(EVENT_RESONANCE, 1500);
break;
case EVENT_MURMURS_TOUCH:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 80, true))
DoCast(target, SPELL_MURMURS_TOUCH);
events.ScheduleEvent(EVENT_MURMURS_TOUCH, urand(25000, 35000));
break;
case EVENT_RESONANCE:
if (!(me->IsWithinMeleeRange(me->GetVictim())))
{
DoCast(me, SPELL_RESONANCE);
events.ScheduleEvent(EVENT_RESONANCE, 5000);
}
break;
case EVENT_MAGNETIC_PULL:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
if (target->GetTypeId() == TYPEID_PLAYER && target->IsAlive())
{
DoCast(target, SPELL_MAGNETIC_PULL);
events.ScheduleEvent(EVENT_MAGNETIC_PULL, 15000+rand()%15000);
break;
}
events.ScheduleEvent(EVENT_MAGNETIC_PULL, 500);
break;
case EVENT_THUNDERING_STORM:
{
DoCast(target, SPELL_MAGNETIC_PULL);
MagneticPull_Timer = 15000+rand()%15000;
return;
}
MagneticPull_Timer = 500;
} else MagneticPull_Timer -= diff;
if (IsHeroic())
{
// Thundering Storm
if (ThunderingStorm_Timer <= diff)
{
ThreatContainer::StorageType threatlist = me->getThreatManager().getThreatList();
for (ThreatContainer::StorageType::const_iterator i = threatlist.begin(); i != threatlist.end(); ++i)
if (Unit* target = Unit::GetUnit(*me, (*i)->getUnitGuid()))
if (target->IsAlive() && !me->IsWithinDist(target, 35, false))
DoCast(target, SPELL_THUNDERING_STORM, true);
ThunderingStorm_Timer = 15000;
} else ThunderingStorm_Timer -= diff;
// Sonic Shock
if (SonicShock_Timer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 20, false))
if (target->IsAlive())
DoCast(target, SPELL_SONIC_SHOCK);
SonicShock_Timer = 10000+rand()%10000;
} else SonicShock_Timer -= diff;
ThreatContainer::StorageType threatlist = me->getThreatManager().getThreatList();
for (ThreatContainer::StorageType::const_iterator i = threatlist.begin(); i != threatlist.end(); ++i)
if (Unit* target = Unit::GetUnit(*me, (*i)->getUnitGuid()))
if (target->IsAlive() && !me->IsWithinDist(target, 35, false))
DoCast(target, SPELL_THUNDERING_STORM, true);
events.ScheduleEvent(EVENT_THUNDERING_STORM, 15000);
break;
}
case EVENT_SONIC_SHOCK:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 20, false))
if (target->IsAlive())
DoCast(target, SPELL_SONIC_SHOCK);
events.ScheduleEvent(EVENT_SONIC_SHOCK, 10000+rand()%10000);
break;
}
}
// Select nearest most aggro target if top aggro too far
if (!me->isAttackReady())
return;
if (!me->IsWithinMeleeRange(me->GetVictim()))
{
ThreatContainer::StorageType threatlist = me->getThreatManager().getThreatList();
@@ -206,6 +188,11 @@ public:
DoMeleeAttackIfReady();
}
CreatureAI* GetAI(Creature* creature) const
{
return new boss_murmurAI (creature);
}
};
};
Loaded 100 of 116 files, more files were not shown because too many files have changed in this diff. Show more