568 lines
17 KiB
C++
568 lines
17 KiB
C++
/* AMX Mod X
|
|
* Sven Co-op Module
|
|
*
|
|
* by the AMX Mod X Development Team
|
|
*
|
|
* This file is part of AMX Mod X.
|
|
*
|
|
*
|
|
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
* In addition, as a special exception, the author gives permission to
|
|
* link the code of this program with the Half-Life Game Engine ("HL
|
|
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
|
|
* L.L.C ("Valve"). You must obey the GNU General Public License in all
|
|
* respects for all of the code used other than the HL Engine and MODs
|
|
* from Valve. If you modify this file, you may extend this exception
|
|
* to your version of the file, but you are not obligated to do so. If
|
|
* you do not wish to do so, delete this exception statement from your
|
|
* version.
|
|
*/
|
|
|
|
#include "svencoop.h"
|
|
|
|
//
|
|
// GLOBALS
|
|
//
|
|
|
|
const char g_weapon_names[24][24] =
|
|
{
|
|
"",
|
|
"weapon_crowbar",
|
|
"weapon_9mmhandgun",
|
|
"weapon_357",
|
|
"weapon_9mmAR",
|
|
"",
|
|
"weapon_crossbow",
|
|
"weapon_shotgun",
|
|
"weapon_rpg",
|
|
"weapon_gauss",
|
|
"weapon_egon",
|
|
"weapon_hornetgun",
|
|
"weapon_handgrenade",
|
|
"weapon_tripmine",
|
|
"weapon_satchel",
|
|
"weapon_snark",
|
|
"weapon_uziakimbo",
|
|
"weapon_uzi",
|
|
"weapon_medkit",
|
|
"weapon_crowbar_electric",
|
|
"weapon_pipewrench",
|
|
"weapon_minigun",
|
|
"weapon_grapple",
|
|
"weapon_sniperrifle"
|
|
};
|
|
|
|
const int g_ammo_offsets[25] =
|
|
{
|
|
-1, // NONE = 0
|
|
0, // SCW_CROWBAR = 1
|
|
OFFSET_9MM_AMMO, // SCW_9MMHANDGUN = 2
|
|
OFFSET_357_AMMO, // SCW_357 = 3
|
|
OFFSET_9MM_AMMO, // SCW_9MMAR = 4
|
|
-1, // NONE = 5
|
|
OFFSET_CROSSBOW_AMMO, // SCW_CROSSBOW = 6
|
|
OFFSET_SHOTGUN_AMMO, // SCW_SHOTGUN = 7
|
|
OFFSET_RPG_AMMO, // SCW_RPG = 8
|
|
OFFSET_ENERGY_AMMO, // SCW_GAUSS = 9
|
|
OFFSET_ENERGY_AMMO, // SCW_EGON = 10
|
|
OFFSET_HORNETGUN_AMMO, // SCW_HORNETGUN = 11
|
|
OFFSET_HANDGRENADE_AMMO,// SCW_HANDGRENADE = 12
|
|
OFFSET_TRIPMINE_AMMO, // SCW_TRIPMINE = 13
|
|
OFFSET_SATCHEL_AMMO, // SCW_SATCHEL = 14
|
|
OFFSET_SNARK_AMMO, // SCW_SNARK = 15
|
|
OFFSET_9MM_AMMO, // SCW_UZIAKIMBO = 16
|
|
OFFSET_9MM_AMMO, // SCW_UZI = 17
|
|
OFFSET_MEDKIT_AMMO, // SCW_MEDKIT = 18
|
|
0, // SCW_CROWBAR_ELECTRIC = 19
|
|
0, // SCW_PIPEWRENCH = 20
|
|
OFFSET_MINIGUN_AMMO, // SCW_MINIGUN = 21
|
|
0, // SCW_GRAPPLE = 22
|
|
OFFSET_SNIPERRIFLE_AMMO,// SCW_SNIPERRIFLE = 23
|
|
OFFSET_ARGRENADE_AMMO // SCW_ARGRENADE = 24
|
|
};
|
|
|
|
//
|
|
// MONSTER NATIVES
|
|
//
|
|
|
|
static cell AMX_NATIVE_CALL sc_get_frags(AMX *amx, cell *params) // sc_get_frags(index); = 1 arguments
|
|
{
|
|
// Gets a monster's or player's frags
|
|
// params[1] = monster/player index
|
|
|
|
// not CHECK_MONSTER because this works for players
|
|
CHECK_ENTITY(params[1]);
|
|
edict_t *pEdict = GETEDICT(params[1]);
|
|
|
|
if(!UTIL_IsPlayer(pEdict) && !UTIL_IsMonster(pEdict))
|
|
{
|
|
MF_LogError(amx, AMX_ERR_NATIVE, "Entity %d (\"%s\") is not a player or monster_* entity", params[1], STRING(pEdict->v.classname));
|
|
return 0;
|
|
}
|
|
|
|
return amx_ftoc(*((float *)pEdict->pvPrivateData + OFFSET_MONSTER_FRAGS));
|
|
}
|
|
|
|
static cell AMX_NATIVE_CALL sc_set_frags(AMX *amx, cell *params) // sc_set_frags(index, Float:value); = 2 arguments
|
|
{
|
|
// Sets a monster's or player's frags
|
|
// params[1] = index = monster/player index
|
|
// params[2] = (float) new frags
|
|
|
|
// not CHECK_MONSTER because this works for players
|
|
CHECK_ENTITY(params[1]);
|
|
edict_t *pEdict = GETEDICT(params[1]);
|
|
|
|
if(!UTIL_IsPlayer(pEdict) && !UTIL_IsMonster(pEdict))
|
|
{
|
|
MF_LogError(amx, AMX_ERR_NATIVE, "Entity %d (\"%s\") is not a player or monster_* entity", params[1], STRING(pEdict->v.classname));
|
|
return 0;
|
|
}
|
|
|
|
float fValue = amx_ctof(params[2]);
|
|
*((float *)pEdict->pvPrivateData + OFFSET_MONSTER_FRAGS) = fValue;
|
|
|
|
if(UTIL_IsPlayer(pEdict))
|
|
{
|
|
pEdict->v.frags = fValue;
|
|
|
|
// update scoreboard
|
|
if(gmsgScoreInfo)
|
|
{
|
|
MESSAGE_BEGIN(MSG_ALL, gmsgScoreInfo);
|
|
WRITE_BYTE(params[1]);
|
|
WRITE_SHORT((int)fValue);
|
|
WRITE_SHORT(*((int *)pEdict->pvPrivateData + OFFSET_PLAYER_DEATHS));
|
|
MESSAGE_END();
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static cell AMX_NATIVE_CALL sc_get_displayname(AMX *amx, cell *params) // sc_get_displayname(index, displayname[], len); = 3 arguments
|
|
{
|
|
// Gets a monster's displayname
|
|
// params[1] = monster index
|
|
// params[2] = return variable
|
|
// params[3] = variable len
|
|
|
|
// check non-player (could be squadmaker)
|
|
CHECK_NONPLAYER(params[1]);
|
|
edict_t *pEdict = INDEXENT(params[1]);
|
|
|
|
// check valid types
|
|
const char *classname = STRING(pEdict->v.classname);
|
|
if(strcmp(classname, "squadmaker") != 0 && strncmp(classname, "monster", 7) != 0)
|
|
{
|
|
MF_LogError(amx, AMX_ERR_NATIVE, "Entity %d (\"%s\") is not a monstermaker, squadmaker, or monster_* entity", params[1], classname);
|
|
return 0;
|
|
}
|
|
|
|
// check for a custom one
|
|
const char *displayname = STRING(pEdict->v.message);
|
|
if(displayname[0])
|
|
{
|
|
MF_SetAmxString(amx, params[2], displayname, params[3]);
|
|
return 1; // 1 means custom displayname
|
|
}
|
|
|
|
// maybe from a monstermaker? use its displayname.
|
|
if(!strncmp(classname, "monster_", 8) && !FNullEnt(pEdict->v.owner))
|
|
{
|
|
const char *ownerclass = STRING(pEdict->v.owner->v.classname);
|
|
if(!strcmp(ownerclass, "squadmaker") || !strcmp(ownerclass, "monstermaker"))
|
|
{
|
|
displayname = STRING(pEdict->v.owner->v.message);
|
|
if(displayname[0])
|
|
{
|
|
return MF_SetAmxString(amx, params[2], displayname, params[3]);
|
|
return 1; // 1 means custom displayname
|
|
}
|
|
}
|
|
}
|
|
|
|
String *name = NULL;
|
|
|
|
if(*((int *)pEdict->pvPrivateData + OFFSET_MONSTER_ALLY))
|
|
name = g_allyNameTrie.Retrieve(classname, strlen(classname));
|
|
else
|
|
name = g_enemyNameTrie.Retrieve(classname, strlen(classname));
|
|
|
|
if(name != NULL)
|
|
{
|
|
MF_SetAmxString(amx, params[2], name->c_str(), params[3]);
|
|
return -1; // -1 means default displayname
|
|
}
|
|
|
|
return 0; // invalid monster
|
|
}
|
|
|
|
static cell AMX_NATIVE_CALL sc_set_displayname(AMX *amx, cell *params) // sc_set_displayname(index, displayname[], {Float,Sql,Result,_}:...); = 2 arguments
|
|
{
|
|
// Sets a monster's displayname
|
|
// params[1] = monster index
|
|
// params[2] = new displayname
|
|
// params[3...] = formatting
|
|
|
|
// check non-player (could be squadmaker)
|
|
CHECK_NONPLAYER(params[1]);
|
|
edict_t *pEdict = INDEXENT(params[1]);
|
|
|
|
// check valid types
|
|
const char *classname = STRING(pEdict->v.classname);
|
|
if(strcmp(classname, "squadmaker") != 0 && strncmp(classname, "monster", 7) != 0)
|
|
{
|
|
MF_LogError(amx, AMX_ERR_NATIVE, "Entity %d (\"%s\") is not a monstermaker, squadmaker, or monster_* entity", params[1], classname);
|
|
return 0;
|
|
}
|
|
|
|
// fetch string
|
|
int len = 0;
|
|
char *displayname = MF_FormatAmxString(amx, params, 2, &len);
|
|
|
|
// set_kvd
|
|
KeyValueData *kvd = &g_kvd;
|
|
kvd->szClassName = const_cast<char *>(classname);
|
|
kvd->szKeyName = const_cast<char *>("displayname");
|
|
kvd->szValue = const_cast<char *>(displayname);
|
|
kvd->fHandled = 0;
|
|
gpGamedllFuncs->dllapi_table->pfnKeyValue(pEdict, kvd);
|
|
|
|
// remember it
|
|
pEdict->v.message = ALLOC_STRING(displayname);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static cell AMX_NATIVE_CALL sc_is_player_ally(AMX *amx, cell *params) // sc_is_player_ally(index); = 1 arguments
|
|
{
|
|
// Checks if a monster is a player ally
|
|
// params[1] = monster index
|
|
|
|
CHECK_MONSTER(params[1]);
|
|
edict_t *pEdict = INDEXENT(params[1]);
|
|
|
|
return *((int *)pEdict->pvPrivateData + OFFSET_MONSTER_ALLY);
|
|
}
|
|
|
|
//
|
|
// PLAYER NATIVES
|
|
// (ammo excluded)
|
|
//
|
|
|
|
static cell AMX_NATIVE_CALL sc_get_user_longjump(AMX *amx, cell *params) // sc_get_user_longjump(index); = 1 arguments
|
|
{
|
|
// Checks if a player can longjump
|
|
// params[1] = player index
|
|
|
|
CHECK_PLAYER(params[1]);
|
|
edict_t *pEdict = MF_GetPlayerEdict(params[1]);
|
|
|
|
const char *buffer = (*g_engfuncs.pfnGetPhysicsKeyValue)(pEdict, "slj");
|
|
if(buffer[0] == '1') return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static cell AMX_NATIVE_CALL sc_set_user_longjump(AMX *amx, cell *params) // sc_set_user_longjump(index, value); = 2 arguments
|
|
{
|
|
// Sets if a player can longjump
|
|
// params[1] = player index
|
|
// params[2] = new value
|
|
|
|
CHECK_PLAYER(params[1]);
|
|
edict_t *pEdict = MF_GetPlayerEdict(params[1]);
|
|
|
|
if(params[2]) (*g_engfuncs.pfnSetPhysicsKeyValue)(pEdict, "slj", "1");
|
|
else (*g_engfuncs.pfnSetPhysicsKeyValue)(pEdict, "slj", "0");
|
|
|
|
return 1;
|
|
}
|
|
|
|
static cell AMX_NATIVE_CALL sc_get_user_deaths(AMX *amx, cell *params) // sc_get_user_deaths(index); = 1 arguments
|
|
{
|
|
// Gets the number of times a player has died (duh!)
|
|
// params[1] = player index
|
|
|
|
CHECK_PLAYER(params[1]);
|
|
edict_t *pEdict = MF_GetPlayerEdict(params[1]);
|
|
|
|
return *((int *)pEdict->pvPrivateData + OFFSET_PLAYER_DEATHS);
|
|
}
|
|
|
|
static cell AMX_NATIVE_CALL sc_set_user_deaths(AMX *amx, cell *params) // sc_set_user_deaths(index, value); = 2 arguments
|
|
{
|
|
// Sets the number of times a player has died
|
|
// params[1] = player index
|
|
// params[2] = new death amount
|
|
|
|
CHECK_PLAYER(params[1]);
|
|
edict_t *pEdict = MF_GetPlayerEdict(params[1]);
|
|
|
|
*((int *)pEdict->pvPrivateData + OFFSET_PLAYER_DEATHS) = params[2];
|
|
|
|
// update scoreboard
|
|
if(gmsgScoreInfo)
|
|
{
|
|
MESSAGE_BEGIN(MSG_ALL, gmsgScoreInfo);
|
|
WRITE_BYTE(params[1]);
|
|
WRITE_SHORT((int)pEdict->v.frags);
|
|
WRITE_SHORT(params[2]);
|
|
MESSAGE_END();
|
|
}
|
|
|
|
*static_cast<int *>(MF_PlayerPropAddr(params[1], Player_Deaths)) = params[2];
|
|
|
|
return 1;
|
|
}
|
|
|
|
//
|
|
// AMMO NATIVES
|
|
//
|
|
|
|
static cell AMX_NATIVE_CALL sc_get_wbox_ammo(AMX *amx, cell *params) // sc_get_wbox_ammo(index); = 1 arguments
|
|
{
|
|
// Gets the amount of ammo in dropped ammo weaponbox
|
|
// params[1] = weaponbox entity index
|
|
|
|
CHECK_NONPLAYER(params[1]);
|
|
edict_t *pEdict = INDEXENT(params[1]);
|
|
|
|
if(strcmp(STRING(pEdict->v.classname), "weaponbox") != 0)
|
|
{
|
|
MF_LogError(amx, AMX_ERR_NATIVE, "Entity %d (\"%s\") is not a weaponbox entity", params[1], STRING(pEdict->v.classname));
|
|
return 0;
|
|
}
|
|
|
|
return *((int *)pEdict->pvPrivateData + OFFSET_WBOX_AMMO);
|
|
}
|
|
|
|
static cell AMX_NATIVE_CALL sc_set_wbox_ammo(AMX *amx, cell *params) // sc_set_wbox_ammo(index, value); = 1 arguments
|
|
{
|
|
// Sets the amount of ammo in dropped ammo weaponbox
|
|
// params[1] = weaponbox entity index
|
|
// params[2] = new ammo amount
|
|
|
|
CHECK_NONPLAYER(params[1]);
|
|
edict_t *pEdict = INDEXENT(params[1]);
|
|
|
|
if(strcmp(STRING(pEdict->v.classname), "weaponbox") != 0)
|
|
{
|
|
MF_LogError(amx, AMX_ERR_NATIVE, "Entity %d (\"%s\") is not a weaponbox entity", params[1], STRING(pEdict->v.classname));
|
|
return 0;
|
|
}
|
|
|
|
*((int *)pEdict->pvPrivateData + OFFSET_WBOX_AMMO) = params[2];
|
|
|
|
return 1;
|
|
}
|
|
|
|
static cell AMX_NATIVE_CALL sc_get_weapon_id(AMX *amx, cell *params) // sc_get_weapon_id(index); = 1 arguments
|
|
{
|
|
// Gets the SCW_* constant of a weapon_* entity
|
|
// params[1] = weapon_* entity index
|
|
|
|
CHECK_NONPLAYER(params[1]);
|
|
edict_t *pEdict = INDEXENT(params[1]);
|
|
|
|
// not a valid weapon_*
|
|
if(strncmp(STRING(pEdict->v.classname), "weapon_", 7) != 0)
|
|
{
|
|
MF_LogError(amx, AMX_ERR_NATIVE, "Entity %d (\"%s\") is not a weapon_* entity", params[1], STRING(pEdict->v.classname));
|
|
return 0;
|
|
}
|
|
|
|
return *((int *)pEdict->pvPrivateData + OFFSET_WEAPON_TYPE);
|
|
}
|
|
|
|
static cell AMX_NATIVE_CALL sc_get_weapon_ammo(AMX *amx, cell *params) // sc_get_weapon_ammo(index1, index2=0); = 2 arguments
|
|
{
|
|
// Gets the amount of ammo in weapon's clip
|
|
// params[1] = weapon_* entity index OR player index
|
|
// params[2] = (optional) SCW_* constant if using player index
|
|
|
|
CHECK_ENTITY(params[1]);
|
|
edict_t *pEdict = GETEDICT(params[1]);
|
|
|
|
// sc_get_weapon_ammo(id, SCW_9MMAR);
|
|
if(params[2])
|
|
{
|
|
if(params[2] < 1 || params[2] > 23 || params[2] == 5)
|
|
{
|
|
MF_LogError(amx, AMX_ERR_NATIVE, "Invalid weapon index %d", params[2]);
|
|
return 0;
|
|
}
|
|
|
|
CHECK_PLAYER(params[1]);
|
|
edict_t *pWeapon = NULL;
|
|
|
|
const char *weaponname = g_weapon_names[params[2]];
|
|
|
|
while(true)
|
|
{
|
|
pWeapon = FIND_ENTITY_BY_STRING(pWeapon, "classname", weaponname);
|
|
if(FNullEnt(pWeapon) || pWeapon->v.owner == pEdict) break;
|
|
}
|
|
|
|
if(FNullEnt(pWeapon))
|
|
{
|
|
MF_LogError(amx, AMX_ERR_NATIVE, "Player %d does not have a \"%s\" (index %d)", params[1], weaponname, params[2]);
|
|
return 0;
|
|
}
|
|
|
|
return *((int *)pWeapon->pvPrivateData + OFFSET_WEAPON_CLIP);
|
|
}
|
|
|
|
if(strncmp(STRING(pEdict->v.classname), "weapon_", 7) != 0)
|
|
{
|
|
MF_LogError(amx, AMX_ERR_NATIVE, "Entity %d (\"%s\") is not a weapon_* entity", params[1], STRING(pEdict->v.classname));
|
|
return 0;
|
|
}
|
|
|
|
return *((int *)pEdict->pvPrivateData + OFFSET_WEAPON_CLIP);
|
|
}
|
|
|
|
static cell AMX_NATIVE_CALL sc_set_weapon_ammo(AMX *amx, cell *params) // sc_set_weapon_ammo(index1, value, index2=0); = 3 arguments
|
|
{
|
|
// Sets the amount of ammo in weapon's clip
|
|
// params[1] = weapon_* entity index OR player index
|
|
// params[2] = new clip ammo
|
|
// params[3] = (optional) SCW_* constant if using player index
|
|
|
|
CHECK_ENTITY(params[1]);
|
|
edict_t *pEdict = GETEDICT(params[1]);
|
|
|
|
// sc_set_weapon_ammo(id, SCW_9MMAR, 50);
|
|
if(params[3])
|
|
{
|
|
if(params[3] < 1 || params[3] > 23 || params[3] == 5)
|
|
{
|
|
MF_LogError(amx, AMX_ERR_NATIVE, "Invalid weapon index %d", params[3]);
|
|
return 0;
|
|
}
|
|
|
|
CHECK_PLAYER(params[1]);
|
|
edict_t *pWeapon = NULL;
|
|
|
|
const char *weaponname = g_weapon_names[params[3]];
|
|
|
|
while(true)
|
|
{
|
|
pWeapon = FIND_ENTITY_BY_STRING(pWeapon, "classname", weaponname);
|
|
if(FNullEnt(pWeapon) || pWeapon->v.owner == pEdict) break;
|
|
}
|
|
|
|
if(FNullEnt(pWeapon))
|
|
{
|
|
MF_LogError(amx, AMX_ERR_NATIVE, "Player %d does not have a \"%s\" (index %d)", params[1], weaponname, params[3]);
|
|
return 0;
|
|
}
|
|
|
|
*((int *)pWeapon->pvPrivateData + OFFSET_WEAPON_CLIP) = params[2];
|
|
|
|
return 1;
|
|
}
|
|
|
|
if(strncmp(STRING(pEdict->v.classname), "weapon_", 7) != 0)
|
|
{
|
|
MF_LogError(amx, AMX_ERR_NATIVE, "Entity %d (\"%s\") is not a weapon_* entity", params[1], STRING(pEdict->v.classname));
|
|
return 0;
|
|
}
|
|
|
|
*((int *)pEdict->pvPrivateData + OFFSET_WEAPON_CLIP) = params[2];
|
|
|
|
return 1;
|
|
}
|
|
|
|
static cell AMX_NATIVE_CALL sc_get_user_bpammo(AMX *amx, cell *params) // sc_get_user_bpammo(index, weapon); = 2 arguments
|
|
{
|
|
// Gets the amount of ammo in player's backpack for a specific weapon
|
|
// params[1] = player index
|
|
// params[2] = SCW_* constant
|
|
|
|
CHECK_PLAYER(params[1]);
|
|
edict_t *pEdict = MF_GetPlayerEdict(params[1]);
|
|
|
|
if(params[2] < 1 || params[2] > 23 || params[2] == 5)
|
|
{
|
|
MF_LogError(amx, AMX_ERR_NATIVE, "Invalid weapon index %d", params[2]);
|
|
return 0;
|
|
}
|
|
|
|
// invalid weapon or no bpammo
|
|
if(g_ammo_offsets[params[2]] <= 0)
|
|
return 0;
|
|
|
|
return *((int *)pEdict->pvPrivateData + g_ammo_offsets[params[2]]);
|
|
}
|
|
|
|
static cell AMX_NATIVE_CALL sc_set_user_bpammo(AMX *amx, cell *params) // sc_set_user_bpammo(index, weapon, value); = 3 arguments
|
|
{
|
|
// Gets the amount of ammo in player's backpack for a specific weapon
|
|
// params[1] = player index
|
|
// params[2] = SCW_* constant
|
|
// params[3] = new backpack ammo
|
|
|
|
CHECK_PLAYER(params[1]);
|
|
edict_t *pEdict = MF_GetPlayerEdict(params[1]);
|
|
|
|
if(params[2] < 1 || params[2] > 23 || params[2] == 5)
|
|
{
|
|
MF_LogError(amx, AMX_ERR_NATIVE, "Invalid weapon index %d", params[2]);
|
|
return 0;
|
|
}
|
|
|
|
// invalid weapon or no bpammo
|
|
if(g_ammo_offsets[params[2]] <= 0)
|
|
return 0;
|
|
|
|
*((int *)pEdict->pvPrivateData + g_ammo_offsets[params[2]]) = params[3];
|
|
|
|
return 1;
|
|
}
|
|
|
|
//
|
|
// EXPORT LIST
|
|
//
|
|
|
|
AMX_NATIVE_INFO svencoop_Exports[] =
|
|
{
|
|
// monster natives
|
|
{"sc_get_frags", sc_get_frags},
|
|
{"sc_set_frags", sc_set_frags},
|
|
{"sc_get_displayname", sc_get_displayname},
|
|
{"sc_set_displayname", sc_set_displayname},
|
|
{"sc_is_player_ally", sc_is_player_ally},
|
|
|
|
// player natives
|
|
{"sc_get_user_longjump", sc_get_user_longjump},
|
|
{"sc_set_user_longjump", sc_set_user_longjump},
|
|
{"sc_get_user_deaths", sc_get_user_deaths},
|
|
{"sc_set_user_deaths", sc_set_user_deaths},
|
|
|
|
// ammo natives
|
|
{"sc_get_wbox_ammo", sc_get_wbox_ammo},
|
|
{"sc_set_wbox_ammo", sc_set_wbox_ammo},
|
|
{"sc_get_weapon_id", sc_get_weapon_id},
|
|
{"sc_get_weapon_ammo", sc_get_weapon_ammo},
|
|
{"sc_set_weapon_ammo", sc_set_weapon_ammo},
|
|
{"sc_get_user_bpammo", sc_get_user_bpammo},
|
|
{"sc_set_user_bpammo", sc_set_user_bpammo},
|
|
//------------------- <-- max 19 characters?? bleh!
|
|
{NULL, NULL}
|
|
};
|