diff --git a/extensions/sdktools/extension.cpp b/extensions/sdktools/extension.cpp index ceb53208..b64a9d7b 100644 --- a/extensions/sdktools/extension.cpp +++ b/extensions/sdktools/extension.cpp @@ -34,16 +34,19 @@ SDKTools g_SdkTools; /**< Global singleton for extension's main interface */ IServerGameEnts *gameents = NULL; +IEngineTrace *enginetrace = NULL; IBinTools *g_pBinTools = NULL; IGameConfig *g_pGameConf = NULL; IGameHelpers *g_pGameHelpers = NULL; IEngineSound *engsound = NULL; HandleType_t g_CallHandle = 0; +HandleType_t g_TraceHandle = 0; SMEXT_LINK(&g_SdkTools); extern sp_nativeinfo_t g_CallNatives[]; extern sp_nativeinfo_t g_TENatives[]; +extern sp_nativeinfo_t g_TRNatives[]; bool SDKTools::SDK_OnLoad(char *error, size_t maxlength, bool late) { @@ -52,6 +55,7 @@ bool SDKTools::SDK_OnLoad(char *error, size_t maxlength, bool late) sharesys->AddNatives(myself, g_Natives); sharesys->AddNatives(myself, g_TENatives); sharesys->AddNatives(myself, g_SoundNatives); + sharesys->AddNatives(myself, g_TRNatives); SM_GET_IFACE(GAMEHELPERS, g_pGameHelpers); @@ -61,6 +65,7 @@ bool SDKTools::SDK_OnLoad(char *error, size_t maxlength, bool late) } g_CallHandle = handlesys->CreateType("ValveCall", this, 0, NULL, NULL, myself->GetIdentity(), NULL); + g_TraceHandle = handlesys->CreateType("TraceRay", this, 0, NULL, NULL, myself->GetIdentity(), NULL); ConCommandBaseMgr::OneTimeInit(this); @@ -74,6 +79,11 @@ void SDKTools::OnHandleDestroy(HandleType_t type, void *object) ValveCall *v = (ValveCall *)object; delete v; } + if (type == g_TraceHandle) + { + trace_t *tr = (trace_t *)object; + delete tr; + } } void SDKTools::SDK_OnUnload() @@ -96,6 +106,7 @@ bool SDKTools::SDK_OnMetamodLoad(ISmmAPI *ismm, char *error, size_t maxlen, bool { GET_V_IFACE_ANY(serverFactory, gameents, IServerGameEnts, INTERFACEVERSION_SERVERGAMEENTS); GET_V_IFACE_ANY(engineFactory, engsound, IEngineSound, IENGINESOUND_SERVER_INTERFACE_VERSION); + GET_V_IFACE_ANY(engineFactory, enginetrace, IEngineTrace, INTERFACEVERSION_ENGINETRACE_SERVER); return true; } diff --git a/extensions/sdktools/extension.h b/extensions/sdktools/extension.h index d35d57e6..8f53e504 100644 --- a/extensions/sdktools/extension.h +++ b/extensions/sdktools/extension.h @@ -33,6 +33,7 @@ #include #include #include +#include #include #include @@ -66,10 +67,12 @@ public: //IConCommandBaseAccessor }; extern IServerGameEnts *gameents; +extern IEngineTrace *enginetrace; extern IBinTools *g_pBinTools; extern IGameConfig *g_pGameConf; extern IGameHelpers *g_pGameHelpers; -extern HandleType_t g_CallHandle; extern IEngineSound *engsound; +extern HandleType_t g_CallHandle; +extern HandleType_t g_TraceHandle; #endif //_INCLUDE_SOURCEMOD_EXTENSION_PROPER_H_ diff --git a/extensions/sdktools/msvc8/sdktools.vcproj b/extensions/sdktools/msvc8/sdktools.vcproj index 1f40fe2f..fe390115 100644 --- a/extensions/sdktools/msvc8/sdktools.vcproj +++ b/extensions/sdktools/msvc8/sdktools.vcproj @@ -1,7 +1,7 @@ + + diff --git a/extensions/sdktools/tempents.cpp b/extensions/sdktools/tempents.cpp index c0d8a007..b54cb2c1 100644 --- a/extensions/sdktools/tempents.cpp +++ b/extensions/sdktools/tempents.cpp @@ -125,7 +125,7 @@ bool TempEntityInfo::TE_SetEntData(const char *name, int value) *((uint8_t *)m_Me + offset) = value; } else if (size <= 16) { *(short *)((uint8_t *)m_Me + offset) = value; - } else if (size <= 32){ + } else if (size <= 32) { *(int *)((uint8_t *)m_Me + offset) = value; } else { return false; diff --git a/extensions/sdktools/trnatives.cpp b/extensions/sdktools/trnatives.cpp new file mode 100644 index 00000000..a7379cc6 --- /dev/null +++ b/extensions/sdktools/trnatives.cpp @@ -0,0 +1,386 @@ +/** + * vim: set ts=4 : + * =============================================================== + * SourceMod SDK Tools Extension + * Copyright (C) 2004-2007 AlliedModders LLC. All rights reserved. + * =============================================================== + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Version: $Id$ + */ + +#include "extension.h" +#include + +class CSMTraceFilter : public CTraceFilter +{ +public: + bool ShouldHitEntity(IHandleEntity *pEntity, int contentsMask) + { + cell_t res = 1; + edict_t *pEdict = gameents->BaseEntityToEdict(reinterpret_cast(pEntity)); + m_pFunc->PushCell(engine->IndexOfEdict(pEdict)); + m_pFunc->PushCell(contentsMask); + m_pFunc->Execute(&res); + + return (res) ? true : false; + } + void SetFunctionPtr(IPluginFunction *pFunc) + { + m_pFunc = pFunc; + } +private: + IPluginFunction *m_pFunc; +}; + +/* Used for the global trace version */ +Ray_t g_Ray; +trace_t g_Trace; +Vector g_StartVec; +Vector g_EndVec; +QAngle g_DirAngles; +CTraceFilterHitAll g_HitAllFilter; +CSMTraceFilter g_SMTraceFilter; + +enum +{ + RayType_EndPoint, + RayType_Infinite +}; + +static cell_t smn_TRTraceRay(IPluginContext *pContext, const cell_t *params) +{ + cell_t *startaddr, *endaddr; + pContext->LocalToPhysAddr(params[1], &startaddr); + pContext->LocalToPhysAddr(params[2], &endaddr); + + g_StartVec.Init(sp_ctof(startaddr[0]), sp_ctof(startaddr[1]), sp_ctof(startaddr[2])); + + switch (params[4]) + { + case RayType_EndPoint: + { + g_EndVec.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2])); + break; + } + case RayType_Infinite: + { + g_DirAngles.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2])); + AngleVectors(g_DirAngles, &g_EndVec); + + /* Make it unitary and get the ending point */ + g_EndVec.NormalizeInPlace(); + g_EndVec = g_StartVec + g_EndVec * MAX_TRACE_LENGTH; + break; + } + } + + g_Ray.Init(g_StartVec, g_EndVec); + enginetrace->TraceRay(g_Ray, params[3], &g_HitAllFilter, &g_Trace); + + return 1; +} + +static cell_t smn_TRTraceRayFilter(IPluginContext *pContext, const cell_t *params) +{ + cell_t *startaddr, *endaddr; + IPluginFunction *pFunc; + + pFunc = pContext->GetFunctionById(params[5]); + if (!pFunc) + { + return pContext->ThrowNativeError("Invalid function id (%X)", params[5]); + } + g_SMTraceFilter.SetFunctionPtr(pFunc); + pContext->LocalToPhysAddr(params[1], &startaddr); + pContext->LocalToPhysAddr(params[2], &endaddr); + + g_StartVec.Init(sp_ctof(startaddr[0]), sp_ctof(startaddr[1]), sp_ctof(startaddr[2])); + + switch (params[4]) + { + case RayType_EndPoint: + { + g_EndVec.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2])); + break; + } + case RayType_Infinite: + { + g_DirAngles.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2])); + AngleVectors(g_DirAngles, &g_EndVec); + + /* Make it unitary and get the ending point */ + g_EndVec.NormalizeInPlace(); + g_EndVec = g_StartVec + g_EndVec * MAX_TRACE_LENGTH; + break; + } + } + + g_Ray.Init(g_StartVec, g_EndVec); + enginetrace->TraceRay(g_Ray, params[3], &g_SMTraceFilter, &g_Trace); + + return 1; +} + +static cell_t smn_TRTraceRayEx(IPluginContext *pContext, const cell_t *params) +{ + cell_t *startaddr, *endaddr; + pContext->LocalToPhysAddr(params[1], &startaddr); + pContext->LocalToPhysAddr(params[2], &endaddr); + + Vector StartVec, EndVec; + Ray_t ray; + + StartVec.Init(sp_ctof(startaddr[0]), sp_ctof(startaddr[1]), sp_ctof(startaddr[2])); + + switch (params[4]) + { + case RayType_EndPoint: + { + EndVec.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2])); + break; + } + case RayType_Infinite: + { + QAngle DirAngles; + DirAngles.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2])); + AngleVectors(DirAngles, &EndVec); + + /* Make it unitary and get the ending point */ + EndVec.NormalizeInPlace(); + EndVec = StartVec + EndVec * MAX_TRACE_LENGTH; + break; + } + } + + trace_t *tr = new trace_t; + ray.Init(StartVec, EndVec); + enginetrace->TraceRay(ray, params[3], &g_HitAllFilter, tr); + + HandleError herr; + Handle_t hndl; + if (!(hndl=handlesys->CreateHandle(g_TraceHandle, tr, pContext->GetIdentity(), myself->GetIdentity(), &herr))) + { + delete tr; + return pContext->ThrowNativeError("Unable to create a new trace handle (error %d)", herr); + } + + return hndl; +} + +static cell_t smn_TRTraceRayFilterEx(IPluginContext *pContext, const cell_t *params) +{ + IPluginFunction *pFunc; + cell_t *startaddr, *endaddr; + + pFunc = pContext->GetFunctionById(params[5]); + if (!pFunc) + { + return pContext->ThrowNativeError("Invalid function id (%X)", params[5]); + } + pContext->LocalToPhysAddr(params[1], &startaddr); + pContext->LocalToPhysAddr(params[2], &endaddr); + + Vector StartVec, EndVec; + CSMTraceFilter smfilter; + Ray_t ray; + + smfilter.SetFunctionPtr(pFunc); + StartVec.Init(sp_ctof(startaddr[0]), sp_ctof(startaddr[1]), sp_ctof(startaddr[2])); + + switch (params[4]) + { + case RayType_EndPoint: + { + EndVec.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2])); + break; + } + case RayType_Infinite: + { + QAngle DirAngles; + DirAngles.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2])); + AngleVectors(DirAngles, &EndVec); + + /* Make it unitary and get the ending point */ + EndVec.NormalizeInPlace(); + EndVec = StartVec + EndVec * MAX_TRACE_LENGTH; + break; + } + } + + trace_t *tr = new trace_t; + ray.Init(StartVec, EndVec); + enginetrace->TraceRay(ray, params[3], &smfilter, tr); + + HandleError herr; + Handle_t hndl; + if (!(hndl=handlesys->CreateHandle(g_TraceHandle, tr, pContext->GetIdentity(), myself->GetIdentity(), &herr))) + { + delete tr; + return pContext->ThrowNativeError("Unable to create a new trace handle (error %d)", herr); + } + + return hndl; +} + +static cell_t smn_TRGetFraction(IPluginContext *pContext, const cell_t *params) +{ + trace_t *tr; + HandleError err; + HandleSecurity sec(pContext->GetIdentity(), myself->GetIdentity()); + + if (params[1] == BAD_HANDLE) + { + tr = &g_Trace; + } else if ((err = handlesys->ReadHandle(params[1], g_TraceHandle, &sec, (void **)&tr)) != HandleError_None) { + return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[1], err); + } + + return sp_ftoc(tr->fraction); +} + +static cell_t smn_TRGetEndPosition(IPluginContext *pContext, const cell_t *params) +{ + trace_t *tr; + HandleError err; + HandleSecurity sec(pContext->GetIdentity(), myself->GetIdentity()); + + if (params[2] == BAD_HANDLE) + { + tr = &g_Trace; + } else if ((err = handlesys->ReadHandle(params[2], g_TraceHandle, &sec, (void **)&tr)) != HandleError_None) { + return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[2], err); + } + + cell_t *addr; + pContext->LocalToPhysAddr(params[1], &addr); + + addr[0] = sp_ftoc(tr->endpos.x); + addr[1] = sp_ftoc(tr->endpos.y); + addr[2] = sp_ftoc(tr->endpos.z); + + return 1; +} + +static cell_t smn_TRDidHit(IPluginContext *pContext, const cell_t *params) +{ + trace_t *tr; + HandleError err; + HandleSecurity sec(pContext->GetIdentity(), myself->GetIdentity()); + + if (params[1] == BAD_HANDLE) + { + tr = &g_Trace; + } else if ((err = handlesys->ReadHandle(params[1], g_TraceHandle, &sec, (void **)&tr)) != HandleError_None) { + return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[1], err); + } + + return tr->DidHit() ? 1 : 0; +} + +static cell_t smn_TRGetHitGroup(IPluginContext *pContext, const cell_t *params) +{ + trace_t *tr; + HandleError err; + HandleSecurity sec(pContext->GetIdentity(), myself->GetIdentity()); + + if (params[1] == BAD_HANDLE) + { + tr = &g_Trace; + } else if ((err = handlesys->ReadHandle(params[1], g_TraceHandle, &sec, (void **)&tr)) != HandleError_None) { + return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[1], err); + } + + return tr->hitgroup; +} + +static cell_t smn_TRGetEntityIndex(IPluginContext *pContext, const cell_t *params) +{ + trace_t *tr; + HandleError err; + HandleSecurity sec(pContext->GetIdentity(), myself->GetIdentity()); + + if (params[1] == BAD_HANDLE) + { + tr = &g_Trace; + } else if ((err = handlesys->ReadHandle(params[1], g_TraceHandle, &sec, (void **)&tr)) != HandleError_None) { + return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[1], err); + } + + edict_t *pEdict = gameents->BaseEntityToEdict(tr->m_pEnt); + return engine->IndexOfEdict(pEdict); +} + +static cell_t smn_TRGetPointContents(IPluginContext *pContext, const cell_t *params) +{ + cell_t *vec, *ent; + IHandleEntity *hentity; + Vector pos; + int mask; + + pContext->LocalToPhysAddr(params[1], &vec); + pContext->LocalToPhysAddr(params[2], &ent); + + pos.x = sp_ctof(vec[0]); + pos.y = sp_ctof(vec[1]); + pos.z = sp_ctof(vec[2]); + + if (*ent == -1) + { + mask = enginetrace->GetPointContents(pos); + } else { + mask = enginetrace->GetPointContents(pos, &hentity); + edict_t *pEdict = gameents->BaseEntityToEdict(reinterpret_cast(hentity)); + *ent = engine->IndexOfEdict(pEdict); + } + + return mask; +} + +static cell_t smn_TRGetPointContentsEnt(IPluginContext *pContext, const cell_t *params) +{ + edict_t *pEdict = engine->PEntityOfEntIndex(params[1]); + if (!pEdict || pEdict->IsFree()) + { + return pContext->ThrowNativeError("Entity %d is invalid", params[1]); + } + + cell_t *addr; + Vector pos; + + pContext->LocalToPhysAddr(params[2], &addr); + + pos.x = sp_ctof(addr[0]); + pos.y = sp_ctof(addr[1]); + pos.z = sp_ctof(addr[2]); + + return enginetrace->GetPointContents_Collideable(pEdict->GetCollideable(), pos); +} + +sp_nativeinfo_t g_TRNatives[] = +{ + {"TR_TraceRay", smn_TRTraceRay}, + {"TR_TraceRayEx", smn_TRTraceRayEx}, + {"TR_GetFraction", smn_TRGetFraction}, + {"TR_GetEndPosition", smn_TRGetEndPosition}, + {"TR_GetEntityIndex", smn_TRGetEntityIndex}, + {"TR_DidHit", smn_TRDidHit}, + {"TR_GetHitGroup", smn_TRGetHitGroup}, + {"TR_GetPointContents", smn_TRGetPointContents}, + {"TR_GetPointContentsEnt", smn_TRGetPointContentsEnt}, + {"TR_TraceRayFilter", smn_TRTraceRayFilter}, + {"TR_TraceRayFilterEx", smn_TRTraceRayFilterEx}, + {NULL, NULL} +}; diff --git a/plugins/include/sdktools.inc b/plugins/include/sdktools.inc index c2f8f6f6..8ec2be01 100644 --- a/plugins/include/sdktools.inc +++ b/plugins/include/sdktools.inc @@ -25,6 +25,7 @@ #if !defined SDKTOOLS_DISABLE_SOUNDAPI #include #endif +#include enum SDKCallType { diff --git a/plugins/include/sdktools_trace.inc b/plugins/include/sdktools_trace.inc new file mode 100644 index 00000000..ea722b98 --- /dev/null +++ b/plugins/include/sdktools_trace.inc @@ -0,0 +1,215 @@ +/** + * vim: set ts=4 : + * =============================================================== + * SourceMod (C)2004-2007 AlliedModders LLC. All rights reserved. + * =============================================================== + * + * This file is part of the SourceMod/SourcePawn SDK. This file may only be used + * or modified under the Terms and Conditions of its License Agreement, which is found + * in LICENSE.txt. The Terms and Conditions for making SourceMod extensions/plugins + * may change at any time. To view the latest information, see: + * http://www.sourcemod.net/license.php + * + * Version: $Id$ + */ + +#if defined _sdktools_trace_included + #endinput +#endif +#define _sdktools_trace_included + +#define CONTENTS_EMPTY 0 /**< No contents. */ +#define CONTENTS_SOLID 0x1 /**< an eye is never valid in a solid . */ +#define CONTENTS_WINDOW 0x2 /**< translucent, but not watery (glass). */ +#define CONTENTS_AUX 0x4 +#define CONTENTS_GRATE 0x8 /**< alpha-tested "grate" textures. Bullets/sight pass through, but solids don't. */ +#define CONTENTS_SLIME 0x10 +#define CONTENTS_WATER 0x20 +#define CONTENTS_MIST 0x40 +#define CONTENTS_OPAQUE 0x80 /**< things that cannot be seen through (may be non-solid though). */ +#define LAST_VISIBLE_CONTENTS 0x80 +#define ALL_VISIBLE_CONTENTS (LAST_VISIBLE_CONTENTS | (LAST_VISIBLE_CONTENTS-1)) +#define CONTENTS_TESTFOGVOLUME 0x100 +#define CONTENTS_UNUSED5 0x200 +#define CONTENTS_UNUSED6 0x4000 +#define CONTENTS_TEAM1 0x800 /**< per team contents used to differentiate collisions. */ +#define CONTENTS_TEAM2 0x1000 /**< between players and objects on different teams. */ +#define CONTENTS_IGNORE_NODRAW_OPAQUE 0x2000 /**< ignore CONTENTS_OPAQUE on surfaces that have SURF_NODRAW. */ +#define CONTENTS_MOVEABLE 0x4000 /**< hits entities which are MOVETYPE_PUSH (doors, plats, etc) */ +#define CONTENTS_AREAPORTAL 0x8000 /**< remaining contents are non-visible, and don't eat brushes. */ +#define CONTENTS_PLAYERCLIP 0x10000 +#define CONTENTS_MONSTERCLIP 0x20000 + +/** + * @section currents can be added to any other contents, and may be mixed + */ +#define CONTENTS_CURRENT_0 0x40000 +#define CONTENTS_CURRENT_90 0x80000 +#define CONTENTS_CURRENT_180 0x100000 +#define CONTENTS_CURRENT_270 0x200000 +#define CONTENTS_CURRENT_UP 0x400000 +#define CONTENTS_CURRENT_DOWN 0x800000 + +/** + * @endsection + */ + +#define CONTENTS_ORIGIN 0x1000000 /**< removed before bsping an entity. */ +#define CONTENTS_MONSTER 0x2000000 /**< should never be on a brush, only in game. */ +#define CONTENTS_DEBRIS 0x4000000 +#define CONTENTS_DETAIL 0x8000000 /**< brushes to be added after vis leafs. */ +#define CONTENTS_TRANSLUCENT 0x10000000 /**< auto set if any surface has trans. */ +#define CONTENTS_LADDER 0x20000000 +#define CONTENTS_HITBOX 0x40000000 /**< use accurate hitboxes on trace. */ + +/** + * @section Trace masks. + */ +#define MASK_ALL (0xFFFFFFFF) +#define MASK_SOLID (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_WINDOW|CONTENTS_MONSTER|CONTENTS_GRATE) /**< everything that is normally solid */ +#define MASK_PLAYERSOLID (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_PLAYERCLIP|CONTENTS_WINDOW|CONTENTS_MONSTER|CONTENTS_GRATE) /**< everything that blocks player movement */ +#define MASK_NPCSOLID (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_MONSTERCLIP|CONTENTS_WINDOW|CONTENTS_MONSTER|CONTENTS_GRATE) /**< blocks npc movement */ +#define MASK_WATER (CONTENTS_WATER|CONTENTS_MOVEABLE|CONTENTS_SLIME) /**< water physics in these contents */ +#define MASK_OPAQUE (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_OPAQUE) /**< everything that blocks line of sight for AI, lighting, etc */ +#define MASK_OPAQUE_AND_NPCS (MASK_OPAQUE|CONTENTS_MONSTER) /**< everything that blocks line of sight for AI, lighting, etc, but with monsters added. */ +#define MASK_VISIBLE (MASK_OPAQUE|CONTENTS_IGNORE_NODRAW_OPAQUE) /**< everything that blocks line of sight for players */ +#define MASK_VISIBLE_AND_NPCS (MASK_OPAQUE_AND_NPCS|CONTENTS_IGNORE_NODRAW_OPAQUE) /**< everything that blocks line of sight for players, but with monsters added. */ +#define MASK_SHOT (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_MONSTER|CONTENTS_WINDOW|CONTENTS_DEBRIS|CONTENTS_HITBOX) /**< bullets see these as solid */ +#define MASK_SHOT_HULL (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_MONSTER|CONTENTS_WINDOW|CONTENTS_DEBRIS|CONTENTS_GRATE) /**< non-raycasted weapons see this as solid (includes grates) */ +#define MASK_SHOT_PORTAL (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_WINDOW) /**< hits solids (not grates) and passes through everything else */ +#define MASK_SOLID_BRUSHONLY (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_WINDOW|CONTENTS_GRATE) /**< everything normally solid, except monsters (world+brush only) */ +#define MASK_PLAYERSOLID_BRUSHONLY (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_WINDOW|CONTENTS_PLAYERCLIP|CONTENTS_GRATE) /**< everything normally solid for player movement, except monsters (world+brush only) */ +#define MASK_NPCSOLID_BRUSHONLY (CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_WINDOW|CONTENTS_MONSTERCLIP|CONTENTS_GRATE) /**< everything normally solid for npc movement, except monsters (world+brush only) */ +#define MASK_NPCWORLDSTATIC (CONTENTS_SOLID|CONTENTS_WINDOW|CONTENTS_MONSTERCLIP|CONTENTS_GRATE) /**< just the world, used for route rebuilding */ +#define MASK_SPLITAREAPORTAL (CONTENTS_WATER|CONTENTS_SLIME) /**< These are things that can split areaportals */ + +/** + * @endsection + */ + +enum RayType +{ + RayType_EndPoint, /**< The trace ray will go from the start position to the end position. */ + RayType_Infinite /**< The trace ray will go from the start position to infinity using a direction vector. */ +}; + +/** + * Called on entity filtering. + * + * @param entity Entity index. + * @param contentsMask Contents Mask. + * @return True to allow the current entity to be hit, otherwise false. + */ +functag TraceEntityFilter bool:public(entity, contentsMask); + +/** + * Get the contents mask and the entity index at the given position. + * + * @param pos World position to test. + * @param entindex Entity index found at the given position (by reference). + * @return Contents mask. + */ +native TR_GetPointContents(const Float:pos[3], &entindex=-1); + +/** + * Get the point contents testing only the given entity index. + * + * @param entindex Entity index to test. + * @param pos World position. + * @return Contents mask. + */ +native TR_GetPointContentsEnt(entindex, const Float:pos[3]); + +/** + * Starts up a new trace ray using a global trace result. + * + * @param pos Starting position of the ray. + * @param vec Depending on RayType, it will be used as the ending point, or the direction angle. + * @param flags Trace flags. + * @param rtype Method to calculate the ray direction. + * @noreturn + */ +native TR_TraceRay(const Float:pos[3], const Float:vec[3], flags, RayType:rtype); + +/** + * Starts up a new trace ray using a global trace result and a customized trace ray filter. + * + * @param pos Starting position of the ray. + * @param vec Depending on RayType, it will be used as the ending point, or the direction angle. + * @param flags Trace flags. + * @param rtype Method to calculate the ray direction. + * @param filter Function to use as a filter. + * @noreturn + */ +native TR_TraceRayFilter(const Float:pos[3], const Float:vec[3], flags, RayType:rtype, TraceEntityFilter:filter); + +/** + * Starts up a new trace ray using a new trace result. + * + * @param pos Starting position of the ray. + * @param vec Depending on RayType, it will be used as the ending point, or the direction angle. + * @param flags Trace flags. + * @param rtype Method to calculate the ray direction. + * @return Ray trace handle. + * @note Traces are closed with CloseHandle(). + */ +native Handle:TR_TraceRayEx(const Float:pos[3], const Float:vec[3], flags, RayType:rtype); + +/** + * Starts up a new trace ray using a new trace result and a customized trace ray filter. + * + * @param pos Starting position of the ray. + * @param vec Depending on RayType, it will be used as the ending point, or the direction angle. + * @param flags Trace flags. + * @param rtype Method to calculate the ray direction. + * @param filter Function to use as a filter. + * @return Ray trace handle. + * @note Traces are closed with CloseHandle(). + */ +native Handle:TR_TraceRayFilterEx(const Float:pos[3], const Float:vec[3], flags, RayType:rtype, TraceEntityFilter:filter); + +/** + * Returns the time fraction from a trace result (1.0 means no collision). + * + * @param hndl A trace Handle, or INVALID_HANDLE to use a global trace result. + * @return Time fraction value of the trace. + * @error Invalid Handle. + */ +native Float:TR_GetFraction(Handle:hndl=INVALID_HANDLE); + +/** + * Returns the collision position of a trace result. + * + * @param pos Vector buffer to store data in. + * @param hndl A trace Handle, or INVALID_HANDLE to use a global trace result. + * @noreturn + * @error Invalid Handle. + */ +native TR_GetEndPosition(Float:pos[3], Handle:hndl=INVALID_HANDLE); + +/** + * Returns the entity index that collided with the trace. + * + * @param hndl A trace Handle, or INVALID_HANDLE to use a global trace result. + * @return Entity index or -1 for no collision. + * @error Invalid Handle. + */ +native TR_GetEntityIndex(Handle:hndl=INVALID_HANDLE); + +/** + * Returns if there was any kind of collision along the trace ray. + * + * @param hndl A trace Handle, or INVALID_HANDLE to use a global trace result. + * @return True if any collision found, otherwise false. + * @error Invalid Handle. + */ +native bool:TR_DidHit(Handle:hndl=INVALID_HANDLE); + +/** + * Returns in which body hit group the trace collided if any. + * + * @param hndl A trace Handle, or INVALID_HANDLE to use a global trace result. + * @return Body hit group. + * @error Invalid Handle. + */ +native TR_GetHitGroup(Handle:hndl=INVALID_HANDLE);