mirror of
https://github.com/UberGames/RPG-X2.git
synced 2024-11-16 01:41:34 +00:00
1993 lines
36 KiB
C
1993 lines
36 KiB
C
// entity lib for lua
|
|
|
|
#include "g_lua.h"
|
|
#include "g_spawn.h"
|
|
|
|
#ifdef G_LUA
|
|
// entity.GetTarget(entity ent)
|
|
// returns a target entity of ent
|
|
static int Entity_GetTarget(lua_State * L)
|
|
{
|
|
lent_t *lent;
|
|
lent_t *target;
|
|
gentity_t *t = NULL;
|
|
|
|
target = lua_newuserdata(L, sizeof(lent_t));
|
|
luaL_getmetatable(L, "game.entity");
|
|
lua_setmetatable(L, -2);
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
|
|
|
|
if(!lent->e)
|
|
{
|
|
Com_Printf("Entity_Target - invalid entity!\n");
|
|
return 0;
|
|
}
|
|
if(!lent->e->target)
|
|
{
|
|
Com_Printf("Entity_Target - no target!\n");
|
|
return 0;
|
|
}
|
|
|
|
t = G_PickTarget(lent->e->target);
|
|
if(!t)
|
|
{
|
|
G_Printf("Entity_Target - Couldn't find target %s\n", lent->e->target);
|
|
return 0;
|
|
}
|
|
|
|
target->e = t;
|
|
|
|
return 1;
|
|
}
|
|
|
|
// entity.FindBModel(int bmodel)
|
|
// finds entity by brush model
|
|
static int Entity_FindBModel(lua_State *L) {
|
|
lent_t *lent;
|
|
int bmodel;
|
|
|
|
lent = lua_newuserdata(L, sizeof(lent_t));
|
|
|
|
luaL_getmetatable(L, "game.entity");
|
|
lua_setmetatable(L, -2);
|
|
|
|
bmodel = luaL_checkint(L, 1);
|
|
|
|
lent->e = G_Find(NULL, FOFS(model), va("*%i", bmodel));
|
|
if(lent->e)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
// entity.FindNumber(int num)
|
|
// finds entity by number
|
|
static int Entity_FindNumber(lua_State * L)
|
|
{
|
|
lent_t *lent;
|
|
int entnum;
|
|
gentity_t *ent;
|
|
|
|
lent = lua_newuserdata(L, sizeof(lent_t));
|
|
|
|
luaL_getmetatable(L, "game.entity");
|
|
lua_setmetatable(L, -2);
|
|
|
|
entnum = luaL_checknumber(L, 1);
|
|
|
|
lent->e = NULL;
|
|
|
|
ent = &g_entities[entnum];
|
|
if(ent)
|
|
{
|
|
if(ent->inuse)
|
|
{
|
|
lent->e = ent;
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// entity.Find(string targetname)
|
|
// finds and returns an entity by it's targetname
|
|
static int Entity_Find(lua_State * L)
|
|
{
|
|
char *s;
|
|
lent_t *lent;
|
|
int i;
|
|
gentity_t *t;
|
|
|
|
lent = lua_newuserdata(L, sizeof(lent_t));
|
|
|
|
luaL_getmetatable(L, "game.entity");
|
|
lua_setmetatable(L, -2);
|
|
|
|
s = (char *)luaL_checkstring(L, 1);
|
|
|
|
lent->e = NULL;
|
|
|
|
for(i = 0; i < level.num_entities; i++)
|
|
{
|
|
t = &g_entities[i];
|
|
|
|
if(!t || !t->inuse)
|
|
continue;
|
|
|
|
if(Q_stricmp(t->targetname, s) == 0)
|
|
{
|
|
LUA_DEBUG("Entity_Find - Found an entity.");
|
|
lent->e = t;
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
if(!lent->e)
|
|
{
|
|
Com_Printf("Entity_Find - entity '%s' not found!\n", s);
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
// entity.Use(entity targetname)
|
|
// Uses an entity.
|
|
static int Entity_Use(lua_State * L)
|
|
{
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
|
|
if(!lent || !lent->e || !lent->e->use) return 0;
|
|
|
|
if(lent->e->luaUse)
|
|
LuaHook_G_EntityUse(lent->e->luaUse, lent->e-g_entities, lent->e-g_entities, lent->e-g_entities);
|
|
lent->e->use(lent->e, NULL, lent->e);
|
|
|
|
return 1;
|
|
}
|
|
|
|
// entity.Teleport(entity ent, entity target)
|
|
// Teleports a player to another entity
|
|
static int Entity_Teleport(lua_State * L)
|
|
{
|
|
lent_t *lent;
|
|
lent_t *target;
|
|
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
target = Lua_GetEntity(L, 2);
|
|
|
|
if(!lent || !lent->e)
|
|
{
|
|
Com_Printf("Entity_Teleport - invalid entity!\n");
|
|
return 0;
|
|
}
|
|
if(!target || !target->e)
|
|
{
|
|
Com_Printf("Entity_Teleport - invalid target!\n");
|
|
return 0;
|
|
}
|
|
|
|
if(lent->e->client)
|
|
TeleportPlayer(lent->e, target->e->s.origin, target->e->s.angles, TP_NORMAL);
|
|
return 1;
|
|
}
|
|
|
|
|
|
// entity.IsRocket(entity ent)
|
|
// Checks if an entity is a rocket
|
|
static int Entity_IsRocket(lua_State * L)
|
|
{
|
|
lent_t *lent;
|
|
qboolean rocket = qfalse;
|
|
|
|
luaL_getmetatable(L, "game.entity");
|
|
lua_setmetatable(L, -2);
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
|
|
if(lent->e && !Q_stricmp(lent->e->classname, "rocket"))
|
|
rocket = qtrue;
|
|
|
|
lua_pushboolean(L, (int)rocket);
|
|
|
|
return 1;
|
|
}
|
|
|
|
// entity.IsGrenade(entity ent)
|
|
// Checks if an enity is a grenade
|
|
static int Entity_IsGrenade(lua_State * L)
|
|
{
|
|
lent_t *lent;
|
|
qboolean grenade = qfalse;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
|
|
if(Q_stricmp(lent->e->classname, "grenade"))
|
|
grenade = qtrue;
|
|
|
|
lua_pushboolean(L, grenade);
|
|
|
|
return 1;
|
|
}
|
|
|
|
// entity.Spawn(void)
|
|
// Spawn a new entity if possible
|
|
static int Entity_Spawn(lua_State * L)
|
|
{
|
|
lent_t *lent;
|
|
|
|
lent = lua_newuserdata(L, sizeof(lent_t));
|
|
|
|
luaL_getmetatable(L, "game.entity");
|
|
lua_setmetatable(L, -2);
|
|
|
|
lent->e = G_Spawn();
|
|
|
|
return 1;
|
|
}
|
|
|
|
// entity.GetNumber(entity ent)
|
|
// returns the entities index number
|
|
static int Entity_GetNumber(lua_State * L)
|
|
{
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
lua_pushnumber(L, lent->e - g_entities);
|
|
|
|
return 1;
|
|
}
|
|
|
|
// entity.IsClient(entity ent)
|
|
// Checks if an entity is a client
|
|
static int Entity_IsClient(lua_State * L)
|
|
{
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
|
|
if(!lent || !lent->e) {
|
|
return 1;
|
|
}
|
|
|
|
lua_pushboolean(L, lent->e->client != NULL);
|
|
|
|
return 1;
|
|
}
|
|
|
|
// entity.GetClientName(entity ent)
|
|
// Returns the display name of a client
|
|
static int Entity_GetClientName(lua_State * L)
|
|
{
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
|
|
if(!lent || !lent->e || !lent->e->classname) {
|
|
return 1;
|
|
}
|
|
|
|
lua_pushstring(L, lent->e->client->pers.netname);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_Print(lua_State * L)
|
|
{
|
|
lent_t *lent;
|
|
int i;
|
|
char buf[MAX_STRING_CHARS];
|
|
int n = lua_gettop(L);
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
|
|
if(!lent|| !lent->e) return 0;
|
|
|
|
if(!lent->e->client)
|
|
return luaL_error(L, "\'Print\' must be used with a client entity");
|
|
|
|
memset(buf, 0, sizeof(buf));
|
|
|
|
lua_getglobal(L, "tostring");
|
|
for(i = 2; i <= n; i++)
|
|
{
|
|
const char *s;
|
|
|
|
lua_pushvalue(L, -1);
|
|
lua_pushvalue(L, i);
|
|
lua_call(L, 1, 1);
|
|
s = lua_tostring(L, -1);
|
|
|
|
if(s == NULL)
|
|
return luaL_error(L, "\'tostring\' must return a string to \'print\'");
|
|
|
|
Q_strcat(buf, sizeof(buf), s);
|
|
|
|
lua_pop(L, 1);
|
|
}
|
|
|
|
trap_SendServerCommand(lent->e - g_entities, va("print \"%s\n\"", buf));
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int Entity_CenterPrint(lua_State * L)
|
|
{
|
|
lent_t *lent;
|
|
int i;
|
|
char buf[MAX_STRING_CHARS];
|
|
int n = lua_gettop(L);
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
|
|
if(!lent || !lent->e) return 0;
|
|
|
|
if(!lent->e->client)
|
|
return luaL_error(L, "\'CenterPrint\' must be used with a client entity");
|
|
|
|
memset(buf, 0, sizeof(buf));
|
|
|
|
lua_getglobal(L, "tostring");
|
|
for(i = 2; i <= n; i++)
|
|
{
|
|
const char *s;
|
|
|
|
lua_pushvalue(L, -1);
|
|
lua_pushvalue(L, i);
|
|
lua_call(L, 1, 1);
|
|
s = lua_tostring(L, -1);
|
|
|
|
if(s == NULL)
|
|
return luaL_error(L, "\'tostring\' must return a string to \'print\'");
|
|
|
|
Q_strcat(buf, sizeof(buf), s);
|
|
|
|
lua_pop(L, 1);
|
|
}
|
|
|
|
trap_SendServerCommand(lent->e - g_entities, va("cp \"" S_COLOR_WHITE "%s\n\"", buf));
|
|
|
|
return 0;
|
|
}
|
|
|
|
extern qboolean G_ParseField(const char *key, const char *value, gentity_t *ent);
|
|
// entity.SetKeyValue(entity ent, string key, string value)
|
|
// Sets a key of an entity to a value
|
|
static int Entity_SetKeyValue(lua_State * L) {
|
|
lent_t *lent;
|
|
char *key, *value;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
key = (char *)luaL_checkstring(L, 2);
|
|
value = (char *)luaL_checkstring(L, 3);
|
|
|
|
if(!lent || !lent->e || !key[0] || !value[0]) {
|
|
lua_pushboolean(L, qfalse);
|
|
return 1;
|
|
}
|
|
|
|
lua_pushboolean(L, G_ParseField(key, value, lent->e));
|
|
return 1;
|
|
}
|
|
|
|
// entity.GetClassname(entity ent)
|
|
// Returns the classname of an entity
|
|
static int Entity_GetClassName(lua_State * L)
|
|
{
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
lua_pushstring(L, lent->e->classname);
|
|
|
|
return 1;
|
|
}
|
|
|
|
// entity.SetClassname(entity ent, string name)
|
|
// Sets the Classname of an entity to name
|
|
static int Entity_SetClassName(lua_State * L)
|
|
{
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
lent->e->classname = (char *)luaL_checkstring(L, 2);
|
|
|
|
return 1;
|
|
}
|
|
|
|
// entity.GetTargetname(entity ent)
|
|
// Returns the targetname of an entity
|
|
static int Entity_GetTargetName(lua_State * L)
|
|
{
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
lua_pushstring(L, lent->e->targetname);
|
|
|
|
return 1;
|
|
}
|
|
|
|
// entity.Rotate(entity ent, vector dir)
|
|
// Rotates an entity in the specified directions
|
|
static int Entity_Rotate(lua_State * L)
|
|
{
|
|
lent_t *lent;
|
|
vec_t *vec;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
vec = Lua_GetVector(L, 2);
|
|
|
|
lent->e->s.apos.trType = TR_LINEAR;
|
|
lent->e->s.apos.trDelta[0] = vec[0];
|
|
lent->e->s.apos.trDelta[1] = vec[1];
|
|
lent->e->s.apos.trDelta[2] = vec[2];
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GC(lua_State * L)
|
|
{
|
|
|
|
return 0;
|
|
}
|
|
|
|
// entity.ToString(entity)
|
|
// Prints an entity as string
|
|
static int Entity_ToString(lua_State * L)
|
|
{
|
|
lent_t *lent;
|
|
gentity_t *gent;
|
|
char buf[MAX_STRING_CHARS];
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
gent = lent->e;
|
|
Com_sprintf(buf, sizeof(buf), "entity: class=%s name=%s id=%i pointer=%p\n", gent->classname, gent->targetname, gent - g_entities,
|
|
gent);
|
|
lua_pushstring(L, buf);
|
|
|
|
return 1;
|
|
}
|
|
|
|
extern qboolean G_CallSpawn(gentity_t *ent);
|
|
|
|
static void ent_delay(gentity_t *ent) {
|
|
ent->think = 0;
|
|
ent->nextthink = -1;
|
|
G_CallSpawn(ent);
|
|
}
|
|
|
|
// entity.DelayedCallSpawn(entity ent, int ms)
|
|
// Calls the entities spawn function delayed
|
|
static int Entity_DelayedCallSpawn(lua_State *L) {
|
|
lent_t *lent;
|
|
int delay;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
|
|
delay = luaL_checkint(L, 2);
|
|
|
|
if(!delay)
|
|
delay = FRAMETIME;
|
|
|
|
lent->e->nextthink = delay;
|
|
lent->e->think = ent_delay;
|
|
|
|
return 1;
|
|
}
|
|
|
|
// entity.CallSpawn(entity ent)
|
|
// Calls the entities spawn function
|
|
static int Entity_CallSpawn(lua_State *L) {
|
|
lent_t *lent;
|
|
qboolean r = qfalse;
|
|
gentity_t *e = NULL;
|
|
|
|
LUA_DEBUG("Entity_CallSpawn - start");
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
|
|
if(lent)
|
|
e = lent->e;
|
|
|
|
if(e) {
|
|
LUA_DEBUG("Entity_CallSpawn - G_CallSpawn");
|
|
trap_UnlinkEntity(e);
|
|
r = G_CallSpawn(e);
|
|
lua_pushboolean(L, r);
|
|
return 1;
|
|
} else {
|
|
LUA_DEBUG("Entity_CallSpawn - NULL entity");
|
|
}
|
|
|
|
lua_pushboolean(L, 0);
|
|
return 1;
|
|
}
|
|
|
|
extern field_t fields[];
|
|
static int Entity_RemoveUnnamedSpawns(lua_State *L) {
|
|
gentity_t *ent;
|
|
int cnt = 0, i;
|
|
|
|
for(i = 0; i < MAX_GENTITIES; i++) {
|
|
if(!&g_entities[i]) continue;
|
|
ent = &g_entities[i];
|
|
if(!ent->classname) continue;
|
|
if(!Q_stricmp(ent->classname, "info_player_deathmatch"))
|
|
if(!ent->targetname) {
|
|
G_FreeEntity(ent);
|
|
cnt++;
|
|
}
|
|
}
|
|
|
|
lua_pushnumber(L, cnt);
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_RemoveSpawns(lua_State *L) {
|
|
gentity_t *ent;
|
|
int cnt = 0, i;
|
|
|
|
for(i = 0; i < MAX_GENTITIES; i++) {
|
|
if(!&g_entities[i]) continue;
|
|
ent = &g_entities[i];
|
|
if(!ent->classname) continue;
|
|
if(!Q_stricmp(ent->classname, "info_player_deathmatch")) {
|
|
G_FreeEntity(ent);
|
|
cnt++;
|
|
}
|
|
}
|
|
|
|
lua_pushnumber(L, cnt);
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_RemoveType(lua_State *L) {
|
|
int i, cnt = 0;
|
|
char *classname;
|
|
|
|
classname = (char *)luaL_checkstring(L , 1);
|
|
if(!classname) {
|
|
lua_pushinteger(L, -1);
|
|
return 1;
|
|
}
|
|
|
|
for(i = 0; i < MAX_GENTITIES; i++) {
|
|
if(!strcmp(g_entities[i].classname, classname)) {
|
|
G_FreeEntity(&g_entities[i]);
|
|
cnt++;
|
|
}
|
|
}
|
|
|
|
lua_pushinteger(L, cnt);
|
|
return 1;
|
|
}
|
|
|
|
// entity.Remove(entity ent)
|
|
// Removes an entity if it is not protected
|
|
static int Entity_Remove(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
|
|
if(!lent || !lent->e) {
|
|
lua_pushboolean(L, 0);
|
|
return 1;
|
|
}
|
|
|
|
if(lent->e->neverFree || lent->e->client) {
|
|
lua_pushboolean(L, 0);
|
|
return 1;
|
|
}
|
|
|
|
G_FreeEntity(lent->e);
|
|
lua_pushboolean(L, 1);
|
|
|
|
return 1;
|
|
}
|
|
|
|
// entity.SetupTrigger(entity ent, int sizex, int sizey, int sizez)
|
|
// entity.SetupTrigger(entity ent, vector size)
|
|
// Sets up some basic trigger things
|
|
static int Entity_SetupTrigger(lua_State *L) {
|
|
lent_t *lent;
|
|
gentity_t *e;
|
|
vec_t *vptr;
|
|
vec3_t size;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
|
|
if(!lent || !lent->e) {
|
|
return 1;
|
|
}
|
|
|
|
e = lent->e;
|
|
|
|
if(Lua_IsVector(L, 2)) {
|
|
vptr = Lua_GetVector(L, 2);
|
|
VectorCopy(vptr, size);
|
|
} else {
|
|
size[0] = luaL_checkint(L, 2);
|
|
size[1] = luaL_checkint(L, 3);
|
|
size[2] = luaL_checkint(L, 4);
|
|
}
|
|
|
|
VectorCopy(size, e->r.mins);
|
|
VectorCopy(size, e->r.maxs);
|
|
VectorScale(e->r.mins, -.5, e->r.mins);
|
|
VectorScale(e->r.maxs, .5, e->r.maxs);
|
|
VectorCopy(e->r.mins, e->r.absmin);
|
|
VectorCopy(e->r.maxs, e->r.absmax);
|
|
|
|
e->tmpEntity = qtrue;
|
|
|
|
return 1;
|
|
}
|
|
|
|
// entity.GetOrigin(entity ent)
|
|
// Returns the origin of an entity as vector
|
|
static int Entity_GetOrigin(lua_State *L) {
|
|
lent_t *lent;
|
|
vec3_t origin;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
|
|
if(!lent || !lent->e) {
|
|
lua_pushnil(L);
|
|
return 1;
|
|
}
|
|
|
|
if(lent->e->r.svFlags & SVF_USE_CURRENT_ORIGIN)
|
|
VectorCopy(lent->e->r.currentOrigin, origin);
|
|
else
|
|
VectorCopy(lent->e->s.origin, origin);
|
|
|
|
Lua_PushVector(L, origin);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_Lock(lua_State *L) {
|
|
lent_t *lent;
|
|
gentity_t *ent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
|
|
if(!lent || !lent->e) return 1;
|
|
|
|
ent = lent->e;
|
|
|
|
if(!strncmp(ent->classname, "func_door", 9) ||
|
|
!strncmp(ent->classname, "func_door_rotating", 18) ||
|
|
!strncmp(ent->classname, "target_teleporter", 17) ||
|
|
!strncmp(ent->classname, "target_turbolift", 16) ||
|
|
!strncmp(ent->classname, "func_usable", 11) ||
|
|
!strncmp(ent->classname, "target_serverchange", 19) ||
|
|
!strncmp(ent->classname, "trigger_teleport", 16) ||
|
|
!strncmp(ent->classname, "ui_transporter", 14) ||
|
|
!strncmp(ent->classname, "ui_holodeck", 11)
|
|
) {
|
|
if(ent->flags & FL_LOCKED) return 1;
|
|
ent->flags ^= FL_LOCKED;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_Unlock(lua_State *L) {
|
|
lent_t *lent;
|
|
gentity_t *ent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
|
|
if(!lent || !lent->e) return 1;
|
|
|
|
ent = lent->e;
|
|
|
|
if(!strncmp(ent->classname, "func_door", 9) ||
|
|
!strncmp(ent->classname, "func_door_rotating", 18) ||
|
|
!strncmp(ent->classname, "target_teleporter", 17) ||
|
|
!strncmp(ent->classname, "target_turbolift", 16) ||
|
|
!strncmp(ent->classname, "func_usable", 11) ||
|
|
!strncmp(ent->classname, "target_serverchange", 19) ||
|
|
!strncmp(ent->classname, "trigger_teleport", 16) ||
|
|
!strncmp(ent->classname, "ui_transporter", 14) ||
|
|
!strncmp(ent->classname, "ui_holodeck", 11)
|
|
) {
|
|
if(ent->flags & FL_LOCKED)
|
|
ent->flags ^= FL_LOCKED;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_IsLocked(lua_State *L) {
|
|
lent_t *lent;
|
|
gentity_t *ent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
|
|
if(!lent || lent->e) return 1;
|
|
|
|
ent = lent->e;
|
|
|
|
lua_pushboolean(L, (int)(ent->flags & FL_LOCKED));
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetParm(lua_State *L) {
|
|
lent_t *lent;
|
|
gentity_t *ent;
|
|
int parm;
|
|
char *res = NULL;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
|
|
if(!lent || !lent->e) {
|
|
lua_pushnil(L);
|
|
return 1;
|
|
}
|
|
|
|
ent = lent->e;
|
|
|
|
parm = luaL_checkint(L, 2);
|
|
|
|
if(!parm || parm < 0 || parm > 4) {
|
|
lua_pushnil(L);
|
|
return 1;
|
|
}
|
|
|
|
switch(parm) {
|
|
case 1:
|
|
res = ent->luaParm1;
|
|
break;
|
|
case 2:
|
|
res = ent->luaParm2;
|
|
break;
|
|
case 3:
|
|
res = ent->luaParm3;
|
|
break;
|
|
case 4:
|
|
res = ent->luaParm4;
|
|
break;
|
|
}
|
|
|
|
if(!res) {
|
|
lua_pushnil(L);
|
|
} else {
|
|
lua_pushstring(L, res);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetParm(lua_State *L) {
|
|
lent_t *lent;
|
|
gentity_t *ent;
|
|
int parm;
|
|
char *parms;
|
|
char *s = NULL;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
|
|
if(!lent || !lent->e) return 1;
|
|
|
|
ent = lent->e;
|
|
|
|
parm = luaL_checkint(L, 2);
|
|
|
|
if(!parm || parm < 0 || parm > 4) return 1;
|
|
|
|
parms = (char *)luaL_checkstring(L, 3);
|
|
|
|
if(!parms) return 1;
|
|
|
|
switch(parm) {
|
|
case 1:
|
|
s = ent->luaParm1;
|
|
break;
|
|
case 2:
|
|
s = ent->luaParm2;
|
|
break;
|
|
case 3:
|
|
s = ent->luaParm3;
|
|
break;
|
|
case 4:
|
|
s = ent->luaParm4;
|
|
break;
|
|
}
|
|
|
|
if(s) {
|
|
// check if the new string fits into the existing one
|
|
if(strlen(s) > (strlen(parms) + 1)) {
|
|
// it fits so copy it
|
|
strncpy(s, parms, sizeof(s));
|
|
} else {
|
|
// it does not fit in so alloc a new string
|
|
s = G_NewString(parms);
|
|
}
|
|
} else
|
|
s = G_NewString(parms);
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetActivator(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushnil(L);
|
|
return 1;
|
|
}
|
|
Lua_PushEntity(L, lent->e->activator);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetActivator(lua_State *L) {
|
|
lent_t *lent;
|
|
lent_t *activator;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
activator = Lua_GetEntity(L, 2);
|
|
if(!activator || activator->e)
|
|
lent->e->activator = NULL;
|
|
else
|
|
lent->e->activator = activator->e;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetAngle(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushnumber(L, 0);
|
|
return 1;
|
|
}
|
|
lua_pushnumber(L, lent->e->angle);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetAngle(lua_State *L) {
|
|
lent_t *lent;
|
|
float angle;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
angle = (float)luaL_checknumber(L, 2);
|
|
lent->e->angle = angle;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetApos1(lua_State *L) {
|
|
lent_t *lent;
|
|
vec3_t null = { 0, 0, 0 };
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
Lua_PushVector(L, null);
|
|
return 1;
|
|
}
|
|
Lua_PushVector(L, lent->e->apos1);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetApos2(lua_State *L) {
|
|
lent_t *lent;
|
|
vec3_t null = { 0, 0, 0 };
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
Lua_PushVector(L, null);
|
|
return 1;
|
|
}
|
|
Lua_PushVector(L, lent->e->apos2);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetApos1(lua_State *L) {
|
|
lent_t *lent;
|
|
vec_t *vec;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || lent->e)
|
|
return 1;
|
|
vec = Lua_GetVector(L, 2);
|
|
if(!vec)
|
|
return 1;
|
|
VectorCopy(vec, lent->e->apos1);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetApos2(lua_State *L) {
|
|
lent_t *lent;
|
|
vec_t *vec;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || lent->e)
|
|
return 1;
|
|
vec = Lua_GetVector(L, 2);
|
|
if(!vec)
|
|
return 1;
|
|
VectorCopy(vec, lent->e->apos2);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetBluename(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
if(!lent->e->bluename[0])
|
|
lua_pushstring(L, "");
|
|
else
|
|
lua_pushstring(L, lent->e->bluename);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetBluename(lua_State *L) {
|
|
lent_t *lent;
|
|
char *s;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
if(lua_isstring(L, 2)) {
|
|
s = (char *)luaL_checkstring(L, 2);
|
|
lent->e->bluename = G_NewString(s);
|
|
} else
|
|
lent->e->bluename = NULL;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetBluesound(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushstring(L, "");
|
|
return 1;
|
|
}
|
|
if(!lent->e->bluesound[0])
|
|
lua_pushstring(L, "");
|
|
else
|
|
lua_pushstring(L, lent->e->bluesound);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetBluesound(lua_State *L) {
|
|
lent_t *lent;
|
|
char *s;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
if(lua_isstring(L, 2)) {
|
|
s = (char *)luaL_checkstring(L, 2);
|
|
lent->e->bluesound = G_NewString(s);
|
|
} else
|
|
lent->e->bluesound = NULL;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetBooleanstate(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || lent->e) {
|
|
lua_pushboolean(L, 0);
|
|
return 1;
|
|
}
|
|
lua_pushboolean(L, (int)lent->e->booleanstate);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetBooleanstate(lua_State *L) {
|
|
lent_t *lent;
|
|
qboolean b;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
b = (qboolean)lua_toboolean(L, 2);
|
|
|
|
lent->e->booleanstate = b;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetClipmask(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushinteger(L, 0);
|
|
return 1;
|
|
}
|
|
lua_pushinteger(L, lent->e->clipmask);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetClipmask(lua_State *L) {
|
|
lent_t *lent;
|
|
int mask;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
mask = (int)luaL_checknumber(L, 2);
|
|
|
|
lent->e->clipmask = mask;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetCount(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushinteger(L, 0);
|
|
return 1;
|
|
}
|
|
lua_pushinteger(L, lent->e->count);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetCount(lua_State *L) {
|
|
lent_t *lent;
|
|
int count;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
count = (int)luaL_checknumber(L, 2);
|
|
|
|
lent->e->count = count;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetDamage(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushinteger(L, 0);
|
|
return 1;
|
|
}
|
|
lua_pushinteger(L, lent->e->damage);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetDamage(lua_State *L) {
|
|
lent_t *lent;
|
|
int damage;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
damage = (int)luaL_checknumber(L, 2);
|
|
|
|
lent->e->damage = damage;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetDistance(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushnumber(L, 0);
|
|
return 1;
|
|
}
|
|
lua_pushnumber(L, lent->e->distance);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetDistance(lua_State *L) {
|
|
lent_t *lent;
|
|
float distance;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || ! lent->e)
|
|
return 1;
|
|
distance = (float)luaL_checknumber(L, 2);
|
|
|
|
lent->e->distance = distance;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetEnemy(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushnil(L);
|
|
return 1;
|
|
}
|
|
Lua_PushEntity(L, lent->e->enemy);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetEnemy(lua_State *L) {
|
|
lent_t *lent;
|
|
lent_t *enemy;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || lent->e)
|
|
return 1;
|
|
if(lua_isnil(L, 2)) {
|
|
lent->e->enemy = NULL;
|
|
} else {
|
|
enemy = Lua_GetEntity(L, 2);
|
|
if(!enemy || !enemy->e) {
|
|
lent->e->enemy = NULL;
|
|
} else {
|
|
lent->e->enemy = enemy->e;
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetEventTime(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushinteger(L, 0);
|
|
return 1;
|
|
}
|
|
lua_pushinteger(L, lent->e->eventTime);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetEventTime(lua_State *L) {
|
|
lent_t *lent;
|
|
int eTime;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
eTime = (int)luaL_checknumber(L, 2);
|
|
|
|
lent->e->eventTime = eTime;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetFalsename(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushstring(L, "");
|
|
}
|
|
if(!lent->e->falsename[0])
|
|
lua_pushstring(L, "");
|
|
else
|
|
lua_pushstring(L, lent->e->falsename);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetFalsename(lua_State *L) {
|
|
lent_t *lent;
|
|
char *s;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
s = (char *)luaL_checkstring(L, 2);
|
|
if(!s[0])
|
|
lent->e->falsename = NULL;
|
|
else
|
|
lent->e->falsename = G_NewString(s);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetTargetName(lua_State *L) {
|
|
lent_t *lent;
|
|
char *s;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
s = (char *)luaL_checkstring(L, 2);
|
|
if(!s[0])
|
|
lent->e->targetname = NULL;
|
|
else
|
|
lent->e->targetname = G_NewString(s);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetFalsetarget(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushstring(L, "");
|
|
return 1;
|
|
}
|
|
if(!lent->e->falsetarget[0]) {
|
|
lua_pushstring(L, "");
|
|
} else {
|
|
lua_pushstring(L, lent->e->falsetarget);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetFalsetarget(lua_State *L) {
|
|
lent_t *lent;
|
|
char *s;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
s = (char *)luaL_checkstring(L, 2);
|
|
if(!s[0])
|
|
lent->e->falsetarget = NULL;
|
|
else
|
|
lent->e->falsetarget = G_NewString(s);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetFlags(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushinteger(L, 0);
|
|
return 1;
|
|
}
|
|
lua_pushinteger(L, lent->e->flags);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetFlags(lua_State *L) {
|
|
lent_t *lent;
|
|
int flags;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
flags = (int)luaL_checknumber(L, 2);
|
|
|
|
lent->e->flags = flags;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetFreeAfterEvent(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushboolean(L, 0);
|
|
return 1;
|
|
}
|
|
lua_pushboolean(L, (int)lent->e->freeAfterEvent);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetFreeAfterEvent(lua_State *L) {
|
|
lent_t *lent;
|
|
qboolean b;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
b = (qboolean)lua_toboolean(L, 2);
|
|
|
|
lent->e->freeAfterEvent = b;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetFreetime(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushinteger(L, 0);
|
|
return 1;
|
|
}
|
|
lua_pushinteger(L, lent->e->freetime);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetGreensound(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushstring(L, "");
|
|
return 1;
|
|
}
|
|
if(!lent->e->greensound[0]) {
|
|
lua_pushstring(L, "");
|
|
} else {
|
|
lua_pushstring(L, lent->e->greensound);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetGreensound(lua_State *L) {
|
|
lent_t *lent;
|
|
char *s;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
s = (char *)luaL_checkstring(L, 2);
|
|
if(!s[0])
|
|
lent->e->greensound = NULL;
|
|
else
|
|
lent->e->greensound = G_NewString(s);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetHealth(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushinteger(L, 0);
|
|
return 1;
|
|
}
|
|
lua_pushinteger(L, lent->e->health);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetHealth(lua_State *L) {
|
|
lent_t *lent;
|
|
int health;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
health = (int)luaL_checknumber(L, 2);
|
|
|
|
lent->e->health = health;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetInUse(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushboolean(L, 0);
|
|
return 1;
|
|
}
|
|
lua_pushboolean(L, (int)lent->e->inuse);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetInUse(lua_State *L) {
|
|
lent_t *lent;
|
|
qboolean b;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
b = (qboolean)lua_toboolean(L, 2);
|
|
lent->e->inuse = b;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetLastEnemy(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushnil(L);
|
|
return 1;
|
|
}
|
|
if(!lent->e->lastEnemy)
|
|
lua_pushnil(L);
|
|
else
|
|
Lua_PushEntity(L, lent->e->lastEnemy);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetLastEnemy(lua_State *L) {
|
|
lent_t *lent;
|
|
lent_t *lastEnemy;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
lastEnemy = Lua_GetEntity(L, 2);
|
|
if(!lastEnemy || !lastEnemy->e)
|
|
return 1;
|
|
|
|
lent->e->lastEnemy = lastEnemy->e;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetLuaDie(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushstring(L, "");
|
|
return 1;
|
|
}
|
|
if(!lent->e->luaDie[0]) {
|
|
lua_pushstring(L, "");
|
|
} else {
|
|
lua_pushstring(L, lent->e->luaDie);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetLuaDie(lua_State *L) {
|
|
lent_t *lent;
|
|
char *s;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
s = (char *)luaL_checkstring(L, 2);
|
|
if(!s[0])
|
|
lent->e->luaDie = NULL;
|
|
else
|
|
lent->e->luaDie = G_NewString(s);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetLuaEntity(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushboolean(L, 0);
|
|
return 1;
|
|
}
|
|
lua_pushboolean(L, (int)lent->e->luaEntity);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetLuaEntity(lua_State *L) {
|
|
lent_t *lent;
|
|
qboolean b;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
b = (qboolean)lua_toboolean(L, 2);
|
|
|
|
lent->e->luaEntity = b;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetLuaFree(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushstring(L, "");
|
|
return 1;
|
|
}
|
|
if(!lent->e->luaDie[0]) {
|
|
lua_pushstring(L, "");
|
|
} else {
|
|
lua_pushstring(L, lent->e->luaFree);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetLuaFree(lua_State *L) {
|
|
lent_t *lent;
|
|
char *s;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
s = (char *)luaL_checkstring(L, 2);
|
|
if(!s[0])
|
|
lent->e->luaFree = NULL;
|
|
else
|
|
lent->e->luaFree = G_NewString(s);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetLuaHurt(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushstring(L, "");
|
|
return 1;
|
|
}
|
|
if(!lent->e->luaDie[0]) {
|
|
lua_pushstring(L, "");
|
|
} else {
|
|
lua_pushstring(L, lent->e->luaHurt);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetLuaHurt(lua_State *L) {
|
|
lent_t *lent;
|
|
char *s;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
s = (char *)luaL_checkstring(L, 2);
|
|
if(!s[0])
|
|
lent->e->luaHurt = NULL;
|
|
else
|
|
lent->e->luaHurt = G_NewString(s);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetLuaReached(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushstring(L, "");
|
|
return 1;
|
|
}
|
|
if(!lent->e->luaDie[0]) {
|
|
lua_pushstring(L, "");
|
|
} else {
|
|
lua_pushstring(L, lent->e->luaReached);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetLuaReached(lua_State *L) {
|
|
lent_t *lent;
|
|
char *s;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
s = (char *)luaL_checkstring(L, 2);
|
|
if(!s[0])
|
|
lent->e->luaReached = NULL;
|
|
else
|
|
lent->e->luaReached = G_NewString(s);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetLuaReachedAngular(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushstring(L, "");
|
|
return 1;
|
|
}
|
|
if(!lent->e->luaDie[0]) {
|
|
lua_pushstring(L, "");
|
|
} else {
|
|
lua_pushstring(L, lent->e->luaReachedAngular);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetLuaReachedAngular(lua_State *L) {
|
|
lent_t *lent;
|
|
char *s;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
s = (char *)luaL_checkstring(L, 2);
|
|
if(!s[0])
|
|
lent->e->luaReachedAngular = NULL;
|
|
else
|
|
lent->e->luaReachedAngular = G_NewString(s);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetLuaSpawn(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushstring(L, "");
|
|
return 1;
|
|
}
|
|
if(!lent->e->luaDie[0]) {
|
|
lua_pushstring(L, "");
|
|
} else {
|
|
lua_pushstring(L, lent->e->luaSpawn);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetLuaSpawn(lua_State *L) {
|
|
lent_t *lent;
|
|
char *s;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
s = (char *)luaL_checkstring(L, 2);
|
|
if(!s[0])
|
|
lent->e->luaSpawn = NULL;
|
|
else
|
|
lent->e->luaSpawn = G_NewString(s);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetLuaThink(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushstring(L, "");
|
|
return 1;
|
|
}
|
|
if(!lent->e->luaDie[0]) {
|
|
lua_pushstring(L, "");
|
|
} else {
|
|
lua_pushstring(L, lent->e->luaThink);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetLuaThink(lua_State *L) {
|
|
lent_t *lent;
|
|
char *s;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
s = (char *)luaL_checkstring(L, 2);
|
|
if(!s[0])
|
|
lent->e->luaThink = NULL;
|
|
else
|
|
lent->e->luaThink = G_NewString(s);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetLuaTouch(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushstring(L, "");
|
|
return 1;
|
|
}
|
|
if(!lent->e->luaDie[0]) {
|
|
lua_pushstring(L, "");
|
|
} else {
|
|
lua_pushstring(L, lent->e->luaTouch);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetLuaTouch(lua_State *L) {
|
|
lent_t *lent;
|
|
char *s;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
s = (char *)luaL_checkstring(L, 2);
|
|
if(!s[0])
|
|
lent->e->luaTouch = NULL;
|
|
else
|
|
lent->e->luaTouch = G_NewString(s);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetLuaTrigger(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushstring(L, "");
|
|
return 1;
|
|
}
|
|
if(!lent->e->luaDie[0]) {
|
|
lua_pushstring(L, "");
|
|
} else {
|
|
lua_pushstring(L, lent->e->luaTrigger);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetLuaTrigger(lua_State *L) {
|
|
lent_t *lent;
|
|
char *s;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
s = (char *)luaL_checkstring(L, 2);
|
|
if(!s[0])
|
|
lent->e->luaTrigger = NULL;
|
|
else
|
|
lent->e->luaTrigger = G_NewString(s);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_GetLuaUse(lua_State *L) {
|
|
lent_t *lent;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e) {
|
|
lua_pushstring(L, "");
|
|
return 1;
|
|
}
|
|
if(!lent->e->luaDie[0]) {
|
|
lua_pushstring(L, "");
|
|
} else {
|
|
lua_pushstring(L, lent->e->luaUse);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int Entity_SetLuaUse(lua_State *L) {
|
|
lent_t *lent;
|
|
char *s;
|
|
|
|
lent = Lua_GetEntity(L, 1);
|
|
if(!lent || !lent->e)
|
|
return 1;
|
|
s = (char *)luaL_checkstring(L, 2);
|
|
if(!s[0])
|
|
lent->e->luaUse = NULL;
|
|
else
|
|
lent->e->luaUse = G_NewString(s);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static const luaL_Reg Entity_ctor[] = {
|
|
{"Spawn", Entity_Spawn},
|
|
{"Find", Entity_Find},
|
|
{"FindNumber", Entity_FindNumber},
|
|
{"FindBModel", Entity_FindBModel},
|
|
{"GetTarget", Entity_GetTarget},
|
|
{"CallSpawn", Entity_CallSpawn},
|
|
{"DelayedCallSpawn", Entity_DelayedCallSpawn },
|
|
{"Remove", Entity_Remove},
|
|
{"RemoveUnnamedSpawns", Entity_RemoveUnnamedSpawns},
|
|
{"RemoveSpawns", Entity_RemoveSpawns},
|
|
{"RemoveType", Entity_RemoveType},
|
|
{"Use", Entity_Use},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
/*void dummy(gentity_t *ent) {
|
|
ent->luaUse;
|
|
}*/
|
|
|
|
static const luaL_Reg Entity_meta[] = {
|
|
{"__gc", Entity_GC},
|
|
{"__tostring", Entity_ToString},
|
|
{"GetNumber", Entity_GetNumber},
|
|
{"IsClient", Entity_IsClient},
|
|
{"GetClientname", Entity_GetClientName},
|
|
{"Print", Entity_Print},
|
|
{"CenterPrint", Entity_CenterPrint},
|
|
{"GetClassname", Entity_GetClassName},
|
|
{"SetClassname", Entity_SetClassName},
|
|
{"GetTargetname", Entity_GetTargetName},
|
|
{"SetTargetname", Entity_SetTargetName},
|
|
{"Rotate", Entity_Rotate},
|
|
|
|
{"IsRocket", Entity_IsRocket},
|
|
{"IsGrenade", Entity_IsGrenade},
|
|
{"Teleport", Entity_Teleport},
|
|
{"SetKeyValue", Entity_SetKeyValue},
|
|
{"GetOrigin", Entity_GetOrigin},
|
|
{"SetupTrigger", Entity_SetupTrigger},
|
|
|
|
{"Lock", Entity_Lock},
|
|
{"Unlock", Entity_Unlock},
|
|
{"IsLocked", Entity_IsLocked},
|
|
|
|
{"GetParm", Entity_GetParm},
|
|
{"SetParm", Entity_SetParm},
|
|
|
|
{"GetActivator", Entity_GetActivator},
|
|
{"SetActivator", Entity_SetActivator},
|
|
|
|
{"GetAngle", Entity_GetAngle},
|
|
{"SetAngle", Entity_SetAngle},
|
|
|
|
{"GetApos1", Entity_GetApos1},
|
|
{"GetApos2", Entity_GetApos2},
|
|
|
|
{"SetApos1", Entity_SetApos1},
|
|
{"SetApos2", Entity_SetApos2},
|
|
|
|
{"GetBluename", Entity_GetBluename},
|
|
{"SetBluename", Entity_SetBluename},
|
|
|
|
{"GetBluesound", Entity_GetBluesound},
|
|
{"SetBluesound", Entity_SetBluesound},
|
|
|
|
{"GetBooleanstate", Entity_GetBooleanstate},
|
|
{"SetBooleanstate", Entity_SetBooleanstate},
|
|
|
|
{"GetClipmask", Entity_GetClipmask},
|
|
{"SetClipmask", Entity_SetClipmask},
|
|
|
|
{"GetCount", Entity_GetCount},
|
|
{"SetCount", Entity_SetCount},
|
|
|
|
{"GetDamage", Entity_GetDamage},
|
|
{"SetDamage", Entity_SetDamage},
|
|
|
|
{"GetDistance", Entity_GetDistance},
|
|
{"SetDistance", Entity_SetDistance},
|
|
|
|
{"GetEnemy", Entity_GetEnemy},
|
|
{"SetEnemy", Entity_SetEnemy},
|
|
|
|
{"GetEventTime", Entity_GetEventTime},
|
|
{"SetEventTime", Entity_SetEventTime},
|
|
|
|
{"GetFalsename", Entity_GetFalsename},
|
|
{"SetFalsename", Entity_SetFalsename},
|
|
|
|
{"GetFalsetarget", Entity_GetFalsetarget},
|
|
{"SetFalsetarget", Entity_SetFalsetarget},
|
|
|
|
{"GetFlags", Entity_GetFlags},
|
|
{"SetFlags", Entity_SetFlags},
|
|
|
|
{"GetFreeAfterEvent", Entity_GetFreeAfterEvent},
|
|
{"SetFreeAfterEvent", Entity_SetFreeAfterEvent},
|
|
|
|
{"GetFreetime", Entity_GetFreetime},
|
|
|
|
{"GetGreensound", Entity_GetGreensound},
|
|
{"SetGreensound", Entity_SetGreensound},
|
|
|
|
{"GetHealth", Entity_GetHealth},
|
|
{"SetHealth", Entity_SetHealth},
|
|
|
|
{"GetInUse", Entity_GetInUse},
|
|
{"SetInUse", Entity_SetInUse},
|
|
|
|
{"GetLastEnemy", Entity_GetLastEnemy},
|
|
{"SetLastEnemy", Entity_SetLastEnemy},
|
|
|
|
{"GetLuaDie", Entity_GetLuaDie},
|
|
{"SetLuaDie", Entity_SetLuaDie},
|
|
|
|
{"GetLuaEntity", Entity_GetLuaEntity},
|
|
{"SetLuaEntity", Entity_SetLuaEntity},
|
|
|
|
{"GetLuaFree", Entity_GetLuaFree},
|
|
{"SetLuaFree", Entity_SetLuaFree},
|
|
|
|
{"GetLuaHurt", Entity_GetLuaHurt},
|
|
{"SetLuaHurt", Entity_SetLuaHurt},
|
|
|
|
{"GetLuaReached", Entity_GetLuaReached},
|
|
{"SetLuaReached", Entity_SetLuaReached},
|
|
|
|
{"GetLuaReachedAngular", Entity_GetLuaReachedAngular},
|
|
{"SetLuaReachedAngular", Entity_SetLuaReachedAngular},
|
|
|
|
{"GetLuaSpawn", Entity_GetLuaSpawn},
|
|
{"SetLuaSpawn", Entity_SetLuaSpawn},
|
|
|
|
{"GetLuaThink", Entity_GetLuaThink},
|
|
{"SetLuaThink", Entity_SetLuaThink},
|
|
|
|
{"GetLuaTouch", Entity_GetLuaTouch},
|
|
{"SetLuaTouch", Entity_SetLuaTouch},
|
|
|
|
{"GetLuaTrigger", Entity_GetLuaTrigger},
|
|
{"SetLuaTrigger", Entity_SetLuaTrigger},
|
|
|
|
{"GetLuaUse", Entity_GetLuaUse},
|
|
{"SetLuaUse", Entity_SetLuaUse},
|
|
|
|
{NULL, NULL}
|
|
};
|
|
|
|
int Luaopen_Entity(lua_State * L)
|
|
{
|
|
luaL_newmetatable(L, "game.entity");
|
|
|
|
lua_pushstring(L, "__index");
|
|
lua_pushvalue(L, -2);
|
|
lua_settable(L, -3);
|
|
|
|
luaL_register(L, NULL, Entity_meta);
|
|
luaL_register(L, "entity", Entity_ctor);
|
|
|
|
return 1;
|
|
}
|
|
|
|
void Lua_PushEntity(lua_State * L, gentity_t * ent)
|
|
{
|
|
lent_t *lent;
|
|
|
|
lent = (lent_t *)lua_newuserdata(L, sizeof(lent_t));
|
|
|
|
luaL_getmetatable(L, "game.entity");
|
|
lua_setmetatable(L, -2);
|
|
|
|
lent->e = ent;
|
|
}
|
|
|
|
lent_t *Lua_GetEntity(lua_State * L, int argNum)
|
|
{
|
|
void *ud;
|
|
|
|
ud = luaL_checkudata(L, argNum, "game.entity");
|
|
luaL_argcheck(L, ud != NULL, argNum, "\'entity\' expected");
|
|
return (lent_t *) ud;
|
|
}
|
|
#endif
|