static cell_t GetAbsAngles(IPluginContext *pContext, const cell_t *params)
{
int client = params[1];
CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
if (!pPlayer)
{
return pContext->ThrowNativeError("Client index %d is invalid", client);
} else if (!pPlayer->IsInGame()) {
return pContext->ThrowNativeError("Client %d is not in game", client);
}
IPlayerInfo *pInfo = pPlayer->GetPlayerInfo();
if (!pInfo)
{
return pContext->ThrowNativeError("IPlayerInfo not supported by game");
}
cell_t *pAng;
pContext->LocalToPhysAddr(params[2], &pAng);
QAngle ang = pInfo->GetAbsAngles();
pAng[0] = sp_ftoc(ang.x);
pAng[1] = sp_ftoc(ang.y);
pAng[2] = sp_ftoc(ang.z);
return 1;
}
static cell_t GetPlayerMaxs(IPluginContext *pContext, const cell_t *params)
{
int client = params[1];
CPlayer *pPlayer = g_Players.GetPlayerByIndex(client);
if (!pPlayer)
{
return pContext->ThrowNativeError("Client index %d is invalid", client);
} else if (!pPlayer->IsInGame()) {
return pContext->ThrowNativeError("Client %d is not in game", client);
}
IPlayerInfo *pInfo = pPlayer->GetPlayerInfo();
if (!pInfo)
{
return pContext->ThrowNativeError("IPlayerInfo not supported by game");
}
cell_t *pVec;
pContext->LocalToPhysAddr(params[2], &pVec);
Vector vec = pInfo->GetPlayerMaxs();
pVec[0] = sp_ftoc(vec.x);
pVec[1] = sp_ftoc(vec.y);
pVec[2] = sp_ftoc(vec.z);
return 1;
}
static cell_t GameRules_GetPropVector(IPluginContext *pContext, const cell_t *params)
{
char *prop;
int element = params[3];
int offset;
int bit_count;
void *pGameRules = GameRules();
if (!pGameRules || !g_szGameRulesProxy || !strcmp(g_szGameRulesProxy, ""))
return pContext->ThrowNativeError("Gamerules lookup failed.");
pContext->LocalToString(params[1], &prop);
FIND_PROP_SEND(DPT_Vector, "vector");
Vector *v = (Vector *)((intptr_t)pGameRules + offset);
cell_t *vec;
pContext->LocalToPhysAddr(params[2], &vec);
vec[0] = sp_ftoc(v->x);
vec[1] = sp_ftoc(v->y);
vec[2] = sp_ftoc(v->z);
return 1;
static cell_t smn_BfReadAngles(IPluginContext *pCtx, const cell_t *params)
{
Handle_t hndl = static_cast<Handle_t>(params[1]);
HandleError herr;
HandleSecurity sec;
bf_read *pBitBuf;
sec.pOwner = NULL;
sec.pIdentity = g_pCoreIdent;
if ((herr=handlesys->ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
!= HandleError_None)
{
return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
}
cell_t *pAng;
pCtx->LocalToPhysAddr(params[2], &pAng);
QAngle ang;
pBitBuf->ReadBitAngles(ang);
pAng[0] = sp_ftoc(ang.x);
pAng[1] = sp_ftoc(ang.y);
pAng[2] = sp_ftoc(ang.z);
return 1;
}
static cell_t GetClientEyePosition(IPluginContext *pContext, const cell_t *params)
{
IGamePlayer *player = playerhelpers->GetGamePlayer(params[1]);
if (player == NULL)
{
return pContext->ThrowNativeError("Invalid client index %d", params[1]);
}
if (!player->IsInGame())
{
return pContext->ThrowNativeError("Client %d is not in game", params[1]);
}
Vector pos;
#if SOURCE_ENGINE == SE_DOTA
serverClients->ClientEarPosition(params[1], &pos);
#else
serverClients->ClientEarPosition(player->GetEdict(), &pos);
#endif
cell_t *addr;
pContext->LocalToPhysAddr(params[2], &addr);
addr[0] = sp_ftoc(pos.x);
addr[1] = sp_ftoc(pos.y);
addr[2] = sp_ftoc(pos.z);
return 1;
}
static cell_t smn_BfReadVecNormal(IPluginContext *pCtx, const cell_t *params)
{
Handle_t hndl = static_cast<Handle_t>(params[1]);
HandleError herr;
HandleSecurity sec;
bf_read *pBitBuf;
sec.pOwner = NULL;
sec.pIdentity = g_pCoreIdent;
if ((herr=g_HandleSys.ReadHandle(hndl, g_RdBitBufType, &sec, (void **)&pBitBuf))
!= HandleError_None)
{
return pCtx->ThrowNativeError("Invalid bit buffer handle %x (error %d)", hndl, herr);
}
cell_t *pVec;
pCtx->LocalToPhysAddr(params[2], &pVec);
Vector vec;
pBitBuf->ReadBitVec3Normal(vec);
pVec[0] = sp_ftoc(vec.x);
pVec[1] = sp_ftoc(vec.y);
pVec[2] = sp_ftoc(vec.z);
return 1;
}
static cell_t smn_PbReadVector2D(IPluginContext *pCtx, const cell_t *params)
{
GET_MSG_FROM_HANDLE_OR_ERR();
GET_FIELD_NAME_OR_ERR();
cell_t *out;
pCtx->LocalToPhysAddr(params[3], &out);
Vector2D vec;
int index = params[0] >= 4 ? params[4] : -1;
if (index < 0)
{
if (!msg->GetVector2D(strField, &vec))
{
return pCtx->ThrowNativeError("Invalid field \"%s\" for message \"%s\"", strField, msg->GetProtobufMessage()->GetTypeName().c_str());
}
}
else
{
if (!msg->GetRepeatedVector2D(strField, index, &vec))
{
return pCtx->ThrowNativeError("Invalid field \"%s\"[%d] for message \"%s\"", strField, index, msg->GetProtobufMessage()->GetTypeName().c_str());
}
}
out[0] = sp_ftoc(vec.x);
out[1] = sp_ftoc(vec.y);
return 1;
}
static cell_t smn_TEReadVector(IPluginContext *pContext, const cell_t *params)
{
if (!g_TEManager.IsAvailable())
{
return pContext->ThrowNativeError("TempEntity System unsupported or not available, file a bug report");
}
if (!g_CurrentTE)
{
return pContext->ThrowNativeError("No TempEntity call is in progress");
}
char *prop;
pContext->LocalToString(params[1], &prop);
cell_t *addr;
float vec[3];
pContext->LocalToPhysAddr(params[2], &addr);
if (!g_CurrentTE->TE_GetEntDataVector(prop, vec))
{
return pContext->ThrowNativeError("Temp entity property \"%s\" not found", prop);
}
addr[0] = sp_ftoc(vec[0]);
addr[1] = sp_ftoc(vec[1]);
addr[2] = sp_ftoc(vec[2]);
return 1;
}
static cell_t GetClientEyeAngles(IPluginContext *pContext, const cell_t *params)
{
IGamePlayer *pPlayer = playerhelpers->GetGamePlayer(params[1]);
if (!pPlayer)
{
return pContext->ThrowNativeError("Invalid client index %d", params[1]);
}
else if (!pPlayer->IsInGame())
{
return pContext->ThrowNativeError("Client %d is not in game", params[1]);
}
edict_t *pEdict = pPlayer->GetEdict();
CBaseEntity *pEntity = pEdict->GetUnknown() ? pEdict->GetUnknown()->GetBaseEntity() : NULL;
/* We always set the angles for backwards compatibility --
* The original function had no return value.
*/
QAngle angles;
bool got_angles = false;
if (pEntity != NULL)
{
got_angles = GetEyeAngles(pEntity, &angles);
}
cell_t *addr;
pContext->LocalToPhysAddr(params[2], &addr);
addr[0] = sp_ftoc(angles.x);
addr[1] = sp_ftoc(angles.y);
addr[2] = sp_ftoc(angles.z);
return got_angles ? 1 : 0;
}
void SoundHooks::OnEmitAmbientSound(CEntityIndex index, const Vector &pos, const char *samp, float vol,
soundlevel_t soundlevel, int fFlags, int pitch, float delay)
{
int entindex = index.Get();
#else
void SoundHooks::OnEmitAmbientSound(int entindex, const Vector &pos, const char *samp, float vol,
soundlevel_t soundlevel, int fFlags, int pitch, float delay)
{
#endif
SoundHookIter iter;
IPluginFunction *pFunc;
cell_t vec[3] = {sp_ftoc(pos.x), sp_ftoc(pos.y), sp_ftoc(pos.z)};
cell_t res = static_cast<ResultType>(Pl_Continue);
char buffer[PLATFORM_MAX_PATH];
strcpy(buffer, samp);
for (iter=m_AmbientFuncs.begin(); iter!=m_AmbientFuncs.end(); iter++)
{
pFunc = (*iter);
pFunc->PushStringEx(buffer, sizeof(buffer), SM_PARAM_STRING_COPY, SM_PARAM_COPYBACK);
pFunc->PushCellByRef(&entindex);
pFunc->PushFloatByRef(&vol);
pFunc->PushCellByRef(reinterpret_cast<cell_t *>(&soundlevel));
pFunc->PushCellByRef(&pitch);
pFunc->PushArray(vec, 3, SM_PARAM_COPYBACK);
pFunc->PushCellByRef(&fFlags);
pFunc->PushFloatByRef(&delay);
g_InSoundHook = true;
pFunc->Execute(&res);
g_InSoundHook = false;
switch (res)
{
case Pl_Handled:
case Pl_Stop:
{
RETURN_META(MRES_SUPERCEDE);
}
case Pl_Changed:
{
Vector vec2;
vec2.x = sp_ctof(vec[0]);
vec2.y = sp_ctof(vec[1]);
vec2.z = sp_ctof(vec[2]);
#if SOURCE_ENGINE == SE_DOTA
RETURN_META_NEWPARAMS(MRES_IGNORED, &IVEngineServer::EmitAmbientSound,
(CEntityIndex(entindex), vec2, buffer, vol, soundlevel, fFlags, pitch, delay));
#else
RETURN_META_NEWPARAMS(MRES_IGNORED, &IVEngineServer::EmitAmbientSound,
(entindex, vec2, buffer, vol, soundlevel, fFlags, pitch, delay));
#endif
}
}
}
}
/*
=============================================================
Navigation_GetNextHidingSpot
Increment the list-counter and return the position.
=============================================================
*/
cell_t Navigation_GetNextHidingSpot(IPluginContext *pContext, const cell_t *params)
{
cell_t *pos;
pContext->LocalToPhysAddr(params[1], &pos);
Navigation::INavMeshHidingSpot *hidingSpot = Navigation::GetNextHidingSpot();
pos[0] = sp_ftoc(hidingSpot->GetX());
pos[1] = sp_ftoc(hidingSpot->GetY());
pos[2] = sp_ftoc(hidingSpot->GetZ());
return (true);
}
static cell_t GetVectorLength(IPluginContext *pContext, const cell_t *params)
{
cell_t *addr;
pContext->LocalToPhysAddr(params[1], &addr);
Vector source(sp_ctof(addr[0]), sp_ctof(addr[1]), sp_ctof(addr[2]));
if (!params[2])
{
return sp_ftoc(source.Length());
} else {
return sp_ftoc(source.LengthSqr());
}
}
static cell_t sm_FloatAbs(IPluginContext *pCtx, const cell_t *params)
{
float val = sp_ctof(params[1]);
val = (val >= 0.0f) ? val : -val;
return sp_ftoc(val);
}
static cell_t sm_ArcTangent(IPluginContext *pCtx, const cell_t *params)
{
float val = sp_ctof(params[1]);
val = atan(val);
return sp_ftoc(val);
}
static cell_t sm_ArcCosine(IPluginContext *pCtx, const cell_t *params)
{
float val = sp_ctof(params[1]);
val = acos(val);
return sp_ftoc(val);
}
static cell_t sm_FloatFraction(IPluginContext *pCtx, const cell_t *params)
{
float val = sp_ctof(params[1]);
val = val - floor(val);
return sp_ftoc(val);
}
static cell_t sm_Pow(IPluginContext *pCtx, const cell_t *params)
{
float base = sp_ctof(params[1]);
float exponent = sp_ctof(params[2]);
return sp_ftoc(pow(base, exponent));
}
static cell_t GetProfilerTime(IPluginContext *pContext, const cell_t *params)
{
Handle_t hndl = params[1];
HandleSecurity sec = HandleSecurity(pContext->GetIdentity(), g_pCoreIdent);
HandleError err;
Profiler *prof;
if ((err = g_HandleSys.ReadHandle(hndl, g_ProfilerType, &sec, (void **)&prof))
!= HandleError_None)
{
return pContext->ThrowNativeError("Invalid Handle %x (error %d)", hndl, err);
}
if (!prof->stopped)
{
return pContext->ThrowNativeError("Profiler was never stopped");
}
float fTime;
#if defined PLATFORM_WINDOWS
LONGLONG diff = prof->end.QuadPart - prof->start.QuadPart;
double seconds = diff * prof->freq;
fTime = (float)seconds;
#endif
return sp_ftoc(fTime);
}
static cell_t smn_PbReadFloat(IPluginContext *pCtx, const cell_t *params)
{
GET_MSG_FROM_HANDLE_OR_ERR();
GET_FIELD_NAME_OR_ERR();
float ret;
int index = params[0] >= 3 ? params[3] : -1;
if (index < 0)
{
if (!msg->GetFloatOrDouble(strField, &ret))
{
return pCtx->ThrowNativeError("Invalid field \"%s\" for message \"%s\"", strField, msg->GetProtobufMessage()->GetTypeName().c_str());
}
}
else
{
if (!msg->GetRepeatedFloatOrDouble(strField, index, &ret))
{
return pCtx->ThrowNativeError("Invalid field \"%s\"[%d] for message \"%s\"", strField, index, msg->GetProtobufMessage()->GetTypeName().c_str());
}
}
return sp_ftoc(ret);
}
static cell_t smn_GetDistGainFromSoundLevel(IPluginContext *pContext, const cell_t *params)
{
int decibel = params[1];
float distance = sp_ctof(params[2]);
return sp_ftoc(engsound->GetDistGainFromSoundLevel((soundlevel_t)decibel, distance));
}
static cell_t GetSoundDuration(IPluginContext *pContext, const cell_t *params)
{
char *name;
pContext->LocalToString(params[1], &name);
return sp_ftoc(engsound->GetSoundDuration(name));
}
// native bool:GetGameSoundParams(const String:gameSound[], &channel, &soundLevel, &Float:volume, &pitch, String:sample[], maxlength, entity=SOUND_FROM_WORLD)
static cell_t smn_GetGameSoundParams(IPluginContext *pContext, const cell_t *params)
{
char *soundname;
pContext->LocalToString(params[1], &soundname);
CSoundParameters soundParams;
if (!GetSoundParams(&soundParams, soundname, params[8]))
return false;
cell_t *channel;
cell_t *fakeVolume;
cell_t *pitch;
cell_t *soundLevel;
pContext->LocalToPhysAddr(params[2], &channel);
pContext->LocalToPhysAddr(params[3], &soundLevel);
pContext->LocalToPhysAddr(params[4], &fakeVolume);
pContext->LocalToPhysAddr(params[5], &pitch);
*channel = soundParams.channel;
*pitch = soundParams.pitch;
*soundLevel = (cell_t)soundParams.soundlevel;
*fakeVolume = sp_ftoc(soundParams.volume);
pContext->StringToLocal(params[6], params[7], soundParams.soundname);
// Precache the sound we're returning
if (!engsound->IsSoundPrecached(soundParams.soundname))
{
InternalPrecacheScriptSound(soundname);
}
return true;
}
static cell_t sm_GetConVarBounds(IPluginContext *pContext, const cell_t *params)
{
Handle_t hndl = static_cast<Handle_t>(params[1]);
HandleError err;
ConVar *pConVar;
if ((err=g_ConVarManager.ReadConVarHandle(hndl, &pConVar))
!= HandleError_None)
{
return pContext->ThrowNativeError("Invalid convar handle %x (error %d)", hndl, err);
}
cell_t *addr;
bool hasBound;
float bound;
switch (params[2])
{
case ConVarBound_Upper:
hasBound = pConVar->GetMax(bound);
break;
case ConVarBound_Lower:
hasBound = pConVar->GetMin(bound);
break;
default:
return pContext->ThrowNativeError("Invalid ConVarBounds value %d");
}
pContext->LocalToPhysAddr(params[3], &addr);
*addr = sp_ftoc(bound);
return hasBound;
}
static cell_t sm_GetStatFloat(IPluginContext *pContext, const cell_t *params)
{
ISteamGameServerStats *pStats = GetServerStatsPointer();
if (pStats == NULL)
{
return 0;
}
int client = gamehelpers->ReferenceToIndex(params[1]);
IGamePlayer *pPlayer = playerhelpers->GetGamePlayer(client); /* Man, including GameHelpers and PlayerHelpers for this native :(. */
if (pPlayer == NULL || pPlayer->IsConnected() == false)
{
return pContext->ThrowNativeError("Client index %d is invalid", params[1]);
}
char *pName;
pContext->LocalToString(params[2], &pName);
cell_t *pValue;
pContext->LocalToPhysAddr(params[3], &pValue);
CSteamID checkid = CreateCommonCSteamID(pPlayer, params, 4, 5);
float fValue;
bool bResult = pStats->GetUserStat(checkid, pName, &fValue);
*pValue = sp_ftoc(fValue);
return bResult ? 1 : 0;
}
static cell_t GetVectorDistance(IPluginContext *pContext, const cell_t *params)
{
cell_t *addr1, *addr2;
pContext->LocalToPhysAddr(params[1], &addr1);
pContext->LocalToPhysAddr(params[2], &addr2);
Vector source(sp_ctof(addr1[0]), sp_ctof(addr1[1]), sp_ctof(addr1[2]));
Vector dest(sp_ctof(addr2[0]), sp_ctof(addr2[1]), sp_ctof(addr2[2]));
if (!params[3])
{
return sp_ftoc(source.DistTo(dest));
} else {
return sp_ftoc(source.DistToSqr(dest));
}
}
static cell_t sm_ArcTangent2(IPluginContext *pCtx, const cell_t *params)
{
float val1 = sp_ctof(params[1]);
float val2 = sp_ctof(params[2]);
val1 = atan2(val1, val2);
return sp_ftoc(val1);
}
static cell_t GetRandomFloat(IPluginContext *pContext, const cell_t *params)
{
float fMin = sp_ctof(params[1]);
float fMax = sp_ctof(params[2]);
float fRandom = engrandom->RandomFloat(fMin, fMax);
return sp_ftoc(fRandom);
}
static cell_t GetEngineTime(IPluginContext *pContext, const cell_t *params)
{
#if SOURCE_ENGINE >= SE_NUCLEARDAWN
float fTime = Plat_FloatTime();
#else
float fTime = engine->Time();
#endif
return sp_ftoc(fTime);
}
static cell_t GetServerNetStats(IPluginContext *pContext, const cell_t *params)
{
if (iserver == NULL)
{
return pContext->ThrowNativeError("IServer interface not supported, file a bug report.");
}
float in, out;
cell_t *pIn, *pOut;
pContext->LocalToPhysAddr(params[1], &pIn);
pContext->LocalToPhysAddr(params[2], &pOut);
iserver->GetNetStats(in, out);
*pIn = sp_ftoc(in);
*pOut = sp_ftoc(out);
return 1;
}
static cell_t sm_SquareRoot(IPluginContext *pCtx, const cell_t *params)
{
float val = sp_ctof(params[1]);
if (val < 0.0f)
{
return pCtx->ThrowNativeError("Cannot evaluate the square root of a negative number (val:%f)", val);
}
return sp_ftoc(sqrt(val));
}
