static cell AMX_NATIVE_CALL is_visible(AMX *amx, cell *params) { int src = params[1]; int dest = params[2]; CHECK_ENTITY(src); CHECK_ENTITY(dest); edict_t *pEntity = INDEXENT2(src); edict_t *pTarget = INDEXENT2(dest); if (pTarget->v.flags & FL_NOTARGET) return 0; Vector vLooker = pEntity->v.origin + pEntity->v.view_ofs; Vector vTarget = pTarget->v.origin + pTarget->v.view_ofs; TraceResult tr; TRACE_LINE(vLooker, vTarget, FALSE, pEntity, &tr); if (tr.fInOpen && tr.fInWater) return 0; else if (tr.flFraction == 1.0) return 1; return 0; }
static cell AMX_NATIVE_CALL find_ent_by_owner(AMX *amx, cell *params) // native find_ent_by_owner(start_from_ent, classname[], owner_index); = 3 params { int iEnt = params[1]; int oEnt = params[3]; // Check index to start searching at, 0 must be possible for iEnt. CHECK_ENTITY_SIMPLE(oEnt); edict_t *pEnt = INDEXENT2(iEnt); edict_t *entOwner = INDEXENT2(oEnt); //optional fourth parameter is for jghg2 compatibility const char* sCategory = NULL; switch(params[4]){ case 1: sCategory = "target"; break; case 2: sCategory = "targetname"; break; default: sCategory = "classname"; } // No need to check if there is a real ent where entOwner points at since we don't access it anyway. int len; char* classname = MF_GetAmxString(amx, params[2], 0, &len); while (true) { pEnt = FIND_ENTITY_BY_STRING(pEnt, sCategory, classname); if (FNullEnt(pEnt)) // break and return 0 if bad break; else if (pEnt->v.owner == entOwner) // compare pointers return ENTINDEX(pEnt); } // If it comes here, the while loop ended because an ent failed (FNullEnt() == true) return 0; }
// Attachview, this allows you to attach a player's view to an entity. // use AttachView(player, player) to reset view. //(vexd) static cell AMX_NATIVE_CALL attach_view(AMX *amx, cell *params) { int iIndex = params[1]; int iTargetIndex = params[2]; CHECK_ENTITY(iIndex); SET_VIEW(INDEXENT2(iIndex), INDEXENT2(iTargetIndex)); return 1; }
static cell AMX_NATIVE_CALL entity_set_edict(AMX *amx, cell *params) { int iEnt = params[1]; int idx = params[2]; int iSetEnt = params[3]; CHECK_ENTITY_SIMPLE(iEnt); edict_t *pEnt = INDEXENT2(iEnt); edict_t *pSetEnt = INDEXENT2(iSetEnt); switch (idx) { case chain: pEnt->v.chain = pSetEnt; break; case dmg_inflictor: pEnt->v.dmg_inflictor = pSetEnt; break; case enemy: pEnt->v.enemy = pSetEnt; break; case aiment: pEnt->v.aiment = pSetEnt; break; case owner: pEnt->v.owner = pSetEnt; break; case groundentity: pEnt->v.groundentity = pSetEnt; break; case pContainingEntity: pEnt->v.pContainingEntity = pSetEnt; break; case euser1: pEnt->v.euser1 = pSetEnt; break; case euser2: pEnt->v.euser2 = pSetEnt; break; case euser3: pEnt->v.euser3 = pSetEnt; break; case euser4: pEnt->v.euser4 = pSetEnt; break; default: return 0; break; } return 1; }
static cell AMX_NATIVE_CALL entity_range(AMX *amx, cell *params) { int idxa = params[1]; int idxb = params[2]; CHECK_ENTITY(idxa); CHECK_ENTITY(idxb); edict_t *pEntA = INDEXENT2(idxa); edict_t *pEntB = INDEXENT2(idxb); REAL fRet = (pEntA->v.origin - pEntB->v.origin).Length(); return amx_ftoc(fRet); }
static cell AMX_NATIVE_CALL fake_touch(AMX *amx, cell *params) { int iPtr = params[1]; int iPtd = params[2]; CHECK_ENTITY(iPtr); CHECK_ENTITY(iPtd); edict_t *pToucher = INDEXENT2(iPtr); edict_t *pTouched = INDEXENT2(iPtd); MDLL_Touch(pToucher, pTouched); return 1; }
static cell AMX_NATIVE_CALL force_use(AMX *amx, cell *params) { int iPtr = params[1]; int iPtd = params[2]; CHECK_ENTITY(iPtr); CHECK_ENTITY(iPtd); edict_t *pUser = INDEXENT2(iPtr); edict_t *pUsed = INDEXENT2(iPtd); MDLL_Use(pUsed, pUser); return 1; }
//(mahnsawce) static cell AMX_NATIVE_CALL trace_hull(AMX *amx,cell *params) { int iResult=0; TraceResult tr; Vector vPos; cell *vCell; vCell = MF_GetAmxAddr(amx, params[1]); vPos.x = amx_ctof(vCell[0]); vPos.y = amx_ctof(vCell[1]); vPos.z = amx_ctof(vCell[2]); TRACE_HULL(vPos,vPos, params[4], params[2], params[3] > 0 ? INDEXENT2(params[3]) : 0 , &tr); if (tr.fStartSolid) { iResult += 1; } if (tr.fAllSolid) { iResult += 2; } if (!tr.fInOpen) { iResult += 4; } return iResult; }
// SetModelCollisionBox( index ); static cell AMX_NATIVE_CALL SetModelCollisionBox(AMX *amx, cell *params) { int entityIndex = params[1]; CHECK_ENTITY(entityIndex); edict_t *pentModel = INDEXENT2(entityIndex); if (!FNullEnt(pentModel)) { studiohdr_t *pStudiohdr = static_cast<studiohdr_t*>(GET_MODEL_PTR(pentModel)); if (!pStudiohdr) { MF_LogError(amx, AMX_ERR_NATIVE, "Could not find the model pointer for the entity."); return 0; } SET_SIZE(pentModel, pStudiohdr->bbmin, pStudiohdr->bbmax); return 1; } return 0; };
static cell AMX_NATIVE_CALL trace_normal(AMX *amx, cell *params) { int iEnt = params[1]; cell *cStart = MF_GetAmxAddr(amx, params[2]); cell *cEnd = MF_GetAmxAddr(amx, params[3]); REAL fStartX = amx_ctof(cStart[0]); REAL fStartY = amx_ctof(cStart[1]); REAL fStartZ = amx_ctof(cStart[2]); REAL fEndX = amx_ctof(cEnd[0]); REAL fEndY = amx_ctof(cEnd[1]); REAL fEndZ = amx_ctof(cEnd[2]); cell *vRet = MF_GetAmxAddr(amx, params[4]); Vector vStart = Vector(fStartX, fStartY, fStartZ); Vector vEnd = Vector(fEndX, fEndY, fEndZ); TraceResult tr; TRACE_LINE(vStart, vEnd, dont_ignore_monsters, INDEXENT2(iEnt), &tr); vRet[0] = amx_ftoc(tr.vecPlaneNormal.x); vRet[1] = amx_ftoc(tr.vecPlaneNormal.y); vRet[2] = amx_ftoc(tr.vecPlaneNormal.z); if (tr.flFraction >= 1.0) return 0; return 1; }
static cell AMX_NATIVE_CALL find_ent_by_model(AMX *amx, cell *params) { int iStart = params[1]; int iLength, iLength2; char *szClass = MF_GetAmxString(amx, params[2], 0, &iLength); char *szModel = MF_GetAmxString(amx, params[3], 1, &iLength2); edict_t *pStart; if (iStart == -1) { pStart = NULL; } else { if (!is_ent_valid(iStart)) pStart = NULL; else pStart = INDEXENT2(iStart); } edict_t *pEdict = FIND_ENTITY_BY_STRING(pStart, "classname", szClass); const char *check; while (pEdict && !FNullEnt(pEdict)) { check = STRING(pEdict->v.model); if (!check || strcmp(check, szModel)) pEdict = FIND_ENTITY_BY_STRING(pEdict, "classname", szClass); else return ENTINDEX(pEdict); } return 0; }
// GetModelCollisionBox( index, Float:mins[3], Float:maxs[3] ); static cell AMX_NATIVE_CALL GetModelCollisionBox(AMX *amx, cell *params) { int entityIndex = params[1]; CHECK_ENTITY(entityIndex); edict_t *pEdict = INDEXENT2(entityIndex); if (!FNullEnt(pEdict)) { studiohdr_t *pStudiohdr = static_cast<studiohdr_t*>(GET_MODEL_PTR(pEdict)); if (!pStudiohdr) { MF_LogError(amx, AMX_ERR_NATIVE, "Could not find the model pointer for the entity."); return 0; } cell *cmins = MF_GetAmxAddr(amx, params[2]); cell *cmaxs = MF_GetAmxAddr(amx, params[3]); cmins[0] = amx_ftoc(pStudiohdr->bbmin.x); cmins[1] = amx_ftoc(pStudiohdr->bbmin.y); cmins[2] = amx_ftoc(pStudiohdr->bbmin.z); cmaxs[0] = amx_ftoc(pStudiohdr->bbmax.x); cmaxs[1] = amx_ftoc(pStudiohdr->bbmax.y); cmaxs[2] = amx_ftoc(pStudiohdr->bbmax.z); return 1; } return 0; };
static cell AMX_NATIVE_CALL entity_set_string(AMX *amx, cell *params) { int iEnt = params[1]; int idx = params[2]; int iLen; int iszString = AmxStringToEngine(amx, params[3], iLen); CHECK_ENTITY_SIMPLE(iEnt); edict_t *pEnt = INDEXENT2(iEnt); switch (idx) { case classname: pEnt->v.classname = iszString; break; case globalname: pEnt->v.globalname = iszString; break; case model: pEnt->v.model = iszString; break; case target: pEnt->v.target = iszString; break; case targetname: pEnt->v.targetname = iszString; break; case netname: pEnt->v.netname = iszString; break; case message: pEnt->v.message = iszString; break; case noise: pEnt->v.noise = iszString; break; case noise1: pEnt->v.noise1 = iszString; break; case noise2: pEnt->v.noise2 = iszString; break; case noise3: pEnt->v.noise3 = iszString; break; case viewmodel: pEnt->v.viewmodel = iszString; break; case weaponmodel: pEnt->v.weaponmodel = iszString; break; default: return 0; break; } return 1; }
static cell AMX_NATIVE_CALL get_keyvalue(AMX *amx, cell *params) { int idx = params[1]; CHECK_ENTITY(idx); edict_t *pEntity = INDEXENT2(idx); int iLength=0; char *char1 = MF_GetAmxString(amx, params[2], 1, &iLength); return MF_SetAmxString(amx, params[3], INFO_KEY_VALUE(INFO_KEY_BUFFER(pEntity),char1), params[4]); }
//from jghg, who says it doesn't work // it works, it's just a picky engine call -sawce static cell AMX_NATIVE_CALL drop_to_floor(AMX *amx, cell *params) { int iEnt = params[1]; CHECK_ENTITY(iEnt); edict_t *e = INDEXENT2(iEnt); return DROP_TO_FLOOR(e); }
static cell AMX_NATIVE_CALL entity_get_edict(AMX *amx, cell *params) { int iEnt = params[1]; int idx = params[2]; edict_t *pRet; CHECK_ENTITY_SIMPLE(iEnt); edict_t *pEnt = INDEXENT2(iEnt); switch (idx) { case chain: pRet = pEnt->v.chain; break; case dmg_inflictor: pRet = pEnt->v.dmg_inflictor; break; case enemy: pRet = pEnt->v.enemy; break; case aiment: pRet = pEnt->v.aiment; break; case owner: pRet = pEnt->v.owner; break; case groundentity: pRet = pEnt->v.groundentity; break; case pContainingEntity: pRet = pEnt->v.pContainingEntity; break; case euser1: pRet = pEnt->v.euser1; break; case euser2: pRet = pEnt->v.euser2; break; case euser3: pRet = pEnt->v.euser3; break; case euser4: pRet = pEnt->v.euser4; break; default: return 0; break; } if (FNullEnt(pRet)) return 0; return ENTINDEX(pRet); }
// GetModelBoundingBox( index, Float:mins[3], Float:maxs[3], sequence = Model_DefaultSize ); static cell AMX_NATIVE_CALL GetModelBoundingBox(AMX *amx, cell *params) { int entityIndex = params[1]; CHECK_ENTITY(entityIndex); edict_t *pentModel = INDEXENT2(entityIndex); if (!FNullEnt(pentModel)) { studiohdr_t *pStudiohdr = static_cast<studiohdr_t*>(GET_MODEL_PTR(pentModel)); if (!pStudiohdr) { MF_LogError(amx, AMX_ERR_NATIVE, "Could not find the model pointer for the entity."); return 0; } cell *bbmins = MF_GetAmxAddr(amx, params[2]); cell *bbmaxs = MF_GetAmxAddr(amx, params[3]); int sequence = params[4]; if (sequence <= Model_DefaultSize) { bbmins[0] = amx_ftoc(pStudiohdr->min.x); bbmins[1] = amx_ftoc(pStudiohdr->min.y); bbmins[2] = amx_ftoc(pStudiohdr->min.z); bbmaxs[0] = amx_ftoc(pStudiohdr->max.x); bbmaxs[1] = amx_ftoc(pStudiohdr->max.y); bbmaxs[2] = amx_ftoc(pStudiohdr->max.z); } else { if (sequence <= Model_CurrentSequence || sequence >= pStudiohdr->numseq) sequence = pentModel->v.sequence; mstudioseqdesc_t *pSeqdesc; pSeqdesc = (mstudioseqdesc_t*)((byte*)pStudiohdr + pStudiohdr->seqindex); bbmins[0] = amx_ftoc(pSeqdesc[sequence].bbmin.x); bbmins[1] = amx_ftoc(pSeqdesc[sequence].bbmin.y); bbmins[2] = amx_ftoc(pSeqdesc[sequence].bbmin.z); bbmaxs[0] = amx_ftoc(pSeqdesc[sequence].bbmax.x); bbmaxs[1] = amx_ftoc(pSeqdesc[sequence].bbmax.y); bbmaxs[2] = amx_ftoc(pSeqdesc[sequence].bbmax.z); } return 1; } return 0; };
static cell AMX_NATIVE_CALL find_sphere_class(AMX *amx, cell *params) // find_sphere_class(aroundent, _lookforclassname[], Float:radius, entlist[], maxents, Float:origin[3] = {0.0, 0.0, 0.0}); // 6 params { // params[1] = index to find around, if this is less than 1 then use around origin in last parameter. // params[2] = classname to find int len; char* classToFind = MF_GetAmxString(amx, params[2], 0, &len); // params[3] = radius, float... REAL radius =amx_ctof(params[3]); // params[4] = store ents in this list cell *entList = MF_GetAmxAddr(amx, params[4]); // params[5] = maximum ents to store in entlist[] in params[4] // params[6] = origin, use this if params[1] is less than 1 vec3_t vecOrigin; if (params[1] > 0) { CHECK_ENTITY(params[1]); edict_t* pEntity = INDEXENT2(params[1]); vecOrigin = pEntity->v.origin; } else { cell *cAddr = MF_GetAmxAddr(amx, params[6]); vecOrigin = Vector(amx_ctof(cAddr[0]), amx_ctof(cAddr[1]), amx_ctof(cAddr[2])); } int entsFound = 0; edict_t* pSearchEnt = INDEXENT2(0); while (entsFound < params[5]) { pSearchEnt = FIND_ENTITY_IN_SPHERE(pSearchEnt, vecOrigin, radius); // takes const float origin if (FNullEnt(pSearchEnt)) break; else { if (strcmp(STRING(pSearchEnt->v.classname), classToFind) == 0) { // Add to entlist (params[4]) entList[entsFound++] = ENTINDEX(pSearchEnt); // raise entsFound } } } return entsFound; }
static cell AMX_NATIVE_CALL DispatchSpawn(AMX *amx, cell *params) { int iEnt = params[1]; CHECK_ENTITY(iEnt); edict_t *pEnt = INDEXENT2(iEnt); MDLL_Spawn(pEnt); return 1; }
static cell AMX_NATIVE_CALL call_think(AMX *amx, cell *params) { int iEnt = params[1]; CHECK_ENTITY(iEnt); edict_t *pEnt = INDEXENT2(iEnt); MDLL_Think(pEnt); return 1; }
static cell AMX_NATIVE_CALL get_info_keybuffer(AMX *amx, cell *params) { int iEnt = params[1]; CHECK_ENTITY(iEnt); edict_t *e = INDEXENT2(iEnt); char *info = GETINFOKEYBUFFER(e); return MF_SetAmxString(amx, params[2], info, params[3]); }
static cell AMX_NATIVE_CALL remove_entity(AMX *amx, cell *params) { int id = params[1]; edict_t *pEnt = INDEXENT2(id); if (FNullEnt(pEnt)) return 0; REMOVE_ENTITY(pEnt); return 1; }
//uses mahnsawce's version now static cell AMX_NATIVE_CALL DispatchKeyValue(AMX *amx, cell *params) { int count = *params / sizeof(cell); if (count == 3) { cell *cVal = MF_GetAmxAddr(amx, params[1]); int iValue = *cVal; if (iValue != 0 && (FNullEnt(INDEXENT2(iValue)) || iValue < 0 || iValue > gpGlobals->maxEntities)) { MF_LogError(amx, AMX_ERR_NATIVE, "Invalid entity %d", iValue); return 0; } edict_t *pEntity = INDEXENT2(iValue); KeyValueData kvd; int iLength=0; char *char1 = MF_GetAmxString(amx, params[2], 0, &iLength); char *char2 = MF_GetAmxString(amx, params[3], 1, &iLength); kvd.szClassName = (char*)STRING(pEntity->v.classname); kvd.szKeyName = char1; kvd.szValue = char2; kvd.fHandled = 0; MDLL_KeyValue(pEntity, &kvd); } else { int iLength; char *char1 = MF_GetAmxString(amx, params[1], 0, &iLength); char *char2 = MF_GetAmxString(amx, params[2], 1, &iLength); const char *charA = STRING(ALLOC_STRING(char1)); const char *charB = STRING(ALLOC_STRING(char2)); g_pkvd->szKeyName = const_cast<char *>(charA); g_pkvd->szValue = const_cast<char *>(charB); } return 1; }
static cell AMX_NATIVE_CALL find_ent_by_class(AMX *amx, cell *params) /* 3 param */ { edict_t *pEnt = INDEXENT2(params[1]); int len; char* sValue = MF_GetAmxString(amx, params[2], 0, &len); pEnt = FIND_ENTITY_BY_STRING(pEnt, "classname", sValue); if (FNullEnt(pEnt)) return 0; return ENTINDEX(pEnt); }
static cell AMX_NATIVE_CALL get_grenade_id(AMX *amx, cell *params) /* 4 param */ { int index = params[1]; const char *szModel; CHECK_ENTITY(index); edict_t* pentFind = INDEXENT2(params[4]); edict_t* pentOwner = INDEXENT2(index); pentFind = FIND_ENTITY_BY_CLASSNAME( pentFind, "grenade" ); while (!FNullEnt(pentFind)) { if (pentFind->v.owner == pentOwner) { if (params[3]>0) { szModel = (char*)STRING(pentFind->v.model); MF_SetAmxString(amx, params[2], szModel, params[3]); return ENTINDEX(pentFind); } } pentFind = FIND_ENTITY_BY_CLASSNAME( pentFind, "grenade" ); } return 0; }
static cell AMX_NATIVE_CALL entity_intersects(AMX *amx, cell *params) // bool:entity_intersects(entity, other); = 2 arguments { // params[1] = entity // params[2] = other CHECK_ENTITY_SIMPLE(params[1]); CHECK_ENTITY_SIMPLE(params[2]); entvars_s *pevEntity = VARS(INDEXENT2(params[1])); entvars_s *pevOther = VARS(INDEXENT2(params[2])); if (pevOther->absmin.x > pevEntity->absmax.x || pevOther->absmin.y > pevEntity->absmax.y || pevOther->absmin.z > pevEntity->absmax.z || pevOther->absmax.x < pevEntity->absmin.x || pevOther->absmax.y < pevEntity->absmin.y || pevOther->absmax.z < pevEntity->absmin.z) { return 1; } return 0; }
static cell AMX_NATIVE_CALL entity_set_model(AMX *amx, cell *params) { int iEnt = params[1]; CHECK_ENTITY_SIMPLE(iEnt); edict_t *pEnt = INDEXENT2(iEnt); int iLen; char *szModel = MF_GetAmxString(amx, params[2], 0, &iLen); const char *szStatic = STRING(ALLOC_STRING(szModel)); SET_MODEL(pEnt, szStatic); return 1; }
static cell AMX_NATIVE_CALL entity_set_origin(AMX *amx, cell *params) { int iEnt = params[1]; CHECK_ENTITY_SIMPLE(iEnt); edict_t *pEnt = INDEXENT2(iEnt); cell *vVector = MF_GetAmxAddr(amx, params[2]); REAL fX = amx_ctof(vVector[0]); REAL fY = amx_ctof(vVector[1]); REAL fZ = amx_ctof(vVector[2]); Vector vOrigin = Vector(fX, fY, fZ); SET_SIZE(pEnt, pEnt->v.mins, pEnt->v.maxs); SET_ORIGIN(pEnt, vOrigin); return 1; }
static cell AMX_NATIVE_CALL entity_set_byte(AMX *amx, cell *params) { int iEnt = params[1]; int idx = params[2]; int iNewValue = params[3]; CHECK_ENTITY_SIMPLE(iEnt); if(iNewValue > 255) iNewValue = 255; if(iNewValue < 0) iNewValue = 0; edict_t *pEnt = INDEXENT2(iEnt); switch (idx) { case controller1: pEnt->v.controller[0] = iNewValue; break; case controller2: pEnt->v.controller[1] = iNewValue; break; case controller3: pEnt->v.controller[2] = iNewValue; break; case controller4: pEnt->v.controller[3] = iNewValue; break; case blending1: pEnt->v.blending[0] = iNewValue; break; case blending2: pEnt->v.blending[1] = iNewValue; break; default: return 0; break; } return 1; }
static cell AMX_NATIVE_CALL find_ent_by_tname(AMX *amx, cell *params) { int iStart = params[1]; int iLength; char *szValue = MF_GetAmxString(amx, params[2], 0, &iLength); edict_t *pStart; if (iStart == -1) { pStart = NULL; } else { if (!is_ent_valid(iStart)) pStart = NULL; else pStart = INDEXENT2(iStart); } int iReturnEnt = ENTINDEX(FIND_ENTITY_BY_TARGETNAME(pStart, szValue)); return iReturnEnt; }