Trinity Namespace Reference

Namespaces
	Containers
	Currency
	Honor
	XP

Classes
class	AbsorbAuraOrderPred
struct	AIRelocationNotifier
class	AllCreaturesOfEntryInRange
class	AllFriendlyCreaturesInGrid
class	AllGameObjectsWithEntryInRange
class	AllWorldObjectsInRange
class	AnyAoETargetUnitInObjectRangeCheck
class	AnyAssistCreatureInRangeCheck
struct	AnyDeadUnitCheck
class	AnyDeadUnitObjectInRangeCheck
class	AnyDeadUnitSpellTargetInRangeCheck
class	AnyFriendlyUnitInObjectRangeCheck
class	AnyGroupedUnitInObjectRangeCheck
class	AnyPlayerInObjectRangeCheck
class	AnyUnfriendlyNoTotemUnitInObjectRangeCheck
class	AnyUnfriendlyUnitInObjectRangeCheck
class	AnyUnitInObjectRangeCheck
class	Battleground2ChatBuilder
class	BattlegroundChatBuilder
class	BroadcastTextBuilder
class	CallOfHelpCreatureInRangeDo
struct	CreatureLastSearcher
struct	CreatureListSearcher
struct	CreatureRelocationNotifier
struct	CreatureSearcher
struct	CreatureWorker
class	CustomChatTextBuilder
struct	DelayedUnitRelocation
struct	discrete_distribution_param
class	FriendlyCCedInRange
class	FriendlyMissingBuffInRange
class	GameObjectFocusCheck
class	GameObjectInRangeCheck
struct	GameObjectLastSearcher
struct	GameObjectListSearcher
struct	GameObjectSearcher
struct	GameObjectWorker
struct	GridUpdater
class	HealthPctOrderPred
class	HeightDifferenceCheck
class	LocalizedPacketDo
class	LocalizedPacketListDo
struct	MessageDistDeliverer
class	MostHPMissingInRange
class	NearestAssistCreatureInCreatureRangeCheck
class	NearestAttackableUnitInObjectRangeCheck
class	NearestCreatureEntryWithLiveStateInObjectRangeCheck
class	NearestGameObjectCheck
class	NearestGameObjectEntryInObjectRangeCheck
class	NearestGameObjectFishingHole
class	NearestGameObjectTypeInObjectRangeCheck
class	NearestHostileUnitCheck
class	NearestHostileUnitInAggroRangeCheck
class	NearestHostileUnitInAttackDistanceCheck
class	NearestPlayerInObjectRangeCheck
class	ObjectDistanceOrderPred
class	ObjectGUIDCheck
class	ObjectTypeIdCheck
struct	ObjectUpdater
class	PlayerAtMinimumRangeAway
struct	PlayerDistWorker
struct	PlayerLastSearcher
struct	PlayerListSearcher
struct	PlayerRelocationNotifier
struct	PlayerSearcher
struct	PlayerWorker
class	PowerPctOrderPred
class	RespawnDo
class	ThreatOrderPred
class	UnitAuraCheck
struct	UnitLastSearcher
struct	UnitListSearcher
struct	UnitSearcher
struct	VisibleChangesNotifier
struct	VisibleNotifier
struct	WorldObjectLastSearcher
struct	WorldObjectListSearcher
struct	WorldObjectSearcher
struct	WorldObjectSpellAreaTargetCheck
struct	WorldObjectSpellConeTargetCheck
struct	WorldObjectSpellNearbyTargetCheck
struct	WorldObjectSpellTargetCheck
struct	WorldObjectSpellTrajTargetCheck
struct	WorldObjectWorker
class	WorldWorldTextBuilder

Functions
template<typename T , typename... Args>
std::unique_ptr< T >	make_unique (Args &&...args)
	std::make_unique implementation (TODO: remove this once C++14 is supported) More...
void	Assert (char const *file, int line, char const *function, char const *message)
void	Assert (char const *file, int line, char const *function, char const *message, char const *format,...)
void	Fatal (char const *file, int line, char const *function, char const *message,...)
void	Error (char const *file, int line, char const *function, char const *message)
void	Warning (char const *file, int line, char const *function, char const *message)
void	Abort (char const *file, int line, char const *function)
void	AbortHandler (int)
template<typename Format , typename... Args>
std::string	StringFormat (Format &&fmt, Args &&...args)
	Default TC string format function. More...
bool	IsFormatEmptyOrNull (const char *fmt)
	Returns true if the given char pointer is null. More...
bool	IsFormatEmptyOrNull (std::string const &fmt)
	Returns true if the given std::string is empty. More...
template<class RET_TYPE , int CENTER_VAL>
RET_TYPE	Compute (float x, float y, float center_offset, float size)
GridCoord	ComputeGridCoord (float x, float y)
CellCoord	ComputeCellCoord (float x, float y)
CellCoord	ComputeCellCoord (float x, float y, float &x_off, float &y_off)
void	NormalizeMapCoord (float &c)
bool	IsValidMapCoord (float c)
bool	IsValidMapCoord (float x, float y)
bool	IsValidMapCoord (float x, float y, float z)
bool	IsValidMapCoord (float x, float y, float z, float o)
template<class SPECIFIC_TYPE , class KEY_TYPE >
bool	Insert (ContainerUnorderedMap< SPECIFIC_TYPE, KEY_TYPE > &elements, KEY_TYPE const &handle, SPECIFIC_TYPE *obj)
template<class SPECIFIC_TYPE , class KEY_TYPE >
bool	Insert (ContainerUnorderedMap< TypeNull, KEY_TYPE > &, KEY_TYPE const &, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class KEY_TYPE , class T >
bool	Insert (ContainerUnorderedMap< T, KEY_TYPE > &, KEY_TYPE const &, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class KEY_TYPE , class H , class T >
bool	Insert (ContainerUnorderedMap< TypeList< H, T >, KEY_TYPE > &elements, KEY_TYPE const &handle, SPECIFIC_TYPE *obj)
template<class SPECIFIC_TYPE , class KEY_TYPE >
SPECIFIC_TYPE *	Find (ContainerUnorderedMap< SPECIFIC_TYPE, KEY_TYPE > const &elements, KEY_TYPE const &handle, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class KEY_TYPE >
SPECIFIC_TYPE *	Find (ContainerUnorderedMap< TypeNull, KEY_TYPE > const &, KEY_TYPE const &, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class KEY_TYPE , class T >
SPECIFIC_TYPE *	Find (ContainerUnorderedMap< T, KEY_TYPE > const &, KEY_TYPE const &, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class KEY_TYPE , class H , class T >
SPECIFIC_TYPE *	Find (ContainerUnorderedMap< TypeList< H, T >, KEY_TYPE > const &elements, KEY_TYPE const &handle, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class KEY_TYPE >
bool	Remove (ContainerUnorderedMap< SPECIFIC_TYPE, KEY_TYPE > &elements, KEY_TYPE const &handle, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class KEY_TYPE >
bool	Remove (ContainerUnorderedMap< TypeNull, KEY_TYPE > &, KEY_TYPE const &, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class KEY_TYPE , class T >
bool	Remove (ContainerUnorderedMap< T, KEY_TYPE > &, KEY_TYPE const &, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class KEY_TYPE , class H , class T >
bool	Remove (ContainerUnorderedMap< TypeList< H, T >, KEY_TYPE > &elements, KEY_TYPE const &handle, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE >
size_t	Count (ContainerMapList< SPECIFIC_TYPE > const &elements, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE >
size_t	Count (ContainerMapList< TypeNull > const &, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class T >
size_t	Count (ContainerMapList< T > const &, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class T >
size_t	Count (ContainerMapList< TypeList< SPECIFIC_TYPE, T >> const &elements, SPECIFIC_TYPE *fake)
template<class SPECIFIC_TYPE , class H , class T >
size_t	Count (ContainerMapList< TypeList< H, T >> const &elements, SPECIFIC_TYPE *fake)
template<class SPECIFIC_TYPE >
SPECIFIC_TYPE *	Insert (ContainerMapList< SPECIFIC_TYPE > &elements, SPECIFIC_TYPE *obj)
template<class SPECIFIC_TYPE >
SPECIFIC_TYPE *	Insert (ContainerMapList< TypeNull > &, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class T >
SPECIFIC_TYPE *	Insert (ContainerMapList< T > &, SPECIFIC_TYPE *)
template<class SPECIFIC_TYPE , class H , class T >
SPECIFIC_TYPE *	Insert (ContainerMapList< TypeList< H, T >> &elements, SPECIFIC_TYPE *obj)

Function Documentation

DECLSPEC_NORETURN TC_COMMON_API void Trinity::Abort	(	char const *	file,
		int	line,
		char const *	function
	)

{
 fprintf(stderr, "\n%s:%i in %s ABORTED.\n",
 file, line, function);
 *((volatile int*)NULL) = 0;
 exit(1);
}

Here is the call graph for this function:

DECLSPEC_NORETURN TC_COMMON_API void Trinity::AbortHandler

(

int

)

{
 // nothing useful to log here, no way to pass args
 *((volatile int*)NULL) = 0;
 exit(1);
}

Here is the caller graph for this function:

DECLSPEC_NORETURN TC_COMMON_API void Trinity::Assert	(	char const *	file,
		int	line,
		char const *	function,
		char const *	message
	)

{
 fprintf(stderr, "\n%s:%i in %s ASSERTION FAILED:\n %s\n",
 file, line, function, message);
 *((volatile int*)NULL) = 0;
 exit(1);
}

Here is the call graph for this function:

DECLSPEC_NORETURN TC_COMMON_API void Trinity::Assert	(	char const *	file,
		int	line,
		char const *	function,
		char const *	message,
		char const *	format,
			...
	)

{
 va_list args;
 va_start(args, format);

 fprintf(stderr, "\n%s:%i in %s ASSERTION FAILED:\n %s ", file, line, function, message);
 vfprintf(stderr, format, args);
 fprintf(stderr, "\n");
 fflush(stderr);

 va_end(args);
 *((volatile int*)NULL) = 0;
 exit(1);
}

Here is the call graph for this function:

template<class RET_TYPE , int CENTER_VAL>

RET_TYPE Trinity::Compute ( float  x, float  y, float  center_offset, float  size  )

inline

 {
 // calculate and store temporary values in double format for having same result as same mySQL calculations
 double x_offset = (double(x) - center_offset)/size;
 double y_offset = (double(y) - center_offset)/size;

 int x_val = int(x_offset + CENTER_VAL + 0.5f);
 int y_val = int(y_offset + CENTER_VAL + 0.5f);
 return RET_TYPE(x_val, y_val);
 }

Here is the caller graph for this function:

CellCoord Trinity::ComputeCellCoord ( float  x, float  y  )

inline

 {
 return Compute<CellCoord, CENTER_GRID_CELL_ID>(x, y, CENTER_GRID_CELL_OFFSET, SIZE_OF_GRID_CELL);
 }

Here is the caller graph for this function:

CellCoord Trinity::ComputeCellCoord ( float  x, float  y, float &  x_off, float &  y_off  )

inline

 {
 double x_offset = (double(x) - CENTER_GRID_CELL_OFFSET)/SIZE_OF_GRID_CELL;
 double y_offset = (double(y) - CENTER_GRID_CELL_OFFSET)/SIZE_OF_GRID_CELL;

 int x_val = int(x_offset + CENTER_GRID_CELL_ID + 0.5f);
 int y_val = int(y_offset + CENTER_GRID_CELL_ID + 0.5f);
 x_off = (float(x_offset) - float(x_val) + CENTER_GRID_CELL_ID) * SIZE_OF_GRID_CELL;
 y_off = (float(y_offset) - float(y_val) + CENTER_GRID_CELL_ID) * SIZE_OF_GRID_CELL;
 return CellCoord(x_val, y_val);
 }

GridCoord Trinity::ComputeGridCoord ( float  x, float  y  )

inline

 {
 return Compute<GridCoord, CENTER_GRID_ID>(x, y, CENTER_GRID_OFFSET, SIZE_OF_GRIDS);
 }

Here is the caller graph for this function:

template<class SPECIFIC_TYPE >

size_t Trinity::Count	(	ContainerMapList< SPECIFIC_TYPE > const &	elements,
		SPECIFIC_TYPE *
	)

 {
 return elements._element.getSize();
 }

Here is the caller graph for this function:

template<class SPECIFIC_TYPE >

size_t Trinity::Count	(	ContainerMapList< TypeNull > const &	,
		SPECIFIC_TYPE *
	)

 {
 return 0;
 }

template<class SPECIFIC_TYPE , class T >

size_t Trinity::Count	(	ContainerMapList< T > const &	,
		SPECIFIC_TYPE *
	)

 {
 return 0;
 }

template<class SPECIFIC_TYPE , class T >

size_t Trinity::Count	(	ContainerMapList< TypeList< SPECIFIC_TYPE, T >> const &	elements,
		SPECIFIC_TYPE *	fake
	)

 {
 return Count(elements._elements, fake);
 }

Here is the call graph for this function:

template<class SPECIFIC_TYPE , class H , class T >

size_t Trinity::Count	(	ContainerMapList< TypeList< H, T >> const &	elements,
		SPECIFIC_TYPE *	fake
	)

 {
 return Count(elements._TailElements, fake);
 }

Here is the call graph for this function:

DECLSPEC_NORETURN TC_COMMON_API void DECLSPEC_NORETURN TC_COMMON_API void DECLSPEC_NORETURN TC_COMMON_API void Trinity::Error	(	char const *	file,
		int	line,
		char const *	function,
		char const *	message
	)

{
 fprintf(stderr, "\n%s:%i in %s ERROR:\n %s\n",
 file, line, function, message);
 *((volatile int*)NULL) = 0;
 exit(1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

DECLSPEC_NORETURN TC_COMMON_API void DECLSPEC_NORETURN TC_COMMON_API void Trinity::Fatal	(	char const *	file,
		int	line,
		char const *	function,
		char const *	message,
			...
	)

{
 va_list args;
 va_start(args, message);

 fprintf(stderr, "\n%s:%i in %s FATAL ERROR:\n ", file, line, function);
 vfprintf(stderr, message, args);
 fprintf(stderr, "\n");
 fflush(stderr);

 std::this_thread::sleep_for(std::chrono::seconds(10));
 *((volatile int*)NULL) = 0;
 exit(1);
}

Here is the call graph for this function:

template<class SPECIFIC_TYPE , class KEY_TYPE >

SPECIFIC_TYPE* Trinity::Find	(	ContainerUnorderedMap< SPECIFIC_TYPE, KEY_TYPE > const &	elements,
		KEY_TYPE const &	handle,
		SPECIFIC_TYPE *
	)

 {
 auto i = elements._element.find(handle);
 if (i == elements._element.end())
 return nullptr;
 else
 return i->second;
 }

Here is the caller graph for this function:

template<class SPECIFIC_TYPE , class KEY_TYPE >

SPECIFIC_TYPE* Trinity::Find	(	ContainerUnorderedMap< TypeNull, KEY_TYPE > const &	,
		KEY_TYPE const &	,
		SPECIFIC_TYPE *
	)

 {
 return nullptr;
 }

template<class SPECIFIC_TYPE , class KEY_TYPE , class T >

SPECIFIC_TYPE* Trinity::Find	(	ContainerUnorderedMap< T, KEY_TYPE > const &	,
		KEY_TYPE const &	,
		SPECIFIC_TYPE *
	)

 {
 return nullptr;
 }

template<class SPECIFIC_TYPE , class KEY_TYPE , class H , class T >

SPECIFIC_TYPE* Trinity::Find	(	ContainerUnorderedMap< TypeList< H, T >, KEY_TYPE > const &	elements,
		KEY_TYPE const &	handle,
		SPECIFIC_TYPE *
	)

 {
 SPECIFIC_TYPE* ret = Find(elements._elements, handle, (SPECIFIC_TYPE*)nullptr);
 return ret ? ret : Find(elements._TailElements, handle, (SPECIFIC_TYPE*)nullptr);
 }

Here is the call graph for this function:

template<class SPECIFIC_TYPE , class KEY_TYPE >

bool Trinity::Insert	(	ContainerUnorderedMap< SPECIFIC_TYPE, KEY_TYPE > &	elements,
		KEY_TYPE const &	handle,
		SPECIFIC_TYPE *	obj
	)

 {
 auto i = elements._element.find(handle);
 if (i == elements._element.end())
 {
 elements._element[handle] = obj;
 return true;
 }
 else
 {
 ASSERT(i->second == obj, "Object with certain key already in but objects are different!");
 return false;
 }
 }

Here is the caller graph for this function:

template<class SPECIFIC_TYPE , class KEY_TYPE >

bool Trinity::Insert	(	ContainerUnorderedMap< TypeNull, KEY_TYPE > &	,
		KEY_TYPE const &	,
		SPECIFIC_TYPE *
	)

 {
 return false;
 }

template<class SPECIFIC_TYPE , class KEY_TYPE , class T >

bool Trinity::Insert	(	ContainerUnorderedMap< T, KEY_TYPE > &	,
		KEY_TYPE const &	,
		SPECIFIC_TYPE *
	)

 {
 return false;
 }

template<class SPECIFIC_TYPE , class KEY_TYPE , class H , class T >

bool Trinity::Insert	(	ContainerUnorderedMap< TypeList< H, T >, KEY_TYPE > &	elements,
		KEY_TYPE const &	handle,
		SPECIFIC_TYPE *	obj
	)

 {
 bool ret = Insert(elements._elements, handle, obj);
 return ret ? ret : Insert(elements._TailElements, handle, obj);
 }

Here is the call graph for this function:

template<class SPECIFIC_TYPE >

SPECIFIC_TYPE* Trinity::Insert	(	ContainerMapList< SPECIFIC_TYPE > &	elements,
		SPECIFIC_TYPE *	obj
	)

 {
 //elements._element[hdl] = obj;
 obj->AddToGrid(elements._element);
 return obj;
 }

template<class SPECIFIC_TYPE >

SPECIFIC_TYPE* Trinity::Insert	(	ContainerMapList< TypeNull > &	,
		SPECIFIC_TYPE *
	)

 {
 return nullptr;
 }

template<class SPECIFIC_TYPE , class T >

SPECIFIC_TYPE* Trinity::Insert	(	ContainerMapList< T > &	,
		SPECIFIC_TYPE *
	)

 {
 return nullptr; // a missed
 }

template<class SPECIFIC_TYPE , class H , class T >

SPECIFIC_TYPE* Trinity::Insert	(	ContainerMapList< TypeList< H, T >> &	elements,
		SPECIFIC_TYPE *	obj
	)

 {
 SPECIFIC_TYPE* t = Insert(elements._elements, obj);
 return (t != nullptr ? t : Insert(elements._TailElements, obj));
 }

Here is the call graph for this function:

bool Trinity::IsFormatEmptyOrNull ( const char *  fmt )

inline

Returns true if the given char pointer is null.

 {
 return fmt == nullptr;
 }

Here is the caller graph for this function:

bool Trinity::IsFormatEmptyOrNull ( std::string const &  fmt )

inline

Returns true if the given std::string is empty.

 {
 return fmt.empty();
 }

bool Trinity::IsValidMapCoord ( float  c )

inline

 {
 return std::isfinite(c) && (std::fabs(c) <= MAP_HALFSIZE - 0.5f);
 }

Here is the caller graph for this function:

bool Trinity::IsValidMapCoord ( float  x, float  y  )

inline

 {
 return IsValidMapCoord(x) && IsValidMapCoord(y);
 }

Here is the call graph for this function:

bool Trinity::IsValidMapCoord ( float  x, float  y, float  z  )

inline

 {
 return IsValidMapCoord(x, y) && IsValidMapCoord(z);
 }

Here is the call graph for this function:

bool Trinity::IsValidMapCoord ( float  x, float  y, float  z, float  o  )

inline

 {
 return IsValidMapCoord(x, y, z) && std::isfinite(o);
 }

Here is the call graph for this function:

template<typename T , typename... Args>

std::unique_ptr<T> Trinity::make_unique

(

Args &&...

args

)

std::make_unique implementation (TODO: remove this once C++14 is supported)

 {
 return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
 }

Here is the caller graph for this function:

void Trinity::NormalizeMapCoord ( float &  c )

inline

 {
 if (c > MAP_HALFSIZE - 0.5f)
 c = MAP_HALFSIZE - 0.5f;
 else if (c < -(MAP_HALFSIZE - 0.5f))
 c = -(MAP_HALFSIZE - 0.5f);
 }

Here is the caller graph for this function:

template<class SPECIFIC_TYPE , class KEY_TYPE >

bool Trinity::Remove	(	ContainerUnorderedMap< SPECIFIC_TYPE, KEY_TYPE > &	elements,
		KEY_TYPE const &	handle,
		SPECIFIC_TYPE *
	)

 {
 elements._element.erase(handle);
 return true;
 }

Here is the caller graph for this function:

template<class SPECIFIC_TYPE , class KEY_TYPE >

bool Trinity::Remove	(	ContainerUnorderedMap< TypeNull, KEY_TYPE > &	,
		KEY_TYPE const &	,
		SPECIFIC_TYPE *
	)

 {
 return false;
 }

template<class SPECIFIC_TYPE , class KEY_TYPE , class T >

bool Trinity::Remove	(	ContainerUnorderedMap< T, KEY_TYPE > &	,
		KEY_TYPE const &	,
		SPECIFIC_TYPE *
	)

 {
 return false;
 }

template<class SPECIFIC_TYPE , class KEY_TYPE , class H , class T >

bool Trinity::Remove	(	ContainerUnorderedMap< TypeList< H, T >, KEY_TYPE > &	elements,
		KEY_TYPE const &	handle,
		SPECIFIC_TYPE *
	)

 {
 bool ret = Remove(elements._elements, handle, (SPECIFIC_TYPE*)nullptr);
 return ret ? ret : Remove(elements._TailElements, handle, (SPECIFIC_TYPE*)nullptr);
 }

Here is the call graph for this function:

template<typename Format , typename... Args>

std::string Trinity::StringFormat ( Format &&  fmt, Args &&...  args  )

inline

Default TC string format function.

 {
 return fmt::sprintf(std::forward<Format>(fmt), std::forward<Args>(args)...);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

TC_COMMON_API void Trinity::Warning	(	char const *	file,
		int	line,
		char const *	function,
		char const *	message
	)

{
 fprintf(stderr, "\n%s:%i in %s WARNING:\n %s\n",
 file, line, function, message);
}

Here is the call graph for this function: