From 8ba8373440436032709a269a1f1d5b9a7e1ebfef Mon Sep 17 00:00:00 2001 From: Yamagi Burmeister Date: Tue, 4 Oct 2011 13:02:52 +0000 Subject: [PATCH] Commit the cool, amazing and outresolving savegame system. Savegames don't break anymore when the game.so is recompiled or changed. :) --- Makefile | 4 +- src/game/baseq2/g_save.c | 770 ------------ src/game/baseq2/savegame/savegame.c | 1095 +++++++++++++++++ .../baseq2/savegame/tables/clientfields.h | 4 + src/game/baseq2/savegame/tables/fields.h | 81 ++ .../baseq2/savegame/tables/gamefunc_decs.h | 1028 ++++++++++++++++ .../baseq2/savegame/tables/gamefunc_list.h | 1029 ++++++++++++++++ .../baseq2/savegame/tables/gamemmove_decs.h | 286 +++++ .../baseq2/savegame/tables/gamemmove_list.h | 287 +++++ src/game/baseq2/savegame/tables/levelfields.h | 6 + 10 files changed, 3818 insertions(+), 772 deletions(-) delete mode 100644 src/game/baseq2/g_save.c create mode 100644 src/game/baseq2/savegame/savegame.c create mode 100644 src/game/baseq2/savegame/tables/clientfields.h create mode 100644 src/game/baseq2/savegame/tables/fields.h create mode 100644 src/game/baseq2/savegame/tables/gamefunc_decs.h create mode 100644 src/game/baseq2/savegame/tables/gamefunc_list.h create mode 100644 src/game/baseq2/savegame/tables/gamemmove_decs.h create mode 100644 src/game/baseq2/savegame/tables/gamemmove_list.h create mode 100644 src/game/baseq2/savegame/tables/levelfields.h diff --git a/Makefile b/Makefile index 8145a890..a9f8aaa2 100644 --- a/Makefile +++ b/Makefile @@ -181,7 +181,6 @@ BASEQ2_OBJS_ = \ src/game/baseq2/g_misc.o \ src/game/baseq2/g_monster.o \ src/game/baseq2/g_phys.o \ - src/game/baseq2/g_save.o \ src/game/baseq2/g_spawn.o \ src/game/baseq2/g_svcmds.o \ src/game/baseq2/g_target.o \ @@ -218,7 +217,8 @@ BASEQ2_OBJS_ = \ src/game/baseq2/p_trail.o \ src/game/baseq2/p_view.o \ src/game/baseq2/p_weapon.o \ - src/game/baseq2/q_shared.o + src/game/baseq2/q_shared.o \ + src/game/baseq2/savegame/savegame.o # Used by the client CLIENT_OBJS_ := \ diff --git a/src/game/baseq2/g_save.c b/src/game/baseq2/g_save.c deleted file mode 100644 index 96d32095..00000000 --- a/src/game/baseq2/g_save.c +++ /dev/null @@ -1,770 +0,0 @@ -/* -Copyright (C) 1997-2001 Id Software, Inc. - -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. - -*/ - -#include "g_local.h" - -#define Function(f) {#f, f} - -mmove_t mmove_reloc; - -field_t fields[] = { - {"classname", FOFS(classname), F_LSTRING}, - {"model", FOFS(model), F_LSTRING}, - {"spawnflags", FOFS(spawnflags), F_INT}, - {"speed", FOFS(speed), F_FLOAT}, - {"accel", FOFS(accel), F_FLOAT}, - {"decel", FOFS(decel), F_FLOAT}, - {"target", FOFS(target), F_LSTRING}, - {"targetname", FOFS(targetname), F_LSTRING}, - {"pathtarget", FOFS(pathtarget), F_LSTRING}, - {"deathtarget", FOFS(deathtarget), F_LSTRING}, - {"killtarget", FOFS(killtarget), F_LSTRING}, - {"combattarget", FOFS(combattarget), F_LSTRING}, - {"message", FOFS(message), F_LSTRING}, - {"team", FOFS(team), F_LSTRING}, - {"wait", FOFS(wait), F_FLOAT}, - {"delay", FOFS(delay), F_FLOAT}, - {"random", FOFS(random), F_FLOAT}, - {"move_origin", FOFS(move_origin), F_VECTOR}, - {"move_angles", FOFS(move_angles), F_VECTOR}, - {"style", FOFS(style), F_INT}, - {"count", FOFS(count), F_INT}, - {"health", FOFS(health), F_INT}, - {"sounds", FOFS(sounds), F_INT}, - {"light", 0, F_IGNORE}, - {"dmg", FOFS(dmg), F_INT}, - {"mass", FOFS(mass), F_INT}, - {"volume", FOFS(volume), F_FLOAT}, - {"attenuation", FOFS(attenuation), F_FLOAT}, - {"map", FOFS(map), F_LSTRING}, - {"origin", FOFS(s.origin), F_VECTOR}, - {"angles", FOFS(s.angles), F_VECTOR}, - {"angle", FOFS(s.angles), F_ANGLEHACK}, - - {"goalentity", FOFS(goalentity), F_EDICT, FFL_NOSPAWN}, - {"movetarget", FOFS(movetarget), F_EDICT, FFL_NOSPAWN}, - {"enemy", FOFS(enemy), F_EDICT, FFL_NOSPAWN}, - {"oldenemy", FOFS(oldenemy), F_EDICT, FFL_NOSPAWN}, - {"activator", FOFS(activator), F_EDICT, FFL_NOSPAWN}, - {"groundentity", FOFS(groundentity), F_EDICT, FFL_NOSPAWN}, - {"teamchain", FOFS(teamchain), F_EDICT, FFL_NOSPAWN}, - {"teammaster", FOFS(teammaster), F_EDICT, FFL_NOSPAWN}, - {"owner", FOFS(owner), F_EDICT, FFL_NOSPAWN}, - {"mynoise", FOFS(mynoise), F_EDICT, FFL_NOSPAWN}, - {"mynoise2", FOFS(mynoise2), F_EDICT, FFL_NOSPAWN}, - {"target_ent", FOFS(target_ent), F_EDICT, FFL_NOSPAWN}, - {"chain", FOFS(chain), F_EDICT, FFL_NOSPAWN}, - - {"prethink", FOFS(prethink), F_FUNCTION, FFL_NOSPAWN}, - {"think", FOFS(think), F_FUNCTION, FFL_NOSPAWN}, - {"blocked", FOFS(blocked), F_FUNCTION, FFL_NOSPAWN}, - {"touch", FOFS(touch), F_FUNCTION, FFL_NOSPAWN}, - {"use", FOFS(use), F_FUNCTION, FFL_NOSPAWN}, - {"pain", FOFS(pain), F_FUNCTION, FFL_NOSPAWN}, - {"die", FOFS(die), F_FUNCTION, FFL_NOSPAWN}, - - {"stand", FOFS(monsterinfo.stand), F_FUNCTION, FFL_NOSPAWN}, - {"idle", FOFS(monsterinfo.idle), F_FUNCTION, FFL_NOSPAWN}, - {"search", FOFS(monsterinfo.search), F_FUNCTION, FFL_NOSPAWN}, - {"walk", FOFS(monsterinfo.walk), F_FUNCTION, FFL_NOSPAWN}, - {"run", FOFS(monsterinfo.run), F_FUNCTION, FFL_NOSPAWN}, - {"dodge", FOFS(monsterinfo.dodge), F_FUNCTION, FFL_NOSPAWN}, - {"attack", FOFS(monsterinfo.attack), F_FUNCTION, FFL_NOSPAWN}, - {"melee", FOFS(monsterinfo.melee), F_FUNCTION, FFL_NOSPAWN}, - {"sight", FOFS(monsterinfo.sight), F_FUNCTION, FFL_NOSPAWN}, - {"checkattack", FOFS(monsterinfo.checkattack), F_FUNCTION, FFL_NOSPAWN}, - {"currentmove", FOFS(monsterinfo.currentmove), F_MMOVE, FFL_NOSPAWN}, - - {"endfunc", FOFS(moveinfo.endfunc), F_FUNCTION, FFL_NOSPAWN}, - - // temp spawn vars -- only valid when the spawn function is called - {"lip", STOFS(lip), F_INT, FFL_SPAWNTEMP}, - {"distance", STOFS(distance), F_INT, FFL_SPAWNTEMP}, - {"height", STOFS(height), F_INT, FFL_SPAWNTEMP}, - {"noise", STOFS(noise), F_LSTRING, FFL_SPAWNTEMP}, - {"pausetime", STOFS(pausetime), F_FLOAT, FFL_SPAWNTEMP}, - {"item", STOFS(item), F_LSTRING, FFL_SPAWNTEMP}, - - // need for item field in edict struct, FFL_SPAWNTEMP item will be skipped on saves - {"item", FOFS(item), F_ITEM}, - - {"gravity", STOFS(gravity), F_LSTRING, FFL_SPAWNTEMP}, - {"sky", STOFS(sky), F_LSTRING, FFL_SPAWNTEMP}, - {"skyrotate", STOFS(skyrotate), F_FLOAT, FFL_SPAWNTEMP}, - {"skyaxis", STOFS(skyaxis), F_VECTOR, FFL_SPAWNTEMP}, - {"minyaw", STOFS(minyaw), F_FLOAT, FFL_SPAWNTEMP}, - {"maxyaw", STOFS(maxyaw), F_FLOAT, FFL_SPAWNTEMP}, - {"minpitch", STOFS(minpitch), F_FLOAT, FFL_SPAWNTEMP}, - {"maxpitch", STOFS(maxpitch), F_FLOAT, FFL_SPAWNTEMP}, - {"nextmap", STOFS(nextmap), F_LSTRING, FFL_SPAWNTEMP}, - - {0, 0, 0, 0} - -}; - -field_t levelfields[] = -{ - {"changemap", LLOFS(changemap), F_LSTRING}, - - {"sight_client", LLOFS(sight_client), F_EDICT}, - {"sight_entity", LLOFS(sight_entity), F_EDICT}, - {"sound_entity", LLOFS(sound_entity), F_EDICT}, - {"sound2_entity", LLOFS(sound2_entity), F_EDICT}, - - {NULL, 0, F_INT} -}; - -field_t clientfields[] = -{ - {"pers.weapon", CLOFS(pers.weapon), F_ITEM}, - {"pers.lastweapon", CLOFS(pers.lastweapon), F_ITEM}, - {"newweapon", CLOFS(newweapon), F_ITEM}, - - {NULL, 0, F_INT} -}; - -/* -============ -InitGame - -This will be called when the dll is first loaded, which -only happens when a new game is started or a save game -is loaded. -============ -*/ -void InitGame (void) -{ - gi.dprintf ("Game is starting up.\n"); - gi.dprintf ("Game is baseq2.\n"); - - gun_x = gi.cvar ("gun_x", "0", 0); - gun_y = gi.cvar ("gun_y", "0", 0); - gun_z = gi.cvar ("gun_z", "0", 0); - - //FIXME: sv_ prefix is wrong for these - sv_rollspeed = gi.cvar ("sv_rollspeed", "200", 0); - sv_rollangle = gi.cvar ("sv_rollangle", "2", 0); - sv_maxvelocity = gi.cvar ("sv_maxvelocity", "2000", 0); - sv_gravity = gi.cvar ("sv_gravity", "800", 0); - - // noset vars - dedicated = gi.cvar ("dedicated", "0", CVAR_NOSET); - - // latched vars - sv_cheats = gi.cvar ("cheats", "0", CVAR_SERVERINFO|CVAR_LATCH); - gi.cvar ("gamename", GAMEVERSION , CVAR_SERVERINFO | CVAR_LATCH); - gi.cvar ("gamedate", __DATE__ , CVAR_SERVERINFO | CVAR_LATCH); - - maxclients = gi.cvar ("maxclients", "4", CVAR_SERVERINFO | CVAR_LATCH); - maxspectators = gi.cvar ("maxspectators", "4", CVAR_SERVERINFO); - deathmatch = gi.cvar ("deathmatch", "0", CVAR_LATCH); - coop = gi.cvar ("coop", "0", CVAR_LATCH); - skill = gi.cvar ("skill", "1", CVAR_LATCH); - maxentities = gi.cvar ("maxentities", "1024", CVAR_LATCH); - - // change anytime vars - dmflags = gi.cvar ("dmflags", "0", CVAR_SERVERINFO); - fraglimit = gi.cvar ("fraglimit", "0", CVAR_SERVERINFO); - timelimit = gi.cvar ("timelimit", "0", CVAR_SERVERINFO); - password = gi.cvar ("password", "", CVAR_USERINFO); - spectator_password = gi.cvar ("spectator_password", "", CVAR_USERINFO); - needpass = gi.cvar ("needpass", "0", CVAR_SERVERINFO); - filterban = gi.cvar ("filterban", "1", 0); - - g_select_empty = gi.cvar ("g_select_empty", "0", CVAR_ARCHIVE); - - run_pitch = gi.cvar ("run_pitch", "0.002", 0); - run_roll = gi.cvar ("run_roll", "0.005", 0); - bob_up = gi.cvar ("bob_up", "0.005", 0); - bob_pitch = gi.cvar ("bob_pitch", "0.002", 0); - bob_roll = gi.cvar ("bob_roll", "0.002", 0); - - // flood control - flood_msgs = gi.cvar ("flood_msgs", "4", 0); - flood_persecond = gi.cvar ("flood_persecond", "4", 0); - flood_waitdelay = gi.cvar ("flood_waitdelay", "10", 0); - - // dm map list - sv_maplist = gi.cvar ("sv_maplist", "", 0); - - // items - InitItems (); - - Com_sprintf (game.helpmessage1, sizeof(game.helpmessage1), ""); - - Com_sprintf (game.helpmessage2, sizeof(game.helpmessage2), ""); - - // initialize all entities for this game - game.maxentities = maxentities->value; - g_edicts = gi.TagMalloc (game.maxentities * sizeof(g_edicts[0]), TAG_GAME); - globals.edicts = g_edicts; - globals.max_edicts = game.maxentities; - - // initialize all clients for this game - game.maxclients = maxclients->value; - game.clients = gi.TagMalloc (game.maxclients * sizeof(game.clients[0]), TAG_GAME); - globals.num_edicts = game.maxclients+1; -} - -//========================================================= - -void WriteField1 (FILE *f, field_t *field, byte *base) -{ - void *p; - int len; - int index; - - if (field->flags & FFL_SPAWNTEMP) - return; - - p = (void *)(base + field->ofs); - switch (field->type) - { - case F_INT: - case F_FLOAT: - case F_ANGLEHACK: - case F_VECTOR: - case F_IGNORE: - break; - - case F_LSTRING: - case F_GSTRING: - if ( *(char **)p ) - len = strlen(*(char **)p) + 1; - else - len = 0; - *(int *)p = len; - break; - case F_EDICT: - if ( *(edict_t **)p == NULL) - index = -1; - else - index = *(edict_t **)p - g_edicts; - *(int *)p = index; - break; - case F_CLIENT: - if ( *(gclient_t **)p == NULL) - index = -1; - else - index = *(gclient_t **)p - game.clients; - *(int *)p = index; - break; - case F_ITEM: - if ( *(edict_t **)p == NULL) - index = -1; - else - index = *(gitem_t **)p - itemlist; - *(int *)p = index; - break; - - //relative to code segment - case F_FUNCTION: - if (*(byte **)p == NULL) - index = 0; - else - index = *(byte **)p - ((byte *)InitGame); - *(int *)p = index; - break; - - //relative to data segment - case F_MMOVE: - if (*(byte **)p == NULL) - index = 0; - else - index = *(byte **)p - (byte *)&mmove_reloc; - *(int *)p = index; - break; - - default: - gi.error ("WriteEdict: unknown field type"); - } -} - - -void WriteField2 (FILE *f, field_t *field, byte *base) -{ - int len; - void *p; - - if (field->flags & FFL_SPAWNTEMP) - return; - - p = (void *)(base + field->ofs); - switch (field->type) - { - case F_LSTRING: - if ( *(char **)p ) - { - len = strlen(*(char **)p) + 1; - fwrite (*(char **)p, len, 1, f); - } - break; - default: - break; - } -} - -void ReadField (FILE *f, field_t *field, byte *base) -{ - void *p; - int len; - int index; - - if (field->flags & FFL_SPAWNTEMP) - return; - - p = (void *)(base + field->ofs); - switch (field->type) - { - case F_INT: - case F_FLOAT: - case F_ANGLEHACK: - case F_VECTOR: - case F_IGNORE: - break; - - case F_LSTRING: - len = *(int *)p; - if (!len) - *(char **)p = NULL; - else - { - /* - SBF: FIXME - 32 extra bytes alloc'd since the saved - string might not be long enough - */ - *(char **)p = gi.TagMalloc (32+len, TAG_LEVEL); - fread (*(char **)p, len, 1, f); - } - break; - case F_EDICT: - index = *(int *)p; - if ( index == -1 ) - *(edict_t **)p = NULL; - else - *(edict_t **)p = &g_edicts[index]; - break; - case F_CLIENT: - index = *(int *)p; - if ( index == -1 ) - *(gclient_t **)p = NULL; - else - *(gclient_t **)p = &game.clients[index]; - break; - case F_ITEM: - index = *(int *)p; - if ( index == -1 ) - *(gitem_t **)p = NULL; - else - *(gitem_t **)p = &itemlist[index]; - break; - - //relative to code segment - case F_FUNCTION: - index = *(int *)p; - if ( index == 0 ) - *(byte **)p = NULL; - else - *(byte **)p = ((byte *)InitGame) + index; - break; - - //relative to data segment - case F_MMOVE: - index = *(int *)p; - if (index == 0) - *(byte **)p = NULL; - else - *(byte **)p = (byte *)&mmove_reloc + index; - break; - - default: - gi.error ("ReadEdict: unknown field type"); - } -} - -//========================================================= - -/* -============== -WriteClient - -All pointer variables (except function pointers) must be handled specially. -============== -*/ -void WriteClient (FILE *f, gclient_t *client) -{ - field_t *field; - gclient_t temp; - - // all of the ints, floats, and vectors stay as they are - temp = *client; - - // change the pointers to lengths or indexes - for (field=clientfields ; field->name ; field++) - { - WriteField1 (f, field, (byte *)&temp); - } - - // write the block - fwrite (&temp, sizeof(temp), 1, f); - - // now write any allocated data following the edict - for (field=clientfields ; field->name ; field++) - { - WriteField2 (f, field, (byte *)client); - } -} - -/* -============== -ReadClient - -All pointer variables (except function pointers) must be handled specially. -============== -*/ -void ReadClient (FILE *f, gclient_t *client) -{ - field_t *field; - - fread (client, sizeof(*client), 1, f); - - for (field=clientfields ; field->name ; field++) - { - ReadField (f, field, (byte *)client); - } -} - -/* -============ -WriteGame - -This will be called whenever the game goes to a new level, -and when the user explicitly saves the game. - -Game information include cross level data, like multi level -triggers, help computer info, and all client states. - -A single player death will automatically restore from the -last save position. -============ -*/ -void WriteGame (const char *filename, qboolean autosave) -{ - FILE *f; - int i; - char str[16]; - - if (!autosave) - SaveClientData (); - - f = fopen (filename, "wb"); - if (!f) - gi.error ("Couldn't open %s", filename); - - memset (str, 0, sizeof(str)); - strcpy (str, __DATE__); - fwrite (str, sizeof(str), 1, f); - - game.autosaved = autosave; - fwrite (&game, sizeof(game), 1, f); - game.autosaved = false; - - for (i=0 ; iname ; field++) - { - WriteField1 (f, field, (byte *)&temp); - } - - // write the block - fwrite (&temp, sizeof(temp), 1, f); - - // now write any allocated data following the edict - for (field=fields ; field->name ; field++) - { - WriteField2 (f, field, (byte *)ent); - } - -} - -/* -============== -WriteLevelLocals - -All pointer variables (except function pointers) must be handled specially. -============== -*/ -void WriteLevelLocals (FILE *f) -{ - field_t *field; - level_locals_t temp; - - // all of the ints, floats, and vectors stay as they are - temp = level; - - // change the pointers to lengths or indexes - for (field=levelfields ; field->name ; field++) - { - WriteField1 (f, field, (byte *)&temp); - } - - // write the block - fwrite (&temp, sizeof(temp), 1, f); - - // now write any allocated data following the edict - for (field=levelfields ; field->name ; field++) - { - WriteField2 (f, field, (byte *)&level); - } -} - - -/* -============== -ReadEdict - -All pointer variables (except function pointers) must be handled specially. -============== -*/ -void ReadEdict (FILE *f, edict_t *ent) -{ - field_t *field; - - fread (ent, sizeof(*ent), 1, f); - - for (field=fields ; field->name ; field++) - { - ReadField (f, field, (byte *)ent); - } -} - -/* -============== -ReadLevelLocals - -All pointer variables (except function pointers) must be handled specially. -============== -*/ -void ReadLevelLocals (FILE *f) -{ - field_t *field; - - fread (&level, sizeof(level), 1, f); - - for (field=levelfields ; field->name ; field++) - { - ReadField (f, field, (byte *)&level); - } -} - -/* -================= -WriteLevel - -================= -*/ -void WriteLevel (const char *filename) -{ - int i; - edict_t *ent; - FILE *f; - void *base; - - f = fopen (filename, "wb"); - if (!f) - gi.error ("Couldn't open %s", filename); - - // write out edict size for checking - i = sizeof(edict_t); - fwrite (&i, sizeof(i), 1, f); - - // write out a function pointer for checking - base = (void *)InitGame; - fwrite (&base, sizeof(base), 1, f); - - // write out level_locals_t - WriteLevelLocals (f); - - // write out all the entities - for (i=0 ; iinuse) - continue; - fwrite (&i, sizeof(i), 1, f); - WriteEdict (f, ent); - } - i = -1; - fwrite (&i, sizeof(i), 1, f); - - fclose (f); -} - - -/* -================= -ReadLevel - -SpawnEntities will allready have been called on the -level the same way it was when the level was saved. - -That is necessary to get the baselines -set up identically. - -The server will have cleared all of the world links before -calling ReadLevel. - -No clients are connected yet. -================= -*/ -void ReadLevel (const char *filename) -{ - int entnum; - FILE *f; - int i; - void *base; - edict_t *ent; - - f = fopen (filename, "rb"); - if (!f) - gi.error ("Couldn't open %s", filename); - - // free any dynamic memory allocated by loading the level - // base state - gi.FreeTags (TAG_LEVEL); - - // wipe all the entities - memset (g_edicts, 0, game.maxentities*sizeof(g_edicts[0])); - globals.num_edicts = maxclients->value+1; - - // check edict size - fread (&i, sizeof(i), 1, f); - if (i != sizeof(edict_t)) - { - fclose (f); - gi.error ("ReadLevel: mismatched edict size"); - } - - // check function pointer base address - fread (&base, sizeof(base), 1, f); - gi.dprintf("Function offsets %d\n", ((byte *)base) - ((byte *)InitGame)); - - // load the level locals - ReadLevelLocals (f); - - // load all the entities - while (1) - { - if (fread (&entnum, sizeof(entnum), 1, f) != 1) - { - fclose (f); - gi.error ("ReadLevel: failed to read entnum"); - } - if (entnum == -1) - break; - if (entnum >= globals.num_edicts) - globals.num_edicts = entnum+1; - - ent = &g_edicts[entnum]; - ReadEdict (f, ent); - - // let the server rebuild world links for this ent - memset (&ent->area, 0, sizeof(ent->area)); - gi.linkentity (ent); - } - - fclose (f); - - // mark all clients as unconnected - for (i=0 ; ivalue ; i++) - { - ent = &g_edicts[i+1]; - ent->client = game.clients + i; - ent->client->pers.connected = false; - } - - // do any load time things at this point - for (i=0 ; iinuse) - continue; - - // fire any cross-level triggers - if (ent->classname) - if (strcmp(ent->classname, "target_crosslevel_target") == 0) - ent->nextthink = level.time + ent->delay; - } -} - diff --git a/src/game/baseq2/savegame/savegame.c b/src/game/baseq2/savegame/savegame.c new file mode 100644 index 00000000..2752a333 --- /dev/null +++ b/src/game/baseq2/savegame/savegame.c @@ -0,0 +1,1095 @@ +/* + * Copyright (C) 1997-2001 Id Software, Inc. + * Copyright (C) 2011 Knightmare + * Copyright (C) 2011 Yamagi Burmeister + * + * 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. + * + * ======================================================================= + * + * The savegame system. + * + * ======================================================================= + */ + +/* + * This is the Quake 2 savegame system, fixed by Yamagi + * based on an idea by Knightmare of kmquake2. This major + * rewrite of the original g_save.c is much more robust + * and portable since it doesn't use any function pointers. + * + * Inner workings: + * When the game is saved all function pointers are + * translated into human readable function definition strings. + * The same way all mmove_t pointers are translated. This + * human readable strings are then written into the file. + * At game load the human readable strings are retranslated + * into the actual function pointers and struct pointers. The + * pointers are generated at each compilation / start of the + * client, thus the pointers are always correct. + * + * Limitations: + * While savegames survive recompilations of the game source + * and bigger changes in the source, there are some limitation + * which a nearly impossible to fix without a object orientated + * rewrite of the game. + * - If functions or mmove_t structs that a referencenced + * inside savegames are added or removed (e.g. the files + * in tables/ are altered) the load functions cannot + * reconnect all pointers and thus not restore the game. + * - If the operating system is changed internal structures + * may change in an unrepairable way. + * - If the architecture is changed pointer length and + * other internal datastructures change in an + * incompatible way. + * - If the edict_t struct is changed, savegames + * will break. + * This is not so bad as it looks since functions and + * struct won't be added and edict_t won't be changed + * if no big, sweeping changes are done. The operating + * system and architecture are in the hands of the user. + */ + +#include "../g_local.h" + +/* + * When ever the savegame version + * is changed, q2 will refuse to + * load older savegames. This + * should be bumped if the files + * in tables/ are changed, otherwise + * strange things may happen. + */ +#define SAVEGAMEVER "YQ2-0" + +/* + * This macros are used to + * prohibit loading of savegames + * created on other systems or + * architectures. This will + * crash q2 in spectecular + * ways + */ +#if defined(__FreeBSD__) + #define OS "FreeBSD" +#elif defined(__linux__) + #define OS "Linux" +#else + #define OS "Unknown" +#endif + +#if defined(__i386__) + #define ARCH "i386" +#elif defined(__x86_64__) + #define ARCH "amd64" +#else + #define ARCH "unknown" +#endif + +/* + * Connects a human readable + * function signature with + * the corresponding pointer + */ +typedef struct +{ + char *funcStr; + byte *funcPtr; +} functionList_t; + +/* + * Connects a human readable + * mmove_t string with the + * correspondig pointer + * */ +typedef struct +{ + char *mmoveStr; + mmove_t *mmovePtr; +} mmoveList_t; + +/* ========================================================= */ + +/* + * Prototypes for forward + * declaration for all game + * functions. + */ +#include "tables/gamefunc_decs.h" + +/* + * List with function pointer + * to each of the functions + * prototyped above. + */ +functionList_t functionList[] = { + #include "tables/gamefunc_list.h" +}; + +/* + * Prtotypes for forward + * declaration for all game + * mmove_t functions. + */ +#include "tables/gamemmove_decs.h" + +/* + * List with pointers to + * each of the mmove_t + * functions prototyped + * above. + */ +mmoveList_t mmoveList[] = { + #include "tables/gamemmove_list.h" +}; + +/* + * Fields to be saved + */ +field_t fields[] = { + #include "tables/fields.h" +}; + +/* + * Level fields to + * be saved + */ +field_t levelfields[] = { + #include "tables/levelfields.h" +}; + +/* + * Client fields to + * be saved + */ +field_t clientfields[] = { + #include "tables/clientfields.h" +}; + +/* ========================================================= */ + +/* + * This will be called when the dll is first loaded, + * which only happens when a new game is started or + * a save game is loaded. + */ +void +InitGame(void) +{ + gi.dprintf("Game is starting up.\n"); + gi.dprintf("Game is %s.\n", GAMEVERSION); + + gun_x = gi.cvar("gun_x", "0", 0); + gun_y = gi.cvar("gun_y", "0", 0); + gun_z = gi.cvar("gun_z", "0", 0); + sv_rollspeed = gi.cvar("sv_rollspeed", "200", 0); + sv_rollangle = gi.cvar("sv_rollangle", "2", 0); + sv_maxvelocity = gi.cvar("sv_maxvelocity", "2000", 0); + sv_gravity = gi.cvar("sv_gravity", "800", 0); + + /* noset vars */ + dedicated = gi.cvar("dedicated", "0", CVAR_NOSET); + + /* latched vars */ + sv_cheats = gi.cvar("cheats", "0", CVAR_SERVERINFO | CVAR_LATCH); + gi.cvar("gamename", GAMEVERSION, CVAR_SERVERINFO | CVAR_LATCH); + gi.cvar("gamedate", __DATE__, CVAR_SERVERINFO | CVAR_LATCH); + maxclients = gi.cvar("maxclients", "4", CVAR_SERVERINFO | CVAR_LATCH); + maxspectators = gi.cvar("maxspectators", "4", CVAR_SERVERINFO); + deathmatch = gi.cvar("deathmatch", "0", CVAR_LATCH); + coop = gi.cvar("coop", "0", CVAR_LATCH); + skill = gi.cvar("skill", "1", CVAR_LATCH); + maxentities = gi.cvar("maxentities", "1024", CVAR_LATCH); + + /* change anytime vars */ + dmflags = gi.cvar("dmflags", "0", CVAR_SERVERINFO); + fraglimit = gi.cvar("fraglimit", "0", CVAR_SERVERINFO); + timelimit = gi.cvar("timelimit", "0", CVAR_SERVERINFO); + password = gi.cvar("password", "", CVAR_USERINFO); + spectator_password = gi.cvar("spectator_password", "", CVAR_USERINFO); + needpass = gi.cvar("needpass", "0", CVAR_SERVERINFO); + filterban = gi.cvar("filterban", "1", 0); + g_select_empty = gi.cvar("g_select_empty", "0", CVAR_ARCHIVE); + run_pitch = gi.cvar("run_pitch", "0.002", 0); + run_roll = gi.cvar("run_roll", "0.005", 0); + bob_up = gi.cvar("bob_up", "0.005", 0); + bob_pitch = gi.cvar("bob_pitch", "0.002", 0); + bob_roll = gi.cvar("bob_roll", "0.002", 0); + + /* flood control */ + flood_msgs = gi.cvar("flood_msgs", "4", 0); + flood_persecond = gi.cvar("flood_persecond", "4", 0); + flood_waitdelay = gi.cvar("flood_waitdelay", "10", 0); + + /* dm map list */ + sv_maplist = gi.cvar("sv_maplist", "", 0); + + /* items */ + InitItems(); + + Com_sprintf(game.helpmessage1, sizeof(game.helpmessage1), ""); + Com_sprintf(game.helpmessage2, sizeof(game.helpmessage2), ""); + + /* initialize all entities for this game */ + game.maxentities = maxentities->value; + g_edicts = gi.TagMalloc(game.maxentities * sizeof(g_edicts[0]), TAG_GAME); + globals.edicts = g_edicts; + globals.max_edicts = game.maxentities; + + /* initialize all clients for this game */ + game.maxclients = maxclients->value; + game.clients = gi.TagMalloc(game.maxclients * sizeof(game.clients[0]), TAG_GAME); + globals.num_edicts = game.maxclients + 1; +} + +/* ========================================================= */ + +/* + * Helper function to get + * the human readable function + * definition by an address. + * Called by WriteField1 and + * WriteField2. + */ +functionList_t * +GetFunctionByAddress(byte *adr) +{ + int i; + + for (i = 0; functionList[i].funcStr; i++) + { + if (functionList[i].funcPtr == adr) + { + return &functionList[i]; + } + } + + return NULL; +} + +/* + * Helper function to get the + * pointer to a function by + * it's human readable name. + * Called by WriteField1 and + * WriteField2. + */ +byte * +FindFunctionByName(char *name) +{ + int i; + + for (i = 0; functionList[i].funcStr; i++) + { + if (!strcmp(name, functionList[i].funcStr)) + { + return functionList[i].funcPtr; + } + } + + return NULL; +} + +/* + * Helper function to get the + * human readable definition of + * a mmove_t struct by a pointer. + */ +mmoveList_t * +GetMmoveByAddress(mmove_t *adr) +{ + int i; + + for (i = 0; mmoveList[i].mmoveStr; i++) + { + if (mmoveList[i].mmovePtr == adr) + { + return &mmoveList[i]; + } + } + + return NULL; +} + +/* + * Helper function to get the + * pointer to a mmove_t struct + * by a human readable definition. + */ +mmove_t * +FindMmoveByName(char *name) +{ + int i; + + for (i = 0; mmoveList[i].mmoveStr; i++) + { + if (!strcmp(name, mmoveList[i].mmoveStr)) + { + return mmoveList[i].mmovePtr; + } + } + + return NULL; +} + + +/* ========================================================= */ + +/* + * The following two functions are + * doing the dirty work to write the + * data generated by the functions + * below this block into files. + */ +void +WriteField1(FILE *f, field_t *field, byte *base) +{ + void *p; + int len; + int index; + functionList_t *func; + mmoveList_t *mmove; + + if (field->flags & FFL_SPAWNTEMP) + { + return; + } + + p = (void *)(base + field->ofs); + + switch (field->type) + { + case F_INT: + case F_FLOAT: + case F_ANGLEHACK: + case F_VECTOR: + case F_IGNORE: + break; + + case F_LSTRING: + case F_GSTRING: + + if (*(char **)p) + { + len = strlen(*(char **)p) + 1; + } + else + { + len = 0; + } + + *(int *)p = len; + break; + case F_EDICT: + + if (*(edict_t **)p == NULL) + { + index = -1; + } + else + { + index = *(edict_t **)p - g_edicts; + } + + *(int *)p = index; + break; + case F_CLIENT: + + if (*(gclient_t **)p == NULL) + { + index = -1; + } + else + { + index = *(gclient_t **)p - game.clients; + } + + *(int *)p = index; + break; + case F_ITEM: + + if (*(edict_t **)p == NULL) + { + index = -1; + } + else + { + index = *(gitem_t **)p - itemlist; + } + + *(int *)p = index; + break; + case F_FUNCTION: + + if (*(byte **)p == NULL) + { + len = 0; + } + else + { + func = GetFunctionByAddress (*(byte **)p); + + if (!func) + { + gi.error ("WriteField1: function not in list, can't save game"); + } + + len = strlen(func->funcStr)+1; + } + + *(int *)p = len; + break; + case F_MMOVE: + + if (*(byte **)p == NULL) + { + len = 0; + } + else + { + mmove = GetMmoveByAddress (*(mmove_t **)p); + + if (!mmove) + { + gi.error ("WriteField1: mmove not in list, can't save game"); + } + + len = strlen(mmove->mmoveStr)+1; + } + + *(int *)p = len; + break; + default: + gi.error("WriteEdict: unknown field type"); + } +} + +void +WriteField2(FILE *f, field_t *field, byte *base) +{ + int len; + void *p; + functionList_t *func; + mmoveList_t *mmove; + + if (field->flags & FFL_SPAWNTEMP) + { + return; + } + + p = (void *)(base + field->ofs); + + switch (field->type) + { + case F_LSTRING: + + if (*(char **)p) + { + len = strlen(*(char **)p) + 1; + fwrite(*(char **)p, len, 1, f); + } + + break; + case F_FUNCTION: + + if (*(byte **)p) + { + func = GetFunctionByAddress (*(byte **)p); + + if (!func) + { + gi.error ("WriteField2: function not in list, can't save game"); + } + + len = strlen(func->funcStr)+1; + fwrite (func->funcStr, len, 1, f); + } + + break; + case F_MMOVE: + + if (*(byte **)p) + { + mmove = GetMmoveByAddress (*(mmove_t **)p); + if (!mmove) + { + gi.error ("WriteField2: mmove not in list, can't save game"); + } + + len = strlen(mmove->mmoveStr)+1; + fwrite (mmove->mmoveStr, len, 1, f); + } + + break; + default: + break; + } +} + +/* ========================================================= */ + +/* + * This function does the dirty + * work to read the data from a + * file. The processing of the + * data is done in the functions + * below + */ +void +ReadField(FILE *f, field_t *field, byte *base) +{ + void *p; + int len; + int index; + char funcStr[2048]; + + if (field->flags & FFL_SPAWNTEMP) + { + return; + } + + p = (void *)(base + field->ofs); + + switch (field->type) + { + case F_INT: + case F_FLOAT: + case F_ANGLEHACK: + case F_VECTOR: + case F_IGNORE: + break; + + case F_LSTRING: + len = *(int *)p; + + if (!len) + { + *(char **)p = NULL; + } + else + { + *(char **)p = gi.TagMalloc(32 + len, TAG_LEVEL); + fread(*(char **)p, len, 1, f); + } + + break; + case F_EDICT: + index = *(int *)p; + + if (index == -1) + { + *(edict_t **)p = NULL; + } + else + { + *(edict_t **)p = &g_edicts[index]; + } + + break; + case F_CLIENT: + index = *(int *)p; + + if (index == -1) + { + *(gclient_t **)p = NULL; + } + else + { + *(gclient_t **)p = &game.clients[index]; + } + + break; + case F_ITEM: + index = *(int *)p; + + if (index == -1) + { + *(gitem_t **)p = NULL; + } + else + { + *(gitem_t **)p = &itemlist[index]; + } + + break; + case F_FUNCTION: + len = *(int *)p; + + if (!len) + { + *(byte **)p = NULL; + } + else + { + if (len > sizeof(funcStr)) + { + gi.error ("ReadField: function name is longer than buffer (%i chars)", + sizeof(funcStr)); + } + + fread (funcStr, len, 1, f); + + if ( !(*(byte **)p = FindFunctionByName (funcStr)) ) + { + gi.error ("ReadField: function %s not found in table, can't load game", funcStr); + } + + } + break; + case F_MMOVE: + len = *(int *)p; + + if (!len) + { + *(byte **)p = NULL; + } + else + { + if (len > sizeof(funcStr)) + { + gi.error ("ReadField: mmove name is longer than buffer (%i chars)", + sizeof(funcStr)); + } + + fread (funcStr, len, 1, f); + + if ( !(*(mmove_t **)p = FindMmoveByName (funcStr)) ) + { + gi.error ("ReadField: mmove %s not found in table, can't load game", funcStr); + } + } + break; + + default: + gi.error("ReadEdict: unknown field type"); + } +} + +/* ========================================================= */ + +/* + * Write the client struct into a file. + */ +void +WriteClient(FILE *f, gclient_t *client) +{ + field_t *field; + gclient_t temp; + + /* all of the ints, floats, and vectors stay as they are */ + temp = *client; + + /* change the pointers to indexes */ + for (field = clientfields; field->name; field++) + { + WriteField1(f, field, (byte *)&temp); + } + + /* write the block */ + fwrite(&temp, sizeof(temp), 1, f); + + /* now write any allocated data following the edict */ + for (field = clientfields; field->name; field++) + { + WriteField2(f, field, (byte *)client); + } +} + +/* + * Read the client struct from a file + */ +void +ReadClient(FILE *f, gclient_t *client) +{ + field_t *field; + + fread(client, sizeof(*client), 1, f); + + for (field = clientfields; field->name; field++) + { + ReadField(f, field, (byte *)client); + } +} + +/* ========================================================= */ + +/* + * Writes the game struct into + * a file. This is called when + * ever the games goes to e new + * level or the user saves the + * game. Saved informations are: + * - cross level data + * - client states + * - help computer info + */ +void +WriteGame(const char *filename, qboolean autosave) +{ + FILE *f; + int i; + char str_ver[32]; + char str_os[32]; + char str_arch[32]; + + if (!autosave) + { + SaveClientData(); + } + + f = fopen(filename, "wb"); + + if (!f) + { + gi.error("Couldn't open %s", filename); + } + + /* Savegame identification */ + memset(str_ver, 0, sizeof(str_ver)); + memset(str_os, 0, sizeof(str_os)); + memset(str_arch, 0, sizeof(str_arch)); + + strncpy(str_ver, SAVEGAMEVER, sizeof(str_ver)); + strncpy(str_os, OS, sizeof(str_os)); + strncpy(str_arch, ARCH, sizeof(str_arch)); + + fwrite(str_ver, sizeof(str_ver), 1, f); + fwrite(str_os, sizeof(str_os), 1, f); + fwrite(str_arch, sizeof(str_arch), 1, f); + + game.autosaved = autosave; + fwrite(&game, sizeof(game), 1, f); + game.autosaved = false; + + for (i = 0; i < game.maxclients; i++) + { + WriteClient(f, &game.clients[i]); + } + + fclose(f); +} + +/* + * Read the game structs from + * a file. Called when ever a + * savegames is loaded. + */ +void +ReadGame(const char *filename) +{ + FILE *f; + int i; + char str_ver[32]; + char str_os[32]; + char str_arch[32]; + + gi.FreeTags(TAG_GAME); + + f = fopen(filename, "rb"); + + if (!f) + { + gi.error("Couldn't open %s", filename); + } + + /* Sanity checks */ + fread(str_ver, sizeof(str_ver), 1, f); + fread(str_os, sizeof(str_os), 1, f); + fread(str_arch, sizeof(str_arch), 1, f); + + if (strcmp(str_ver, SAVEGAMEVER)) + { + fclose(f); + gi.error("Savegame from an incompatible version.\n"); + } + else if (strcmp(str_os, OS)) + { + fclose(f); + gi.error("Savegame from an other os.\n"); + } + else if (strcmp(str_arch, ARCH)) + { + fclose(f); + gi.error("Savegame from an other architecure.\n"); + } + + g_edicts = gi.TagMalloc(game.maxentities * sizeof(g_edicts[0]), TAG_GAME); + globals.edicts = g_edicts; + + fread(&game, sizeof(game), 1, f); + game.clients = gi.TagMalloc(game.maxclients * sizeof(game.clients[0]), + TAG_GAME); + + for (i = 0; i < game.maxclients; i++) + { + ReadClient(f, &game.clients[i]); + } + + fclose(f); +} + +/* ========================================================== */ + +/* + * Helper function to write the + * edict into a file. Called by + * WriteLevel. + */ +void +WriteEdict(FILE *f, edict_t *ent) +{ + field_t *field; + edict_t temp; + + /* all of the ints, floats, and vectors stay as they are */ + temp = *ent; + + /* change the pointers to lengths or indexes */ + for (field = fields; field->name; field++) + { + WriteField1(f, field, (byte *)&temp); + } + + /* write the block */ + fwrite(&temp, sizeof(temp), 1, f); + + /* now write any allocated data following the edict */ + for (field = fields; field->name; field++) + { + WriteField2(f, field, (byte *)ent); + } +} + +/* + * Helper fcuntion to write the + * level local data into a file. + * Called by WriteLevel. + */ +void +WriteLevelLocals(FILE *f) +{ + field_t *field; + level_locals_t temp; + + /* all of the ints, floats, and vectors stay as they are */ + temp = level; + + /* change the pointers to lengths or indexes */ + for (field = levelfields; field->name; field++) + { + WriteField1(f, field, (byte *)&temp); + } + + /* write the block */ + fwrite(&temp, sizeof(temp), 1, f); + + /* now write any allocated data following the edict */ + for (field = levelfields; field->name; field++) + { + WriteField2(f, field, (byte *)&level); + } +} + +/* + * Writes the current level + * into a file. + */ +void +WriteLevel(const char *filename) +{ + int i; + edict_t *ent; + FILE *f; + void *base; + + f = fopen(filename, "wb"); + + if (!f) + { + gi.error("Couldn't open %s", filename); + } + + /* write out edict size for checking */ + i = sizeof(edict_t); + fwrite(&i, sizeof(i), 1, f); + + /* write out level_locals_t */ + WriteLevelLocals(f); + + /* write out all the entities */ + for (i = 0; i < globals.num_edicts; i++) + { + ent = &g_edicts[i]; + + if (!ent->inuse) + { + continue; + } + + fwrite(&i, sizeof(i), 1, f); + WriteEdict(f, ent); + } + + i = -1; + fwrite(&i, sizeof(i), 1, f); + + fclose(f); +} + +/* ========================================================== */ + +/* + * A helper function to + * read the edict back + * into the memory. Called + * by ReadLevel. + */ +void +ReadEdict(FILE *f, edict_t *ent) +{ + field_t *field; + + fread(ent, sizeof(*ent), 1, f); + + for (field = fields; field->name; field++) + { + ReadField(f, field, (byte *)ent); + } +} + +/* + * A helper function to + * read the level local + * data from a file. + * Called by ReadLevel. + */ +void +ReadLevelLocals(FILE *f) +{ + field_t *field; + + fread(&level, sizeof(level), 1, f); + + for (field = levelfields; field->name; field++) + { + ReadField(f, field, (byte *)&level); + } +} + +/* + * Reads a level back into the memory. + * SpawnEntities were allready called + * in the same way when the level was + * saved. All world links were cleared + * befor this function was called. When + * this function is called, no clients + * are connected to the server. + */ +void +ReadLevel(const char *filename) +{ + int entnum; + FILE *f; + int i; + void *base; + edict_t *ent; + + f = fopen(filename, "rb"); + + if (!f) + { + gi.error("Couldn't open %s", filename); + } + + /* free any dynamic memory allocated by + loading the level base state */ + gi.FreeTags(TAG_LEVEL); + + /* wipe all the entities */ + memset(g_edicts, 0, game.maxentities * sizeof(g_edicts[0])); + globals.num_edicts = maxclients->value + 1; + + /* check edict size */ + fread(&i, sizeof(i), 1, f); + + if (i != sizeof(edict_t)) + { + fclose(f); + gi.error("ReadLevel: mismatched edict size"); + } + + /* load the level locals */ + ReadLevelLocals(f); + + /* load all the entities */ + while (1) + { + if (fread(&entnum, sizeof(entnum), 1, f) != 1) + { + fclose(f); + gi.error("ReadLevel: failed to read entnum"); + } + + if (entnum == -1) + { + break; + } + + if (entnum >= globals.num_edicts) + { + globals.num_edicts = entnum + 1; + } + + ent = &g_edicts[entnum]; + ReadEdict(f, ent); + + /* let the server rebuild world links for this ent */ + memset(&ent->area, 0, sizeof(ent->area)); + gi.linkentity(ent); + } + + fclose(f); + + /* mark all clients as unconnected */ + for (i = 0; i < maxclients->value; i++) + { + ent = &g_edicts[i + 1]; + ent->client = game.clients + i; + ent->client->pers.connected = false; + } + + /* do any load time things at this point */ + for (i = 0; i < globals.num_edicts; i++) + { + ent = &g_edicts[i]; + + if (!ent->inuse) + { + continue; + } + + /* fire any cross-level triggers */ + if (ent->classname) + { + if (strcmp(ent->classname, "target_crosslevel_target") == 0) + { + ent->nextthink = level.time + ent->delay; + } + } + } +} + diff --git a/src/game/baseq2/savegame/tables/clientfields.h b/src/game/baseq2/savegame/tables/clientfields.h new file mode 100644 index 00000000..c7d8debe --- /dev/null +++ b/src/game/baseq2/savegame/tables/clientfields.h @@ -0,0 +1,4 @@ +{"pers.weapon", CLOFS(pers.weapon), F_ITEM}, +{"pers.lastweapon", CLOFS(pers.lastweapon), F_ITEM}, +{"newweapon", CLOFS(newweapon), F_ITEM}, +{NULL, 0, F_INT} diff --git a/src/game/baseq2/savegame/tables/fields.h b/src/game/baseq2/savegame/tables/fields.h new file mode 100644 index 00000000..7b684d49 --- /dev/null +++ b/src/game/baseq2/savegame/tables/fields.h @@ -0,0 +1,81 @@ +{"classname", FOFS(classname), F_LSTRING}, +{"model", FOFS(model), F_LSTRING}, +{"spawnflags", FOFS(spawnflags), F_INT}, +{"speed", FOFS(speed), F_FLOAT}, +{"accel", FOFS(accel), F_FLOAT}, +{"decel", FOFS(decel), F_FLOAT}, +{"target", FOFS(target), F_LSTRING}, +{"targetname", FOFS(targetname), F_LSTRING}, +{"pathtarget", FOFS(pathtarget), F_LSTRING}, +{"deathtarget", FOFS(deathtarget), F_LSTRING}, +{"killtarget", FOFS(killtarget), F_LSTRING}, +{"combattarget", FOFS(combattarget), F_LSTRING}, +{"message", FOFS(message), F_LSTRING}, +{"team", FOFS(team), F_LSTRING}, +{"wait", FOFS(wait), F_FLOAT}, +{"delay", FOFS(delay), F_FLOAT}, +{"random", FOFS(random), F_FLOAT}, +{"move_origin", FOFS(move_origin), F_VECTOR}, +{"move_angles", FOFS(move_angles), F_VECTOR}, +{"style", FOFS(style), F_INT}, +{"count", FOFS(count), F_INT}, +{"health", FOFS(health), F_INT}, +{"sounds", FOFS(sounds), F_INT}, +{"light", 0, F_IGNORE}, +{"dmg", FOFS(dmg), F_INT}, +{"mass", FOFS(mass), F_INT}, +{"volume", FOFS(volume), F_FLOAT}, +{"attenuation", FOFS(attenuation), F_FLOAT}, +{"map", FOFS(map), F_LSTRING}, +{"origin", FOFS(s.origin), F_VECTOR}, +{"angles", FOFS(s.angles), F_VECTOR}, +{"angle", FOFS(s.angles), F_ANGLEHACK}, +{"goalentity", FOFS(goalentity), F_EDICT, FFL_NOSPAWN}, +{"movetarget", FOFS(movetarget), F_EDICT, FFL_NOSPAWN}, +{"enemy", FOFS(enemy), F_EDICT, FFL_NOSPAWN}, +{"oldenemy", FOFS(oldenemy), F_EDICT, FFL_NOSPAWN}, +{"activator", FOFS(activator), F_EDICT, FFL_NOSPAWN}, +{"groundentity", FOFS(groundentity), F_EDICT, FFL_NOSPAWN}, +{"teamchain", FOFS(teamchain), F_EDICT, FFL_NOSPAWN}, +{"teammaster", FOFS(teammaster), F_EDICT, FFL_NOSPAWN}, +{"owner", FOFS(owner), F_EDICT, FFL_NOSPAWN}, +{"mynoise", FOFS(mynoise), F_EDICT, FFL_NOSPAWN}, +{"mynoise2", FOFS(mynoise2), F_EDICT, FFL_NOSPAWN}, +{"target_ent", FOFS(target_ent), F_EDICT, FFL_NOSPAWN}, +{"chain", FOFS(chain), F_EDICT, FFL_NOSPAWN}, +{"prethink", FOFS(prethink), F_FUNCTION, FFL_NOSPAWN}, +{"think", FOFS(think), F_FUNCTION, FFL_NOSPAWN}, +{"blocked", FOFS(blocked), F_FUNCTION, FFL_NOSPAWN}, +{"touch", FOFS(touch), F_FUNCTION, FFL_NOSPAWN}, +{"use", FOFS(use), F_FUNCTION, FFL_NOSPAWN}, +{"pain", FOFS(pain), F_FUNCTION, FFL_NOSPAWN}, +{"die", FOFS(die), F_FUNCTION, FFL_NOSPAWN}, +{"stand", FOFS(monsterinfo.stand), F_FUNCTION, FFL_NOSPAWN}, +{"idle", FOFS(monsterinfo.idle), F_FUNCTION, FFL_NOSPAWN}, +{"search", FOFS(monsterinfo.search), F_FUNCTION, FFL_NOSPAWN}, +{"walk", FOFS(monsterinfo.walk), F_FUNCTION, FFL_NOSPAWN}, +{"run", FOFS(monsterinfo.run), F_FUNCTION, FFL_NOSPAWN}, +{"dodge", FOFS(monsterinfo.dodge), F_FUNCTION, FFL_NOSPAWN}, +{"attack", FOFS(monsterinfo.attack), F_FUNCTION, FFL_NOSPAWN}, +{"melee", FOFS(monsterinfo.melee), F_FUNCTION, FFL_NOSPAWN}, +{"sight", FOFS(monsterinfo.sight), F_FUNCTION, FFL_NOSPAWN}, +{"checkattack", FOFS(monsterinfo.checkattack), F_FUNCTION, FFL_NOSPAWN}, +{"currentmove", FOFS(monsterinfo.currentmove), F_MMOVE, FFL_NOSPAWN}, +{"endfunc", FOFS(moveinfo.endfunc), F_FUNCTION, FFL_NOSPAWN}, +{"lip", STOFS(lip), F_INT, FFL_SPAWNTEMP}, +{"distance", STOFS(distance), F_INT, FFL_SPAWNTEMP}, +{"height", STOFS(height), F_INT, FFL_SPAWNTEMP}, +{"noise", STOFS(noise), F_LSTRING, FFL_SPAWNTEMP}, +{"pausetime", STOFS(pausetime), F_FLOAT, FFL_SPAWNTEMP}, +{"item", STOFS(item), F_LSTRING, FFL_SPAWNTEMP}, +{"item", FOFS(item), F_ITEM}, +{"gravity", STOFS(gravity), F_LSTRING, FFL_SPAWNTEMP}, +{"sky", STOFS(sky), F_LSTRING, FFL_SPAWNTEMP}, +{"skyrotate", STOFS(skyrotate), F_FLOAT, FFL_SPAWNTEMP}, +{"skyaxis", STOFS(skyaxis), F_VECTOR, FFL_SPAWNTEMP}, +{"minyaw", STOFS(minyaw), F_FLOAT, FFL_SPAWNTEMP}, +{"maxyaw", STOFS(maxyaw), F_FLOAT, FFL_SPAWNTEMP}, +{"minpitch", STOFS(minpitch), F_FLOAT, FFL_SPAWNTEMP}, +{"maxpitch", STOFS(maxpitch), F_FLOAT, FFL_SPAWNTEMP}, +{"nextmap", STOFS(nextmap), F_LSTRING, FFL_SPAWNTEMP}, +{0, 0, 0, 0} diff --git a/src/game/baseq2/savegame/tables/gamefunc_decs.h b/src/game/baseq2/savegame/tables/gamefunc_decs.h new file mode 100644 index 00000000..fa060c37 --- /dev/null +++ b/src/game/baseq2/savegame/tables/gamefunc_decs.h @@ -0,0 +1,1028 @@ +extern void ReadLevel ( const char * filename ) ; +extern void ReadLevelLocals ( FILE * f ) ; +extern void ReadEdict ( FILE * f , edict_t * ent ) ; +extern void WriteLevel ( const char * filename ) ; +extern void WriteLevelLocals ( FILE * f ) ; +extern void WriteEdict ( FILE * f , edict_t * ent ) ; +extern void ReadGame ( const char * filename ) ; +extern void WriteGame ( const char * filename , qboolean autosave ) ; +extern void ReadClient ( FILE * f , gclient_t * client ) ; +extern void WriteClient ( FILE * f , gclient_t * client ) ; +extern void ReadField ( FILE * f , field_t * field , byte * base ) ; +extern void WriteField2 ( FILE * f , field_t * field , byte * base ) ; +extern void WriteField1 ( FILE * f , field_t * field , byte * base ) ; +extern void InitGame ( void ) ; +extern void Info_SetValueForKey ( char * s , char * key , char * value ) ; +extern qboolean Info_Validate ( char * s ) ; +extern void Info_RemoveKey ( char * s , char * key ) ; +extern char * Info_ValueForKey ( char * s , char * key ) ; +extern void Com_sprintf ( char * dest , int size , char * fmt , ... ) ; +extern int Q_strcasecmp ( char * s1 , char * s2 ) ; +extern int Q_strncasecmp ( char * s1 , char * s2 , int n ) ; +extern int Q_stricmp ( const char * s1 , const char * s2 ) ; +extern void Com_PageInMemory ( byte * buffer , int size ) ; +extern char * COM_Parse ( char * * data_p ) ; +extern char * va ( char * format , ... ) ; +extern void Swap_Init ( void ) ; +extern float FloatNoSwap ( float f ) ; +extern float FloatSwap ( float f ) ; +extern int LongNoSwap ( int l ) ; +extern int LongSwap ( int l ) ; +extern short ShortNoSwap ( short l ) ; +extern short ShortSwap ( short l ) ; +extern float LittleFloat ( float l ) ; +extern float BigFloat ( float l ) ; +extern int LittleLong ( int l ) ; +extern int BigLong ( int l ) ; +extern short LittleShort ( short l ) ; +extern short BigShort ( short l ) ; +extern void COM_DefaultExtension ( char * path , const char * extension ) ; +extern void COM_FilePath ( const char * in , char * out ) ; +extern void COM_FileBase ( char * in , char * out ) ; +extern char * COM_FileExtension ( char * in ) ; +extern void COM_StripExtension ( char * in , char * out ) ; +extern char * COM_SkipPath ( char * pathname ) ; +extern int Q_log2 ( int val ) ; +extern void VectorScale ( vec3_t in , vec_t scale , vec3_t out ) ; +extern void VectorInverse ( vec3_t v ) ; +extern vec_t VectorLength ( vec3_t v ) ; +extern void CrossProduct ( vec3_t v1 , vec3_t v2 , vec3_t cross ) ; +extern void _VectorCopy ( vec3_t in , vec3_t out ) ; +extern void _VectorAdd ( vec3_t veca , vec3_t vecb , vec3_t out ) ; +extern void _VectorSubtract ( vec3_t veca , vec3_t vecb , vec3_t out ) ; +extern vec_t _DotProduct ( vec3_t v1 , vec3_t v2 ) ; +extern void VectorMA ( vec3_t veca , float scale , vec3_t vecb , vec3_t vecc ) ; +extern vec_t VectorNormalize2 ( vec3_t v , vec3_t out ) ; +extern vec_t VectorNormalize ( vec3_t v ) ; +extern int VectorCompare ( vec3_t v1 , vec3_t v2 ) ; +extern void AddPointToBounds ( vec3_t v , vec3_t mins , vec3_t maxs ) ; +extern void ClearBounds ( vec3_t mins , vec3_t maxs ) ; +extern int BoxOnPlaneSide2 ( vec3_t emins , vec3_t emaxs , struct cplane_s * p ) ; +extern float anglemod ( float a ) ; +extern float LerpAngle ( float a2 , float a1 , float frac ) ; +extern float Q_fabs ( float f ) ; +extern void R_ConcatTransforms ( float in1 [ 3 ] [ 4 ] , float in2 [ 3 ] [ 4 ] , float out [ 3 ] [ 4 ] ) ; +extern void R_ConcatRotations ( float in1 [ 3 ] [ 3 ] , float in2 [ 3 ] [ 3 ] , float out [ 3 ] [ 3 ] ) ; +extern void PerpendicularVector ( vec3_t dst , const vec3_t src ) ; +extern void ProjectPointOnPlane ( vec3_t dst , const vec3_t p , const vec3_t normal ) ; +extern void AngleVectors2 ( vec3_t value1 , vec3_t angles ) ; +extern void AngleVectors ( vec3_t angles , vec3_t forward , vec3_t right , vec3_t up ) ; +extern void RotatePointAroundVector ( vec3_t dst , const vec3_t dir , const vec3_t point , float degrees ) ; +extern void Weapon_BFG ( edict_t * ent ) ; +extern void weapon_bfg_fire ( edict_t * ent ) ; +extern void Weapon_Railgun ( edict_t * ent ) ; +extern void weapon_railgun_fire ( edict_t * ent ) ; +extern void Weapon_SuperShotgun ( edict_t * ent ) ; +extern void weapon_supershotgun_fire ( edict_t * ent ) ; +extern void Weapon_Shotgun ( edict_t * ent ) ; +extern void weapon_shotgun_fire ( edict_t * ent ) ; +extern void Weapon_Chaingun ( edict_t * ent ) ; +extern void Chaingun_Fire ( edict_t * ent ) ; +extern void Weapon_Machinegun ( edict_t * ent ) ; +extern void Machinegun_Fire ( edict_t * ent ) ; +extern void Weapon_HyperBlaster ( edict_t * ent ) ; +extern void Weapon_HyperBlaster_Fire ( edict_t * ent ) ; +extern void Weapon_Blaster ( edict_t * ent ) ; +extern void Weapon_Blaster_Fire ( edict_t * ent ) ; +extern void Blaster_Fire ( edict_t * ent , vec3_t g_offset , int damage , qboolean hyper , int effect ) ; +extern void Weapon_RocketLauncher ( edict_t * ent ) ; +extern void Weapon_RocketLauncher_Fire ( edict_t * ent ) ; +extern void Weapon_GrenadeLauncher ( edict_t * ent ) ; +extern void weapon_grenadelauncher_fire ( edict_t * ent ) ; +extern void Weapon_Grenade ( edict_t * ent ) ; +extern void weapon_grenade_fire ( edict_t * ent , qboolean held ) ; +extern void Weapon_Generic ( edict_t * ent , int FRAME_ACTIVATE_LAST , int FRAME_FIRE_LAST , int FRAME_IDLE_LAST , int FRAME_DEACTIVATE_LAST , int * pause_frames , int * fire_frames , void ( * fire ) ( edict_t * ent ) ) ; +extern void Drop_Weapon ( edict_t * ent , gitem_t * item ) ; +extern void Use_Weapon ( edict_t * ent , gitem_t * item ) ; +extern void Think_Weapon ( edict_t * ent ) ; +extern void NoAmmoWeaponChange ( edict_t * ent ) ; +extern void ChangeWeapon ( edict_t * ent ) ; +extern qboolean Pickup_Weapon ( edict_t * ent , edict_t * other ) ; +extern void PlayerNoise ( edict_t * who , vec3_t where , int type ) ; +extern void P_ProjectSource ( gclient_t * client , vec3_t point , vec3_t distance , vec3_t forward , vec3_t right , vec3_t result ) ; +extern void ClientEndServerFrame ( edict_t * ent ) ; +extern void G_SetClientFrame ( edict_t * ent ) ; +extern void G_SetClientSound ( edict_t * ent ) ; +extern void G_SetClientEvent ( edict_t * ent ) ; +extern void G_SetClientEffects ( edict_t * ent ) ; +extern void P_WorldEffects ( void ) ; +extern void P_FallingDamage ( edict_t * ent ) ; +extern void SV_CalcBlend ( edict_t * ent ) ; +extern void SV_AddBlend ( float r , float g , float b , float a , float * v_blend ) ; +extern void SV_CalcGunOffset ( edict_t * ent ) ; +extern void SV_CalcViewOffset ( edict_t * ent ) ; +extern void P_DamageFeedback ( edict_t * player ) ; +extern float SV_CalcRoll ( vec3_t angles , vec3_t velocity ) ; +extern edict_t * PlayerTrail_LastSpot ( void ) ; +extern edict_t * PlayerTrail_PickNext ( edict_t * self ) ; +extern edict_t * PlayerTrail_PickFirst ( edict_t * self ) ; +extern void PlayerTrail_New ( vec3_t spot ) ; +extern void PlayerTrail_Add ( vec3_t spot ) ; +extern void PlayerTrail_Init ( void ) ; +extern void G_SetSpectatorStats ( edict_t * ent ) ; +extern void G_CheckChaseStats ( edict_t * ent ) ; +extern void G_SetStats ( edict_t * ent ) ; +extern void Cmd_Help_f ( edict_t * ent ) ; +extern void HelpComputer ( edict_t * ent ) ; +extern void Cmd_Score_f ( edict_t * ent ) ; +extern void DeathmatchScoreboard ( edict_t * ent ) ; +extern void DeathmatchScoreboardMessage ( edict_t * ent , edict_t * killer ) ; +extern void BeginIntermission ( edict_t * targ ) ; +extern void MoveClientToIntermission ( edict_t * ent ) ; +extern void ClientBeginServerFrame ( edict_t * ent ) ; +extern void ClientThink ( edict_t * ent , usercmd_t * ucmd ) ; +extern void PrintPmove ( pmove_t * pm ) ; +extern unsigned CheckBlock ( void * b , int c ) ; +extern trace_t PM_trace ( vec3_t start , vec3_t mins , vec3_t maxs , vec3_t end ) ; +extern void ClientDisconnect ( edict_t * ent ) ; +extern qboolean ClientConnect ( edict_t * ent , char * userinfo ) ; +extern void ClientUserinfoChanged ( edict_t * ent , char * userinfo ) ; +extern void ClientBegin ( edict_t * ent ) ; +extern void ClientBeginDeathmatch ( edict_t * ent ) ; +extern void PutClientInServer ( edict_t * ent ) ; +extern void spectator_respawn ( edict_t * ent ) ; +extern void respawn ( edict_t * self ) ; +extern void CopyToBodyQue ( edict_t * ent ) ; +extern void body_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void InitBodyQue ( void ) ; +extern void SelectSpawnPoint ( edict_t * ent , vec3_t origin , vec3_t angles ) ; +extern edict_t * SelectCoopSpawnPoint ( edict_t * ent ) ; +extern edict_t * SelectDeathmatchSpawnPoint ( void ) ; +extern edict_t * SelectFarthestDeathmatchSpawnPoint ( void ) ; +extern edict_t * SelectRandomDeathmatchSpawnPoint ( void ) ; +extern float PlayersRangeFromSpot ( edict_t * spot ) ; +extern void FetchClientEntData ( edict_t * ent ) ; +extern void SaveClientData ( void ) ; +extern void InitClientResp ( gclient_t * client ) ; +extern void InitClientPersistant ( gclient_t * client ) ; +extern void player_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void LookAtKiller ( edict_t * self , edict_t * inflictor , edict_t * attacker ) ; +extern void TossClientWeapon ( edict_t * self ) ; +extern void ClientObituary ( edict_t * self , edict_t * inflictor , edict_t * attacker ) ; +extern qboolean IsNeutral ( edict_t * ent ) ; +extern qboolean IsFemale ( edict_t * ent ) ; +extern void player_pain ( edict_t * self , edict_t * other , float kick , int damage ) ; +extern void SP_info_player_intermission ( void ) ; +extern void SP_info_player_coop ( edict_t * self ) ; +extern void SP_info_player_deathmatch ( edict_t * self ) ; +extern void SP_info_player_start ( edict_t * self ) ; +extern void SP_CreateCoopSpots ( edict_t * self ) ; +extern void SP_FixCoopSpots ( edict_t * self ) ; +extern void SP_monster_tank ( edict_t * self ) ; +extern void tank_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void tank_dead ( edict_t * self ) ; +extern void tank_attack ( edict_t * self ) ; +extern void tank_doattack_rocket ( edict_t * self ) ; +extern void tank_refire_rocket ( edict_t * self ) ; +extern void tank_poststrike ( edict_t * self ) ; +extern void tank_reattack_blaster ( edict_t * self ) ; +extern void TankMachineGun ( edict_t * self ) ; +extern void TankRocket ( edict_t * self ) ; +extern void TankStrike ( edict_t * self ) ; +extern void TankBlaster ( edict_t * self ) ; +extern void tank_pain ( edict_t * self , edict_t * other , float kick , int damage ) ; +extern void tank_run ( edict_t * self ) ; +extern void tank_walk ( edict_t * self ) ; +extern void tank_stand ( edict_t * self ) ; +extern void tank_idle ( edict_t * self ) ; +extern void tank_windup ( edict_t * self ) ; +extern void tank_thud ( edict_t * self ) ; +extern void tank_footstep ( edict_t * self ) ; +extern void tank_sight ( edict_t * self , edict_t * other ) ; +extern void SP_monster_supertank ( edict_t * self ) ; +extern void supertank_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void BossExplode ( edict_t * self ) ; +extern void supertank_dead ( edict_t * self ) ; +extern void supertank_attack ( edict_t * self ) ; +extern void supertankMachineGun ( edict_t * self ) ; +extern void supertankRocket ( edict_t * self ) ; +extern void supertank_pain ( edict_t * self , edict_t * other , float kick , int damage ) ; +extern void supertank_reattack1 ( edict_t * self ) ; +extern void supertank_run ( edict_t * self ) ; +extern void supertank_walk ( edict_t * self ) ; +extern void supertank_forward ( edict_t * self ) ; +extern void supertank_stand ( edict_t * self ) ; +extern void supertank_search ( edict_t * self ) ; +extern void TreadSound ( edict_t * self ) ; +extern void SP_monster_soldier_ss ( edict_t * self ) ; +extern void SP_monster_soldier ( edict_t * self ) ; +extern void SP_monster_soldier_light ( edict_t * self ) ; +extern void SP_monster_soldier_x ( edict_t * self ) ; +extern void soldier_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void soldier_dead ( edict_t * self ) ; +extern void soldier_fire7 ( edict_t * self ) ; +extern void soldier_fire6 ( edict_t * self ) ; +extern void soldier_dodge ( edict_t * self , edict_t * attacker , float eta ) ; +extern void soldier_duck_hold ( edict_t * self ) ; +extern void soldier_sight ( edict_t * self , edict_t * other ) ; +extern void soldier_attack ( edict_t * self ) ; +extern void soldier_attack6_refire ( edict_t * self ) ; +extern void soldier_fire8 ( edict_t * self ) ; +extern void soldier_fire4 ( edict_t * self ) ; +extern void soldier_attack3_refire ( edict_t * self ) ; +extern void soldier_fire3 ( edict_t * self ) ; +extern void soldier_duck_up ( edict_t * self ) ; +extern void soldier_duck_down ( edict_t * self ) ; +extern void soldier_attack2_refire2 ( edict_t * self ) ; +extern void soldier_attack2_refire1 ( edict_t * self ) ; +extern void soldier_fire2 ( edict_t * self ) ; +extern void soldier_attack1_refire2 ( edict_t * self ) ; +extern void soldier_attack1_refire1 ( edict_t * self ) ; +extern void soldier_fire1 ( edict_t * self ) ; +extern void soldier_fire ( edict_t * self , int flash_number ) ; +extern void soldier_pain ( edict_t * self , edict_t * other , float kick , int damage ) ; +extern void soldier_run ( edict_t * self ) ; +extern void soldier_walk ( edict_t * self ) ; +extern void soldier_walk1_random ( edict_t * self ) ; +extern void soldier_stand ( edict_t * self ) ; +extern void soldier_cock ( edict_t * self ) ; +extern void soldier_idle ( edict_t * self ) ; +extern void SP_monster_parasite ( edict_t * self ) ; +extern void parasite_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void parasite_dead ( edict_t * self ) ; +extern void parasite_attack ( edict_t * self ) ; +extern void parasite_drain_attack ( edict_t * self ) ; +extern qboolean parasite_drain_attack_ok ( vec3_t start , vec3_t end ) ; +extern void parasite_pain ( edict_t * self , edict_t * other , float kick , int damage ) ; +extern void parasite_walk ( edict_t * self ) ; +extern void parasite_start_walk ( edict_t * self ) ; +extern void parasite_run ( edict_t * self ) ; +extern void parasite_start_run ( edict_t * self ) ; +extern void parasite_stand ( edict_t * self ) ; +extern void parasite_idle ( edict_t * self ) ; +extern void parasite_refidget ( edict_t * self ) ; +extern void parasite_do_fidget ( edict_t * self ) ; +extern void parasite_end_fidget ( edict_t * self ) ; +extern void parasite_search ( edict_t * self ) ; +extern void parasite_scratch ( edict_t * self ) ; +extern void parasite_tap ( edict_t * self ) ; +extern void parasite_sight ( edict_t * self , edict_t * other ) ; +extern void parasite_reel_in ( edict_t * self ) ; +extern void parasite_launch ( edict_t * self ) ; +extern void SP_monster_mutant ( edict_t * self ) ; +extern void mutant_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void mutant_dead ( edict_t * self ) ; +extern void mutant_pain ( edict_t * self , edict_t * other , float kick , int damage ) ; +extern qboolean mutant_checkattack ( edict_t * self ) ; +extern qboolean mutant_check_jump ( edict_t * self ) ; +extern qboolean mutant_check_melee ( edict_t * self ) ; +extern void mutant_jump ( edict_t * self ) ; +extern void mutant_check_landing ( edict_t * self ) ; +extern void mutant_jump_takeoff ( edict_t * self ) ; +extern void mutant_jump_touch ( edict_t * self , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void mutant_melee ( edict_t * self ) ; +extern void mutant_check_refire ( edict_t * self ) ; +extern void mutant_hit_right ( edict_t * self ) ; +extern void mutant_hit_left ( edict_t * self ) ; +extern void mutant_run ( edict_t * self ) ; +extern void mutant_walk ( edict_t * self ) ; +extern void mutant_walk_loop ( edict_t * self ) ; +extern void mutant_idle ( edict_t * self ) ; +extern void mutant_idle_loop ( edict_t * self ) ; +extern void mutant_stand ( edict_t * self ) ; +extern void mutant_swing ( edict_t * self ) ; +extern void mutant_search ( edict_t * self ) ; +extern void mutant_sight ( edict_t * self , edict_t * other ) ; +extern void mutant_step ( edict_t * self ) ; +extern qboolean M_walkmove ( edict_t * ent , float yaw , float dist ) ; +extern void M_MoveToGoal ( edict_t * ent , float dist ) ; +extern qboolean SV_CloseEnough ( edict_t * ent , edict_t * goal , float dist ) ; +extern void SV_NewChaseDir ( edict_t * actor , edict_t * enemy , float dist ) ; +extern void SV_FixCheckBottom ( edict_t * ent ) ; +extern qboolean SV_StepDirection ( edict_t * ent , float yaw , float dist ) ; +extern void M_ChangeYaw ( edict_t * ent ) ; +extern qboolean SV_movestep ( edict_t * ent , vec3_t move , qboolean relink ) ; +extern qboolean M_CheckBottom ( edict_t * ent ) ; +extern void SP_monster_medic ( edict_t * self ) ; +extern qboolean medic_checkattack ( edict_t * self ) ; +extern void medic_attack ( edict_t * self ) ; +extern void medic_hook_retract ( edict_t * self ) ; +extern void medic_cable_attack ( edict_t * self ) ; +extern void medic_hook_launch ( edict_t * self ) ; +extern void medic_continue ( edict_t * self ) ; +extern void medic_dodge ( edict_t * self , edict_t * attacker , float eta ) ; +extern void medic_duck_up ( edict_t * self ) ; +extern void medic_duck_hold ( edict_t * self ) ; +extern void medic_duck_down ( edict_t * self ) ; +extern void medic_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void medic_dead ( edict_t * self ) ; +extern void medic_fire_blaster ( edict_t * self ) ; +extern void medic_pain ( edict_t * self , edict_t * other , float kick , int damage ) ; +extern void medic_run ( edict_t * self ) ; +extern void medic_walk ( edict_t * self ) ; +extern void medic_stand ( edict_t * self ) ; +extern void medic_sight ( edict_t * self , edict_t * other ) ; +extern void medic_search ( edict_t * self ) ; +extern void medic_idle ( edict_t * self ) ; +extern edict_t * medic_FindDeadMonster ( edict_t * self ) ; +extern void SP_misc_insane ( edict_t * self ) ; +extern void insane_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void insane_dead ( edict_t * self ) ; +extern void insane_stand ( edict_t * self ) ; +extern void insane_checkup ( edict_t * self ) ; +extern void insane_checkdown ( edict_t * self ) ; +extern void insane_onground ( edict_t * self ) ; +extern void insane_pain ( edict_t * self , edict_t * other , float kick , int damage ) ; +extern void insane_run ( edict_t * self ) ; +extern void insane_walk ( edict_t * self ) ; +extern void insane_cross ( edict_t * self ) ; +extern void insane_scream ( edict_t * self ) ; +extern void insane_moan ( edict_t * self ) ; +extern void insane_shake ( edict_t * self ) ; +extern void insane_fist ( edict_t * self ) ; +extern void SP_monster_infantry ( edict_t * self ) ; +extern void infantry_attack ( edict_t * self ) ; +extern void infantry_smack ( edict_t * self ) ; +extern void infantry_swing ( edict_t * self ) ; +extern void infantry_fire ( edict_t * self ) ; +extern void infantry_cock_gun ( edict_t * self ) ; +extern void infantry_dodge ( edict_t * self , edict_t * attacker , float eta ) ; +extern void infantry_duck_up ( edict_t * self ) ; +extern void infantry_duck_hold ( edict_t * self ) ; +extern void infantry_duck_down ( edict_t * self ) ; +extern void infantry_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void infantry_dead ( edict_t * self ) ; +extern void infantry_sight ( edict_t * self , edict_t * other ) ; +extern void InfantryMachineGun ( edict_t * self ) ; +extern void infantry_pain ( edict_t * self , edict_t * other , float kick , int damage ) ; +extern void infantry_run ( edict_t * self ) ; +extern void infantry_walk ( edict_t * self ) ; +extern void infantry_fidget ( edict_t * self ) ; +extern void infantry_stand ( edict_t * self ) ; +extern void SP_monster_hover ( edict_t * self ) ; +extern void hover_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void hover_dead ( edict_t * self ) ; +extern void hover_deadthink ( edict_t * self ) ; +extern void hover_pain ( edict_t * self , edict_t * other , float kick , int damage ) ; +extern void hover_attack ( edict_t * self ) ; +extern void hover_start_attack ( edict_t * self ) ; +extern void hover_walk ( edict_t * self ) ; +extern void hover_run ( edict_t * self ) ; +extern void hover_stand ( edict_t * self ) ; +extern void hover_fire_blaster ( edict_t * self ) ; +extern void hover_reattack ( edict_t * self ) ; +extern void hover_search ( edict_t * self ) ; +extern void hover_sight ( edict_t * self , edict_t * other ) ; +extern void SP_monster_gunner ( edict_t * self ) ; +extern void gunner_refire_chain ( edict_t * self ) ; +extern void gunner_fire_chain ( edict_t * self ) ; +extern void gunner_attack ( edict_t * self ) ; +extern void GunnerGrenade ( edict_t * self ) ; +extern void GunnerFire ( edict_t * self ) ; +extern void gunner_opengun ( edict_t * self ) ; +extern void gunner_dodge ( edict_t * self , edict_t * attacker , float eta ) ; +extern void gunner_duck_up ( edict_t * self ) ; +extern void gunner_duck_hold ( edict_t * self ) ; +extern void gunner_duck_down ( edict_t * self ) ; +extern void gunner_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void gunner_dead ( edict_t * self ) ; +extern void gunner_pain ( edict_t * self , edict_t * other , float kick , int damage ) ; +extern void gunner_runandshoot ( edict_t * self ) ; +extern void gunner_run ( edict_t * self ) ; +extern void gunner_walk ( edict_t * self ) ; +extern void gunner_stand ( edict_t * self ) ; +extern void gunner_fidget ( edict_t * self ) ; +extern void gunner_search ( edict_t * self ) ; +extern void gunner_sight ( edict_t * self , edict_t * other ) ; +extern void gunner_idlesound ( edict_t * self ) ; +extern void SP_monster_gladiator ( edict_t * self ) ; +extern void gladiator_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void gladiator_dead ( edict_t * self ) ; +extern void gladiator_pain ( edict_t * self , edict_t * other , float kick , int damage ) ; +extern void gladiator_attack ( edict_t * self ) ; +extern void GladiatorGun ( edict_t * self ) ; +extern void gladiator_melee ( edict_t * self ) ; +extern void GaldiatorMelee ( edict_t * self ) ; +extern void gladiator_run ( edict_t * self ) ; +extern void gladiator_walk ( edict_t * self ) ; +extern void gladiator_stand ( edict_t * self ) ; +extern void gladiator_cleaver_swing ( edict_t * self ) ; +extern void gladiator_search ( edict_t * self ) ; +extern void gladiator_sight ( edict_t * self , edict_t * other ) ; +extern void gladiator_idle ( edict_t * self ) ; +extern void SP_monster_flyer ( edict_t * self ) ; +extern void flyer_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void flyer_pain ( edict_t * self , edict_t * other , float kick , int damage ) ; +extern void flyer_check_melee ( edict_t * self ) ; +extern void flyer_melee ( edict_t * self ) ; +extern void flyer_nextmove ( edict_t * self ) ; +extern void flyer_setstart ( edict_t * self ) ; +extern void flyer_attack ( edict_t * self ) ; +extern void flyer_loop_melee ( edict_t * self ) ; +extern void flyer_slash_right ( edict_t * self ) ; +extern void flyer_slash_left ( edict_t * self ) ; +extern void flyer_fireright ( edict_t * self ) ; +extern void flyer_fireleft ( edict_t * self ) ; +extern void flyer_fire ( edict_t * self , int flash_number ) ; +extern void flyer_start ( edict_t * self ) ; +extern void flyer_stop ( edict_t * self ) ; +extern void flyer_stand ( edict_t * self ) ; +extern void flyer_walk ( edict_t * self ) ; +extern void flyer_run ( edict_t * self ) ; +extern void flyer_pop_blades ( edict_t * self ) ; +extern void flyer_idle ( edict_t * self ) ; +extern void flyer_sight ( edict_t * self , edict_t * other ) ; +extern void SP_monster_floater ( edict_t * self ) ; +extern void floater_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void floater_dead ( edict_t * self ) ; +extern void floater_pain ( edict_t * self , edict_t * other , float kick , int damage ) ; +extern void floater_melee ( edict_t * self ) ; +extern void floater_attack ( edict_t * self ) ; +extern void floater_zap ( edict_t * self ) ; +extern void floater_wham ( edict_t * self ) ; +extern void floater_walk ( edict_t * self ) ; +extern void floater_run ( edict_t * self ) ; +extern void floater_stand ( edict_t * self ) ; +extern void floater_fire_blaster ( edict_t * self ) ; +extern void floater_idle ( edict_t * self ) ; +extern void floater_sight ( edict_t * self , edict_t * other ) ; +extern void SP_monster_flipper ( edict_t * self ) ; +extern void flipper_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void flipper_sight ( edict_t * self , edict_t * other ) ; +extern void flipper_dead ( edict_t * self ) ; +extern void flipper_pain ( edict_t * self , edict_t * other , float kick , int damage ) ; +extern void flipper_melee ( edict_t * self ) ; +extern void flipper_preattack ( edict_t * self ) ; +extern void flipper_bite ( edict_t * self ) ; +extern void flipper_start_run ( edict_t * self ) ; +extern void flipper_walk ( edict_t * self ) ; +extern void flipper_run ( edict_t * self ) ; +extern void flipper_run_loop ( edict_t * self ) ; +extern void flipper_stand ( edict_t * self ) ; +extern void SP_monster_chick ( edict_t * self ) ; +extern void chick_sight ( edict_t * self , edict_t * other ) ; +extern void chick_attack ( edict_t * self ) ; +extern void chick_melee ( edict_t * self ) ; +extern void chick_slash ( edict_t * self ) ; +extern void chick_reslash ( edict_t * self ) ; +extern void chick_attack1 ( edict_t * self ) ; +extern void chick_rerocket ( edict_t * self ) ; +extern void ChickReload ( edict_t * self ) ; +extern void Chick_PreAttack1 ( edict_t * self ) ; +extern void ChickRocket ( edict_t * self ) ; +extern void ChickSlash ( edict_t * self ) ; +extern void chick_dodge ( edict_t * self , edict_t * attacker , float eta ) ; +extern void chick_duck_up ( edict_t * self ) ; +extern void chick_duck_hold ( edict_t * self ) ; +extern void chick_duck_down ( edict_t * self ) ; +extern void chick_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void chick_dead ( edict_t * self ) ; +extern void chick_pain ( edict_t * self , edict_t * other , float kick , int damage ) ; +extern void chick_run ( edict_t * self ) ; +extern void chick_walk ( edict_t * self ) ; +extern void chick_stand ( edict_t * self ) ; +extern void chick_fidget ( edict_t * self ) ; +extern void ChickMoan ( edict_t * self ) ; +extern void SP_monster_brain ( edict_t * self ) ; +extern void brain_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void brain_dead ( edict_t * self ) ; +extern void brain_pain ( edict_t * self , edict_t * other , float kick , int damage ) ; +extern void brain_run ( edict_t * self ) ; +extern void brain_melee ( edict_t * self ) ; +extern void brain_chest_closed ( edict_t * self ) ; +extern void brain_tentacle_attack ( edict_t * self ) ; +extern void brain_chest_open ( edict_t * self ) ; +extern void brain_hit_left ( edict_t * self ) ; +extern void brain_swing_left ( edict_t * self ) ; +extern void brain_hit_right ( edict_t * self ) ; +extern void brain_swing_right ( edict_t * self ) ; +extern void brain_dodge ( edict_t * self , edict_t * attacker , float eta ) ; +extern void brain_duck_up ( edict_t * self ) ; +extern void brain_duck_hold ( edict_t * self ) ; +extern void brain_duck_down ( edict_t * self ) ; +extern void brain_walk ( edict_t * self ) ; +extern void brain_idle ( edict_t * self ) ; +extern void brain_stand ( edict_t * self ) ; +extern void brain_search ( edict_t * self ) ; +extern void brain_sight ( edict_t * self , edict_t * other ) ; +extern void MakronToss ( edict_t * self ) ; +extern void MakronSpawn ( edict_t * self ) ; +extern void SP_monster_makron ( edict_t * self ) ; +extern void MakronPrecache ( void ) ; +extern qboolean Makron_CheckAttack ( edict_t * self ) ; +extern void makron_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void makron_dead ( edict_t * self ) ; +extern void makron_torso ( edict_t * ent ) ; +extern void makron_torso_think ( edict_t * self ) ; +extern void makron_attack ( edict_t * self ) ; +extern void makron_sight ( edict_t * self , edict_t * other ) ; +extern void makron_pain ( edict_t * self , edict_t * other , float kick , int damage ) ; +extern void MakronHyperblaster ( edict_t * self ) ; +extern void MakronRailgun ( edict_t * self ) ; +extern void MakronSaveloc ( edict_t * self ) ; +extern void makronBFG ( edict_t * self ) ; +extern void makron_run ( edict_t * self ) ; +extern void makron_walk ( edict_t * self ) ; +extern void makron_prerailgun ( edict_t * self ) ; +extern void makron_brainsplorch ( edict_t * self ) ; +extern void makron_step_right ( edict_t * self ) ; +extern void makron_step_left ( edict_t * self ) ; +extern void makron_popup ( edict_t * self ) ; +extern void makron_hit ( edict_t * self ) ; +extern void makron_stand ( edict_t * self ) ; +extern void makron_taunt ( edict_t * self ) ; +extern void SP_monster_jorg ( edict_t * self ) ; +extern qboolean Jorg_CheckAttack ( edict_t * self ) ; +extern void jorg_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void jorg_dead ( edict_t * self ) ; +extern void jorg_attack ( edict_t * self ) ; +extern void jorg_firebullet ( edict_t * self ) ; +extern void jorg_firebullet_left ( edict_t * self ) ; +extern void jorg_firebullet_right ( edict_t * self ) ; +extern void jorgBFG ( edict_t * self ) ; +extern void jorg_pain ( edict_t * self , edict_t * other , float kick , int damage ) ; +extern void jorg_attack1 ( edict_t * self ) ; +extern void jorg_reattack1 ( edict_t * self ) ; +extern void jorg_run ( edict_t * self ) ; +extern void jorg_walk ( edict_t * self ) ; +extern void jorg_stand ( edict_t * self ) ; +extern void jorg_step_right ( edict_t * self ) ; +extern void jorg_step_left ( edict_t * self ) ; +extern void jorg_death_hit ( edict_t * self ) ; +extern void jorg_idle ( edict_t * self ) ; +extern void jorg_search ( edict_t * self ) ; +extern void SP_monster_boss3_stand ( edict_t * self ) ; +extern void Think_Boss3Stand ( edict_t * ent ) ; +extern void Use_Boss3 ( edict_t * ent , edict_t * other , edict_t * activator ) ; +extern void SP_monster_boss2 ( edict_t * self ) ; +extern qboolean Boss2_CheckAttack ( edict_t * self ) ; +extern void boss2_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void boss2_dead ( edict_t * self ) ; +extern void boss2_pain ( edict_t * self , edict_t * other , float kick , int damage ) ; +extern void boss2_reattack_mg ( edict_t * self ) ; +extern void boss2_attack_mg ( edict_t * self ) ; +extern void boss2_attack ( edict_t * self ) ; +extern void boss2_walk ( edict_t * self ) ; +extern void boss2_run ( edict_t * self ) ; +extern void boss2_stand ( edict_t * self ) ; +extern void Boss2MachineGun ( edict_t * self ) ; +extern void boss2_firebullet_left ( edict_t * self ) ; +extern void boss2_firebullet_right ( edict_t * self ) ; +extern void Boss2Rocket ( edict_t * self ) ; +extern void boss2_search ( edict_t * self ) ; +extern void SP_monster_berserk ( edict_t * self ) ; +extern void berserk_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void berserk_dead ( edict_t * self ) ; +extern void berserk_pain ( edict_t * self , edict_t * other , float kick , int damage ) ; +extern void berserk_melee ( edict_t * self ) ; +extern void berserk_strike ( edict_t * self ) ; +extern void berserk_attack_club ( edict_t * self ) ; +extern void berserk_swing ( edict_t * self ) ; +extern void berserk_attack_spike ( edict_t * self ) ; +extern void berserk_run ( edict_t * self ) ; +extern void berserk_walk ( edict_t * self ) ; +extern void berserk_fidget ( edict_t * self ) ; +extern void berserk_stand ( edict_t * self ) ; +extern void berserk_search ( edict_t * self ) ; +extern void berserk_sight ( edict_t * self , edict_t * other ) ; +extern void SP_target_actor ( edict_t * self ) ; +extern void target_actor_touch ( edict_t * self , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void SP_misc_actor ( edict_t * self ) ; +extern void actor_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void actor_attack ( edict_t * self ) ; +extern void actor_fire ( edict_t * self ) ; +extern void actor_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void actor_dead ( edict_t * self ) ; +extern void actorMachineGun ( edict_t * self ) ; +extern void actor_pain ( edict_t * self , edict_t * other , float kick , int damage ) ; +extern void actor_run ( edict_t * self ) ; +extern void actor_walk ( edict_t * self ) ; +extern void actor_stand ( edict_t * self ) ; +extern void fire_bfg ( edict_t * self , vec3_t start , vec3_t dir , int damage , int speed , float damage_radius ) ; +extern void bfg_think ( edict_t * self ) ; +extern void bfg_touch ( edict_t * self , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void bfg_explode ( edict_t * self ) ; +extern void fire_rail ( edict_t * self , vec3_t start , vec3_t aimdir , int damage , int kick ) ; +extern void fire_rocket ( edict_t * self , vec3_t start , vec3_t dir , int damage , int speed , float damage_radius , int radius_damage ) ; +extern void rocket_touch ( edict_t * ent , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void fire_grenade2 ( edict_t * self , vec3_t start , vec3_t aimdir , int damage , int speed , float timer , float damage_radius , qboolean held ) ; +extern void fire_grenade ( edict_t * self , vec3_t start , vec3_t aimdir , int damage , int speed , float timer , float damage_radius ) ; +extern void Grenade_Touch ( edict_t * ent , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void Grenade_Explode ( edict_t * ent ) ; +extern void fire_blaster ( edict_t * self , vec3_t start , vec3_t dir , int damage , int speed , int effect , qboolean hyper ) ; +extern void blaster_touch ( edict_t * self , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void fire_shotgun ( edict_t * self , vec3_t start , vec3_t aimdir , int damage , int kick , int hspread , int vspread , int count , int mod ) ; +extern void fire_bullet ( edict_t * self , vec3_t start , vec3_t aimdir , int damage , int kick , int hspread , int vspread , int mod ) ; +extern void fire_lead ( edict_t * self , vec3_t start , vec3_t aimdir , int damage , int kick , int te_impact , int hspread , int vspread , int mod ) ; +extern qboolean fire_hit ( edict_t * self , vec3_t aim , int damage , int kick ) ; +extern void check_dodge ( edict_t * self , vec3_t start , vec3_t dir , int speed ) ; +extern qboolean KillBox ( edict_t * ent ) ; +extern void G_TouchSolids ( edict_t * ent ) ; +extern void G_TouchTriggers ( edict_t * ent ) ; +extern void G_FreeEdict ( edict_t * ed ) ; +extern edict_t * G_Spawn ( void ) ; +extern void G_InitEdict ( edict_t * e ) ; +extern char * G_CopyString ( char * in ) ; +extern void vectoangles ( vec3_t value1 , vec3_t angles ) ; +extern float vectoyaw ( vec3_t vec ) ; +extern void G_SetMovedir ( vec3_t angles , vec3_t movedir ) ; +extern char * vtos ( vec3_t v ) ; +extern float * tv ( float x , float y , float z ) ; +extern void G_UseTargets ( edict_t * ent , edict_t * activator ) ; +extern void Think_Delay ( edict_t * ent ) ; +extern edict_t * G_PickTarget ( char * targetname ) ; +extern edict_t * findradius ( edict_t * from , vec3_t org , float rad ) ; +extern edict_t * G_Find ( edict_t * from , int fieldofs , char * match ) ; +extern void G_ProjectSource ( vec3_t point , vec3_t distance , vec3_t forward , vec3_t right , vec3_t result ) ; +extern void SP_turret_driver ( edict_t * self ) ; +extern void turret_driver_link ( edict_t * self ) ; +extern void turret_driver_think ( edict_t * self ) ; +extern void turret_driver_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void SP_turret_base ( edict_t * self ) ; +extern void SP_turret_breach ( edict_t * self ) ; +extern void turret_breach_finish_init ( edict_t * self ) ; +extern void turret_breach_think ( edict_t * self ) ; +extern void turret_breach_fire ( edict_t * self ) ; +extern void turret_blocked ( edict_t * self , edict_t * other ) ; +extern float SnapToEights ( float x ) ; +extern void AnglesNormalize ( vec3_t vec ) ; +extern void SP_trigger_monsterjump ( edict_t * self ) ; +extern void trigger_monsterjump_touch ( edict_t * self , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void SP_trigger_gravity ( edict_t * self ) ; +extern void trigger_gravity_touch ( edict_t * self , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void SP_trigger_hurt ( edict_t * self ) ; +extern void hurt_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void hurt_touch ( edict_t * self , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void SP_trigger_push ( edict_t * self ) ; +extern void trigger_push_touch ( edict_t * self , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void SP_trigger_always ( edict_t * ent ) ; +extern void SP_trigger_counter ( edict_t * self ) ; +extern void trigger_counter_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void SP_trigger_key ( edict_t * self ) ; +extern void trigger_key_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void SP_trigger_relay ( edict_t * self ) ; +extern void trigger_relay_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void SP_trigger_once ( edict_t * ent ) ; +extern void SP_trigger_multiple ( edict_t * ent ) ; +extern void trigger_enable ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void Touch_Multi ( edict_t * self , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void Use_Multi ( edict_t * ent , edict_t * other , edict_t * activator ) ; +extern void multi_trigger ( edict_t * ent ) ; +extern void multi_wait ( edict_t * ent ) ; +extern void InitTrigger ( edict_t * self ) ; +extern void SP_target_earthquake ( edict_t * self ) ; +extern void target_earthquake_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void target_earthquake_think ( edict_t * self ) ; +extern void SP_target_lightramp ( edict_t * self ) ; +extern void target_lightramp_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void target_lightramp_think ( edict_t * self ) ; +extern void SP_target_laser ( edict_t * self ) ; +extern void target_laser_start ( edict_t * self ) ; +extern void target_laser_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void target_laser_off ( edict_t * self ) ; +extern void target_laser_on ( edict_t * self ) ; +extern void target_laser_think ( edict_t * self ) ; +extern void SP_target_crosslevel_target ( edict_t * self ) ; +extern void target_crosslevel_target_think ( edict_t * self ) ; +extern void SP_target_crosslevel_trigger ( edict_t * self ) ; +extern void trigger_crosslevel_trigger_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void SP_target_blaster ( edict_t * self ) ; +extern void use_target_blaster ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void SP_target_spawner ( edict_t * self ) ; +extern void use_target_spawner ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void SP_target_splash ( edict_t * self ) ; +extern void use_target_splash ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void SP_target_changelevel ( edict_t * ent ) ; +extern void use_target_changelevel ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void SP_target_explosion ( edict_t * ent ) ; +extern void use_target_explosion ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void target_explosion_explode ( edict_t * self ) ; +extern void SP_target_goal ( edict_t * ent ) ; +extern void use_target_goal ( edict_t * ent , edict_t * other , edict_t * activator ) ; +extern void SP_target_secret ( edict_t * ent ) ; +extern void use_target_secret ( edict_t * ent , edict_t * other , edict_t * activator ) ; +extern void SP_target_help ( edict_t * ent ) ; +extern void Use_Target_Help ( edict_t * ent , edict_t * other , edict_t * activator ) ; +extern void SP_target_speaker ( edict_t * ent ) ; +extern void Use_Target_Speaker ( edict_t * ent , edict_t * other , edict_t * activator ) ; +extern void SP_target_temp_entity ( edict_t * ent ) ; +extern void Use_Target_Tent ( edict_t * ent , edict_t * other , edict_t * activator ) ; +extern void ServerCommand ( void ) ; +extern void SVCmd_WriteIP_f ( void ) ; +extern void SVCmd_ListIP_f ( void ) ; +extern void SVCmd_RemoveIP_f ( void ) ; +extern void SVCmd_AddIP_f ( void ) ; +extern qboolean SV_FilterPacket ( char * from ) ; +extern void Svcmd_Test_f ( void ) ; +extern void SP_worldspawn ( edict_t * ent ) ; +extern void SpawnEntities ( const char * mapname , char * entities , const char * spawnpoint ) ; +extern void G_FindTeams ( void ) ; +extern char * ED_ParseEdict ( char * data , edict_t * ent ) ; +extern void ED_ParseField ( const char * key , const char * value , edict_t * ent ) ; +extern char * ED_NewString ( const char * string ) ; +extern void ED_CallSpawn ( edict_t * ent ) ; +extern void G_RunEntity ( edict_t * ent ) ; +extern void SV_Physics_Step ( edict_t * ent ) ; +extern void SV_AddRotationalFriction ( edict_t * ent ) ; +extern void SV_Physics_Toss ( edict_t * ent ) ; +extern void SV_Physics_Noclip ( edict_t * ent ) ; +extern void SV_Physics_None ( edict_t * ent ) ; +extern void SV_Physics_Pusher ( edict_t * ent ) ; +extern qboolean SV_Push ( edict_t * pusher , vec3_t move , vec3_t amove ) ; +extern trace_t SV_PushEntity ( edict_t * ent , vec3_t push ) ; +extern void SV_AddGravity ( edict_t * ent ) ; +extern int SV_FlyMove ( edict_t * ent , float time , int mask ) ; +extern int ClipVelocity ( vec3_t in , vec3_t normal , vec3_t out , float overbounce ) ; +extern void SV_Impact ( edict_t * e1 , trace_t * trace ) ; +extern qboolean SV_RunThink ( edict_t * ent ) ; +extern void SV_CheckVelocity ( edict_t * ent ) ; +extern edict_t * SV_TestEntityPosition ( edict_t * ent ) ; +extern void swimmonster_start ( edict_t * self ) ; +extern void swimmonster_start_go ( edict_t * self ) ; +extern void flymonster_start ( edict_t * self ) ; +extern void flymonster_start_go ( edict_t * self ) ; +extern void walkmonster_start ( edict_t * self ) ; +extern void walkmonster_start_go ( edict_t * self ) ; +extern void monster_start_go ( edict_t * self ) ; +extern qboolean monster_start ( edict_t * self ) ; +extern void monster_death_use ( edict_t * self ) ; +extern void monster_triggered_start ( edict_t * self ) ; +extern void monster_triggered_spawn_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void monster_triggered_spawn ( edict_t * self ) ; +extern void monster_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void monster_think ( edict_t * self ) ; +extern void M_MoveFrame ( edict_t * self ) ; +extern void M_SetEffects ( edict_t * ent ) ; +extern void M_droptofloor ( edict_t * ent ) ; +extern void M_WorldEffects ( edict_t * ent ) ; +extern void M_CatagorizePosition ( edict_t * ent ) ; +extern void M_CheckGround ( edict_t * ent ) ; +extern void AttackFinished ( edict_t * self , float time ) ; +extern void M_FlyCheck ( edict_t * self ) ; +extern void M_FliesOn ( edict_t * self ) ; +extern void M_FliesOff ( edict_t * self ) ; +extern void monster_fire_bfg ( edict_t * self , vec3_t start , vec3_t aimdir , int damage , int speed , int kick , float damage_radius , int flashtype ) ; +extern void monster_fire_railgun ( edict_t * self , vec3_t start , vec3_t aimdir , int damage , int kick , int flashtype ) ; +extern void monster_fire_rocket ( edict_t * self , vec3_t start , vec3_t dir , int damage , int speed , int flashtype ) ; +extern void monster_fire_grenade ( edict_t * self , vec3_t start , vec3_t aimdir , int damage , int speed , int flashtype ) ; +extern void monster_fire_blaster ( edict_t * self , vec3_t start , vec3_t dir , int damage , int speed , int flashtype , int effect ) ; +extern void monster_fire_shotgun ( edict_t * self , vec3_t start , vec3_t aimdir , int damage , int kick , int hspread , int vspread , int count , int flashtype ) ; +extern void monster_fire_bullet ( edict_t * self , vec3_t start , vec3_t dir , int damage , int kick , int hspread , int vspread , int flashtype ) ; +extern void SP_misc_teleporter_dest ( edict_t * ent ) ; +extern void SP_misc_teleporter ( edict_t * ent ) ; +extern void teleporter_touch ( edict_t * self , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void SP_func_clock ( edict_t * self ) ; +extern void func_clock_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void func_clock_think ( edict_t * self ) ; +extern void func_clock_format_countdown ( edict_t * self ) ; +extern void func_clock_reset ( edict_t * self ) ; +extern void SP_target_string ( edict_t * self ) ; +extern void target_string_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void SP_target_character ( edict_t * self ) ; +extern void SP_misc_gib_head ( edict_t * ent ) ; +extern void SP_misc_gib_leg ( edict_t * ent ) ; +extern void SP_misc_gib_arm ( edict_t * ent ) ; +extern void SP_light_mine2 ( edict_t * ent ) ; +extern void SP_light_mine1 ( edict_t * ent ) ; +extern void SP_misc_satellite_dish ( edict_t * ent ) ; +extern void misc_satellite_dish_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void misc_satellite_dish_think ( edict_t * self ) ; +extern void SP_misc_strogg_ship ( edict_t * ent ) ; +extern void misc_strogg_ship_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void SP_misc_viper_bomb ( edict_t * self ) ; +extern void misc_viper_bomb_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void misc_viper_bomb_prethink ( edict_t * self ) ; +extern void misc_viper_bomb_touch ( edict_t * self , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void SP_misc_bigviper ( edict_t * ent ) ; +extern void SP_misc_viper ( edict_t * ent ) ; +extern void misc_viper_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void SP_misc_deadsoldier ( edict_t * ent ) ; +extern void misc_deadsoldier_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void SP_misc_banner ( edict_t * ent ) ; +extern void misc_banner_think ( edict_t * ent ) ; +extern void SP_monster_commander_body ( edict_t * self ) ; +extern void commander_body_drop ( edict_t * self ) ; +extern void commander_body_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void commander_body_think ( edict_t * self ) ; +extern void SP_misc_easterchick2 ( edict_t * ent ) ; +extern void misc_easterchick2_think ( edict_t * self ) ; +extern void SP_misc_easterchick ( edict_t * ent ) ; +extern void misc_easterchick_think ( edict_t * self ) ; +extern void SP_misc_eastertank ( edict_t * ent ) ; +extern void misc_eastertank_think ( edict_t * self ) ; +extern void SP_misc_blackhole ( edict_t * ent ) ; +extern void misc_blackhole_transparent ( edict_t * ent ) ; +extern void misc_blackhole_think ( edict_t * self ) ; +extern void misc_blackhole_use ( edict_t * ent , edict_t * other , edict_t * activator ) ; +extern void SP_misc_explobox ( edict_t * self ) ; +extern void barrel_delay ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void barrel_explode ( edict_t * self ) ; +extern void barrel_touch ( edict_t * self , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void SP_func_explosive ( edict_t * self ) ; +extern void func_explosive_spawn ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void func_explosive_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void func_explosive_explode ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void SP_func_object ( edict_t * self ) ; +extern void func_object_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void func_object_release ( edict_t * self ) ; +extern void func_object_touch ( edict_t * self , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void SP_func_wall ( edict_t * self ) ; +extern void func_wall_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void SP_light ( edict_t * self ) ; +extern void light_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void SP_info_notnull ( edict_t * self ) ; +extern void SP_info_null ( edict_t * self ) ; +extern void SP_viewthing ( edict_t * ent ) ; +extern void TH_viewthing ( edict_t * ent ) ; +extern void SP_point_combat ( edict_t * self ) ; +extern void point_combat_touch ( edict_t * self , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void SP_path_corner ( edict_t * self ) ; +extern void path_corner_touch ( edict_t * self , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void BecomeExplosion2 ( edict_t * self ) ; +extern void BecomeExplosion1 ( edict_t * self ) ; +extern void ThrowDebris ( edict_t * self , char * modelname , float speed , vec3_t origin ) ; +extern void debris_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void ThrowClientHead ( edict_t * self , int damage ) ; +extern void ThrowHead ( edict_t * self , char * gibname , int damage , int type ) ; +extern void ThrowGib ( edict_t * self , char * gibname , int damage , int type ) ; +extern void gib_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void gib_touch ( edict_t * self , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void gib_think ( edict_t * self ) ; +extern void ClipGibVelocity ( edict_t * ent ) ; +extern void VelocityForDamage ( int damage , vec3_t v ) ; +extern void SP_func_areaportal ( edict_t * ent ) ; +extern void Use_Areaportal ( edict_t * ent , edict_t * other , edict_t * activator ) ; +extern void G_RunFrame ( void ) ; +extern void ExitLevel ( void ) ; +extern void CheckDMRules ( void ) ; +extern void CheckNeedPass ( void ) ; +extern void EndDMLevel ( void ) ; +extern edict_t * CreateTargetChangeLevel ( char * map ) ; +extern void ClientEndServerFrames ( void ) ; +extern void Com_Printf ( char * msg , ... ) ; +extern void Sys_Error ( char * error , ... ) ; +extern game_export_t * GetGameAPI ( game_import_t * import ) ; +extern void ShutdownGame ( void ) ; +extern void SetItemNames ( void ) ; +extern void InitItems ( void ) ; +extern void SP_item_health_mega ( edict_t * self ) ; +extern void SP_item_health_large ( edict_t * self ) ; +extern void SP_item_health_small ( edict_t * self ) ; +extern void SP_item_health ( edict_t * self ) ; +extern void SpawnItem ( edict_t * ent , gitem_t * item ) ; +extern void PrecacheItem ( gitem_t * it ) ; +extern void droptofloor ( edict_t * ent ) ; +extern void Use_Item ( edict_t * ent , edict_t * other , edict_t * activator ) ; +extern edict_t * Drop_Item ( edict_t * ent , gitem_t * item ) ; +extern void drop_make_touchable ( edict_t * ent ) ; +extern void drop_temp_touch ( edict_t * ent , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void Touch_Item ( edict_t * ent , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void Drop_PowerArmor ( edict_t * ent , gitem_t * item ) ; +extern qboolean Pickup_PowerArmor ( edict_t * ent , edict_t * other ) ; +extern void Use_PowerArmor ( edict_t * ent , gitem_t * item ) ; +extern int PowerArmorType ( edict_t * ent ) ; +extern qboolean Pickup_Armor ( edict_t * ent , edict_t * other ) ; +extern int ArmorIndex ( edict_t * ent ) ; +extern qboolean Pickup_Health ( edict_t * ent , edict_t * other ) ; +extern void MegaHealth_think ( edict_t * self ) ; +extern void Drop_Ammo ( edict_t * ent , gitem_t * item ) ; +extern qboolean Pickup_Ammo ( edict_t * ent , edict_t * other ) ; +extern qboolean Add_Ammo ( edict_t * ent , gitem_t * item , int count ) ; +extern qboolean Pickup_Key ( edict_t * ent , edict_t * other ) ; +extern void Use_Silencer ( edict_t * ent , gitem_t * item ) ; +extern void Use_Invulnerability ( edict_t * ent , gitem_t * item ) ; +extern void Use_Envirosuit ( edict_t * ent , gitem_t * item ) ; +extern void Use_Breather ( edict_t * ent , gitem_t * item ) ; +extern void Use_Quad ( edict_t * ent , gitem_t * item ) ; +extern qboolean Pickup_Pack ( edict_t * ent , edict_t * other ) ; +extern qboolean Pickup_Bandolier ( edict_t * ent , edict_t * other ) ; +extern qboolean Pickup_AncientHead ( edict_t * ent , edict_t * other ) ; +extern qboolean Pickup_Adrenaline ( edict_t * ent , edict_t * other ) ; +extern void Drop_General ( edict_t * ent , gitem_t * item ) ; +extern qboolean Pickup_Powerup ( edict_t * ent , edict_t * other ) ; +extern void SetRespawn ( edict_t * ent , float delay ) ; +extern void DoRespawn ( edict_t * ent ) ; +extern gitem_t * FindItem ( char * pickup_name ) ; +extern gitem_t * FindItemByClassname ( char * classname ) ; +extern gitem_t * GetItemByIndex ( int index ) ; +extern void SP_func_killbox ( edict_t * ent ) ; +extern void use_killbox ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void SP_func_door_secret ( edict_t * ent ) ; +extern void door_secret_die ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void door_secret_blocked ( edict_t * self , edict_t * other ) ; +extern void door_secret_done ( edict_t * self ) ; +extern void door_secret_move6 ( edict_t * self ) ; +extern void door_secret_move5 ( edict_t * self ) ; +extern void door_secret_move4 ( edict_t * self ) ; +extern void door_secret_move3 ( edict_t * self ) ; +extern void door_secret_move2 ( edict_t * self ) ; +extern void door_secret_move1 ( edict_t * self ) ; +extern void door_secret_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void SP_func_conveyor ( edict_t * self ) ; +extern void func_conveyor_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void SP_func_timer ( edict_t * self ) ; +extern void func_timer_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void func_timer_think ( edict_t * self ) ; +extern void SP_trigger_elevator ( edict_t * self ) ; +extern void trigger_elevator_init ( edict_t * self ) ; +extern void trigger_elevator_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void SP_func_train ( edict_t * self ) ; +extern void train_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void func_train_find ( edict_t * self ) ; +extern void train_resume ( edict_t * self ) ; +extern void train_next ( edict_t * self ) ; +extern void train_wait ( edict_t * self ) ; +extern void train_blocked ( edict_t * self , edict_t * other ) ; +extern void SP_func_water ( edict_t * self ) ; +extern void SP_func_door_rotating ( edict_t * ent ) ; +extern void SP_func_door ( edict_t * ent ) ; +extern void door_touch ( edict_t * self , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void door_killed ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void door_blocked ( edict_t * self , edict_t * other ) ; +extern void Think_SpawnDoorTrigger ( edict_t * ent ) ; +extern void Think_CalcMoveSpeed ( edict_t * self ) ; +extern void Touch_DoorTrigger ( edict_t * self , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void door_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void door_go_up ( edict_t * self , edict_t * activator ) ; +extern void door_go_down ( edict_t * self ) ; +extern void door_hit_bottom ( edict_t * self ) ; +extern void door_hit_top ( edict_t * self ) ; +extern void door_use_areaportals ( edict_t * self , qboolean open ) ; +extern void SP_func_button ( edict_t * ent ) ; +extern void button_killed ( edict_t * self , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern void button_touch ( edict_t * self , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void button_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void button_fire ( edict_t * self ) ; +extern void button_wait ( edict_t * self ) ; +extern void button_return ( edict_t * self ) ; +extern void button_done ( edict_t * self ) ; +extern void SP_func_rotating ( edict_t * ent ) ; +extern void rotating_use ( edict_t * self , edict_t * other , edict_t * activator ) ; +extern void rotating_touch ( edict_t * self , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void rotating_blocked ( edict_t * self , edict_t * other ) ; +extern void SP_func_plat ( edict_t * ent ) ; +extern void plat_spawn_inside_trigger ( edict_t * ent ) ; +extern void Touch_Plat_Center ( edict_t * ent , edict_t * other , cplane_t * plane , csurface_t * surf ) ; +extern void Use_Plat ( edict_t * ent , edict_t * other , edict_t * activator ) ; +extern void plat_blocked ( edict_t * self , edict_t * other ) ; +extern void plat_go_up ( edict_t * ent ) ; +extern void plat_go_down ( edict_t * ent ) ; +extern void plat_hit_bottom ( edict_t * ent ) ; +extern void plat_hit_top ( edict_t * ent ) ; +extern void Think_AccelMove ( edict_t * ent ) ; +extern void plat_Accelerate ( moveinfo_t * moveinfo ) ; +extern void plat_CalcAcceleratedMove ( moveinfo_t * moveinfo ) ; +extern void AngleMove_Calc ( edict_t * ent , void ( * func ) ( edict_t * ) ) ; +extern void AngleMove_Begin ( edict_t * ent ) ; +extern void AngleMove_Final ( edict_t * ent ) ; +extern void AngleMove_Done ( edict_t * ent ) ; +extern void Move_Calc ( edict_t * ent , vec3_t dest , void ( * func ) ( edict_t * ) ) ; +extern void Move_Begin ( edict_t * ent ) ; +extern void Move_Final ( edict_t * ent ) ; +extern void Move_Done ( edict_t * ent ) ; +extern void T_RadiusDamage ( edict_t * inflictor , edict_t * attacker , float damage , edict_t * ignore , float radius , int mod ) ; +extern void T_Damage ( edict_t * targ , edict_t * inflictor , edict_t * attacker , vec3_t dir , vec3_t point , vec3_t normal , int damage , int knockback , int dflags , int mod ) ; +extern void M_ReactToDamage ( edict_t * targ , edict_t * attacker ) ; +extern int CheckArmor ( edict_t * ent , vec3_t point , vec3_t normal , int damage , int te_sparks , int dflags ) ; +extern int CheckPowerArmor ( edict_t * ent , vec3_t point , vec3_t normal , int damage , int dflags ) ; +extern void SpawnDamage ( int type , vec3_t origin , vec3_t normal ) ; +extern void Killed ( edict_t * targ , edict_t * inflictor , edict_t * attacker , int damage , vec3_t point ) ; +extern qboolean CanDamage ( edict_t * targ , edict_t * inflictor ) ; +extern void ClientCommand ( edict_t * ent ) ; +extern void Cmd_PlayerList_f ( edict_t * ent ) ; +extern void Cmd_Say_f ( edict_t * ent , qboolean team , qboolean arg0 ) ; +extern void Cmd_Wave_f ( edict_t * ent ) ; +extern void Cmd_Players_f ( edict_t * ent ) ; +extern int PlayerSort ( void const * a , void const * b ) ; +extern void Cmd_PutAway_f ( edict_t * ent ) ; +extern void Cmd_Kill_f ( edict_t * ent ) ; +extern void Cmd_InvDrop_f ( edict_t * ent ) ; +extern void Cmd_WeapLast_f ( edict_t * ent ) ; +extern void Cmd_WeapNext_f ( edict_t * ent ) ; +extern void Cmd_WeapPrev_f ( edict_t * ent ) ; +extern void Cmd_InvUse_f ( edict_t * ent ) ; +extern void Cmd_Inven_f ( edict_t * ent ) ; +extern void Cmd_Drop_f ( edict_t * ent ) ; +extern void Cmd_Use_f ( edict_t * ent ) ; +extern void Cmd_Noclip_f ( edict_t * ent ) ; +extern void Cmd_Notarget_f ( edict_t * ent ) ; +extern void Cmd_God_f ( edict_t * ent ) ; +extern void Cmd_Give_f ( edict_t * ent ) ; +extern void ValidateSelectedItem ( edict_t * ent ) ; +extern void SelectPrevItem ( edict_t * ent , int itflags ) ; +extern void SelectNextItem ( edict_t * ent , int itflags ) ; +extern qboolean OnSameTeam ( edict_t * ent1 , edict_t * ent2 ) ; +extern char * ClientTeam ( edict_t * ent ) ; +extern void GetChaseTarget ( edict_t * ent ) ; +extern void ChasePrev ( edict_t * ent ) ; +extern void ChaseNext ( edict_t * ent ) ; +extern void UpdateChaseCam ( edict_t * ent ) ; +extern void ai_run ( edict_t * self , float dist ) ; +extern qboolean ai_checkattack ( edict_t * self ) ; +extern void ai_run_slide ( edict_t * self , float distance ) ; +extern void ai_run_missile ( edict_t * self ) ; +extern void ai_run_melee ( edict_t * self ) ; +extern qboolean M_CheckAttack ( edict_t * self ) ; +extern qboolean FacingIdeal ( edict_t * self ) ; +extern qboolean FindTarget ( edict_t * self ) ; +extern void FoundTarget ( edict_t * self ) ; +extern void HuntTarget ( edict_t * self ) ; +extern qboolean infront ( edict_t * self , edict_t * other ) ; +extern qboolean visible ( edict_t * self , edict_t * other ) ; +extern int range ( edict_t * self , edict_t * other ) ; +extern void ai_turn ( edict_t * self , float dist ) ; +extern void ai_charge ( edict_t * self , float dist ) ; +extern void ai_walk ( edict_t * self , float dist ) ; +extern void ai_stand ( edict_t * self , float dist ) ; +extern void ai_move ( edict_t * self , float dist ) ; +extern void AI_SetSightClient ( void ) ; diff --git a/src/game/baseq2/savegame/tables/gamefunc_list.h b/src/game/baseq2/savegame/tables/gamefunc_list.h new file mode 100644 index 00000000..aad0eae1 --- /dev/null +++ b/src/game/baseq2/savegame/tables/gamefunc_list.h @@ -0,0 +1,1029 @@ +{"ReadLevel", (byte *)ReadLevel}, +{"ReadLevelLocals", (byte *)ReadLevelLocals}, +{"ReadEdict", (byte *)ReadEdict}, +{"WriteLevel", (byte *)WriteLevel}, +{"WriteLevelLocals", (byte *)WriteLevelLocals}, +{"WriteEdict", (byte *)WriteEdict}, +{"ReadGame", (byte *)ReadGame}, +{"WriteGame", (byte *)WriteGame}, +{"ReadClient", (byte *)ReadClient}, +{"WriteClient", (byte *)WriteClient}, +{"ReadField", (byte *)ReadField}, +{"WriteField2", (byte *)WriteField2}, +{"WriteField1", (byte *)WriteField1}, +{"InitGame", (byte *)InitGame}, +{"Info_SetValueForKey", (byte *)Info_SetValueForKey}, +{"Info_Validate", (byte *)Info_Validate}, +{"Info_RemoveKey", (byte *)Info_RemoveKey}, +{"Info_ValueForKey", (byte *)Info_ValueForKey}, +{"Com_sprintf", (byte *)Com_sprintf}, +{"Q_strcasecmp", (byte *)Q_strcasecmp}, +{"Q_strncasecmp", (byte *)Q_strncasecmp}, +{"Q_stricmp", (byte *)Q_stricmp}, +{"Com_PageInMemory", (byte *)Com_PageInMemory}, +{"COM_Parse", (byte *)COM_Parse}, +{"va", (byte *)va}, +{"Swap_Init", (byte *)Swap_Init}, +{"FloatNoSwap", (byte *)FloatNoSwap}, +{"FloatSwap", (byte *)FloatSwap}, +{"LongNoSwap", (byte *)LongNoSwap}, +{"LongSwap", (byte *)LongSwap}, +{"ShortNoSwap", (byte *)ShortNoSwap}, +{"ShortSwap", (byte *)ShortSwap}, +{"LittleFloat", (byte *)LittleFloat}, +{"BigFloat", (byte *)BigFloat}, +{"LittleLong", (byte *)LittleLong}, +{"BigLong", (byte *)BigLong}, +{"LittleShort", (byte *)LittleShort}, +{"BigShort", (byte *)BigShort}, +{"COM_DefaultExtension", (byte *)COM_DefaultExtension}, +{"COM_FilePath", (byte *)COM_FilePath}, +{"COM_FileBase", (byte *)COM_FileBase}, +{"COM_FileExtension", (byte *)COM_FileExtension}, +{"COM_StripExtension", (byte *)COM_StripExtension}, +{"COM_SkipPath", (byte *)COM_SkipPath}, +{"Q_log2", (byte *)Q_log2}, +{"VectorScale", (byte *)VectorScale}, +{"VectorInverse", (byte *)VectorInverse}, +{"VectorLength", (byte *)VectorLength}, +{"CrossProduct", (byte *)CrossProduct}, +{"_VectorCopy", (byte *)_VectorCopy}, +{"_VectorAdd", (byte *)_VectorAdd}, +{"_VectorSubtract", (byte *)_VectorSubtract}, +{"_DotProduct", (byte *)_DotProduct}, +{"VectorMA", (byte *)VectorMA}, +{"VectorNormalize2", (byte *)VectorNormalize2}, +{"VectorNormalize", (byte *)VectorNormalize}, +{"VectorCompare", (byte *)VectorCompare}, +{"AddPointToBounds", (byte *)AddPointToBounds}, +{"ClearBounds", (byte *)ClearBounds}, +{"BoxOnPlaneSide2", (byte *)BoxOnPlaneSide2}, +{"anglemod", (byte *)anglemod}, +{"LerpAngle", (byte *)LerpAngle}, +{"Q_fabs", (byte *)Q_fabs}, +{"R_ConcatTransforms", (byte *)R_ConcatTransforms}, +{"R_ConcatRotations", (byte *)R_ConcatRotations}, +{"PerpendicularVector", (byte *)PerpendicularVector}, +{"ProjectPointOnPlane", (byte *)ProjectPointOnPlane}, +{"AngleVectors2", (byte *)AngleVectors2}, +{"AngleVectors", (byte *)AngleVectors}, +{"RotatePointAroundVector", (byte *)RotatePointAroundVector}, +{"Weapon_BFG", (byte *)Weapon_BFG}, +{"weapon_bfg_fire", (byte *)weapon_bfg_fire}, +{"Weapon_Railgun", (byte *)Weapon_Railgun}, +{"weapon_railgun_fire", (byte *)weapon_railgun_fire}, +{"Weapon_SuperShotgun", (byte *)Weapon_SuperShotgun}, +{"weapon_supershotgun_fire", (byte *)weapon_supershotgun_fire}, +{"Weapon_Shotgun", (byte *)Weapon_Shotgun}, +{"weapon_shotgun_fire", (byte *)weapon_shotgun_fire}, +{"Weapon_Chaingun", (byte *)Weapon_Chaingun}, +{"Chaingun_Fire", (byte *)Chaingun_Fire}, +{"Weapon_Machinegun", (byte *)Weapon_Machinegun}, +{"Machinegun_Fire", (byte *)Machinegun_Fire}, +{"Weapon_HyperBlaster", (byte *)Weapon_HyperBlaster}, +{"Weapon_HyperBlaster_Fire", (byte *)Weapon_HyperBlaster_Fire}, +{"Weapon_Blaster", (byte *)Weapon_Blaster}, +{"Weapon_Blaster_Fire", (byte *)Weapon_Blaster_Fire}, +{"Blaster_Fire", (byte *)Blaster_Fire}, +{"Weapon_RocketLauncher", (byte *)Weapon_RocketLauncher}, +{"Weapon_RocketLauncher_Fire", (byte *)Weapon_RocketLauncher_Fire}, +{"Weapon_GrenadeLauncher", (byte *)Weapon_GrenadeLauncher}, +{"weapon_grenadelauncher_fire", (byte *)weapon_grenadelauncher_fire}, +{"Weapon_Grenade", (byte *)Weapon_Grenade}, +{"weapon_grenade_fire", (byte *)weapon_grenade_fire}, +{"Weapon_Generic", (byte *)Weapon_Generic}, +{"Drop_Weapon", (byte *)Drop_Weapon}, +{"Use_Weapon", (byte *)Use_Weapon}, +{"Think_Weapon", (byte *)Think_Weapon}, +{"NoAmmoWeaponChange", (byte *)NoAmmoWeaponChange}, +{"ChangeWeapon", (byte *)ChangeWeapon}, +{"Pickup_Weapon", (byte *)Pickup_Weapon}, +{"PlayerNoise", (byte *)PlayerNoise}, +{"P_ProjectSource", (byte *)P_ProjectSource}, +{"ClientEndServerFrame", (byte *)ClientEndServerFrame}, +{"G_SetClientFrame", (byte *)G_SetClientFrame}, +{"G_SetClientSound", (byte *)G_SetClientSound}, +{"G_SetClientEvent", (byte *)G_SetClientEvent}, +{"G_SetClientEffects", (byte *)G_SetClientEffects}, +{"P_WorldEffects", (byte *)P_WorldEffects}, +{"P_FallingDamage", (byte *)P_FallingDamage}, +{"SV_CalcBlend", (byte *)SV_CalcBlend}, +{"SV_AddBlend", (byte *)SV_AddBlend}, +{"SV_CalcGunOffset", (byte *)SV_CalcGunOffset}, +{"SV_CalcViewOffset", (byte *)SV_CalcViewOffset}, +{"P_DamageFeedback", (byte *)P_DamageFeedback}, +{"SV_CalcRoll", (byte *)SV_CalcRoll}, +{"PlayerTrail_LastSpot", (byte *)PlayerTrail_LastSpot}, +{"PlayerTrail_PickNext", (byte *)PlayerTrail_PickNext}, +{"PlayerTrail_PickFirst", (byte *)PlayerTrail_PickFirst}, +{"PlayerTrail_New", (byte *)PlayerTrail_New}, +{"PlayerTrail_Add", (byte *)PlayerTrail_Add}, +{"PlayerTrail_Init", (byte *)PlayerTrail_Init}, +{"G_SetSpectatorStats", (byte *)G_SetSpectatorStats}, +{"G_CheckChaseStats", (byte *)G_CheckChaseStats}, +{"G_SetStats", (byte *)G_SetStats}, +{"Cmd_Help_f", (byte *)Cmd_Help_f}, +{"HelpComputer", (byte *)HelpComputer}, +{"Cmd_Score_f", (byte *)Cmd_Score_f}, +{"DeathmatchScoreboard", (byte *)DeathmatchScoreboard}, +{"DeathmatchScoreboardMessage", (byte *)DeathmatchScoreboardMessage}, +{"BeginIntermission", (byte *)BeginIntermission}, +{"MoveClientToIntermission", (byte *)MoveClientToIntermission}, +{"ClientBeginServerFrame", (byte *)ClientBeginServerFrame}, +{"ClientThink", (byte *)ClientThink}, +{"PrintPmove", (byte *)PrintPmove}, +{"CheckBlock", (byte *)CheckBlock}, +{"PM_trace", (byte *)PM_trace}, +{"ClientDisconnect", (byte *)ClientDisconnect}, +{"ClientConnect", (byte *)ClientConnect}, +{"ClientUserinfoChanged", (byte *)ClientUserinfoChanged}, +{"ClientBegin", (byte *)ClientBegin}, +{"ClientBeginDeathmatch", (byte *)ClientBeginDeathmatch}, +{"PutClientInServer", (byte *)PutClientInServer}, +{"spectator_respawn", (byte *)spectator_respawn}, +{"respawn", (byte *)respawn}, +{"CopyToBodyQue", (byte *)CopyToBodyQue}, +{"body_die", (byte *)body_die}, +{"InitBodyQue", (byte *)InitBodyQue}, +{"SelectSpawnPoint", (byte *)SelectSpawnPoint}, +{"SelectCoopSpawnPoint", (byte *)SelectCoopSpawnPoint}, +{"SelectDeathmatchSpawnPoint", (byte *)SelectDeathmatchSpawnPoint}, +{"SelectFarthestDeathmatchSpawnPoint", (byte *)SelectFarthestDeathmatchSpawnPoint}, +{"SelectRandomDeathmatchSpawnPoint", (byte *)SelectRandomDeathmatchSpawnPoint}, +{"PlayersRangeFromSpot", (byte *)PlayersRangeFromSpot}, +{"FetchClientEntData", (byte *)FetchClientEntData}, +{"SaveClientData", (byte *)SaveClientData}, +{"InitClientResp", (byte *)InitClientResp}, +{"InitClientPersistant", (byte *)InitClientPersistant}, +{"player_die", (byte *)player_die}, +{"LookAtKiller", (byte *)LookAtKiller}, +{"TossClientWeapon", (byte *)TossClientWeapon}, +{"ClientObituary", (byte *)ClientObituary}, +{"IsNeutral", (byte *)IsNeutral}, +{"IsFemale", (byte *)IsFemale}, +{"player_pain", (byte *)player_pain}, +{"SP_info_player_intermission", (byte *)SP_info_player_intermission}, +{"SP_info_player_coop", (byte *)SP_info_player_coop}, +{"SP_info_player_deathmatch", (byte *)SP_info_player_deathmatch}, +{"SP_info_player_start", (byte *)SP_info_player_start}, +{"SP_CreateCoopSpots", (byte *)SP_CreateCoopSpots}, +{"SP_FixCoopSpots", (byte *)SP_FixCoopSpots}, +{"SP_monster_tank", (byte *)SP_monster_tank}, +{"tank_die", (byte *)tank_die}, +{"tank_dead", (byte *)tank_dead}, +{"tank_attack", (byte *)tank_attack}, +{"tank_doattack_rocket", (byte *)tank_doattack_rocket}, +{"tank_refire_rocket", (byte *)tank_refire_rocket}, +{"tank_poststrike", (byte *)tank_poststrike}, +{"tank_reattack_blaster", (byte *)tank_reattack_blaster}, +{"TankMachineGun", (byte *)TankMachineGun}, +{"TankRocket", (byte *)TankRocket}, +{"TankStrike", (byte *)TankStrike}, +{"TankBlaster", (byte *)TankBlaster}, +{"tank_pain", (byte *)tank_pain}, +{"tank_run", (byte *)tank_run}, +{"tank_walk", (byte *)tank_walk}, +{"tank_stand", (byte *)tank_stand}, +{"tank_idle", (byte *)tank_idle}, +{"tank_windup", (byte *)tank_windup}, +{"tank_thud", (byte *)tank_thud}, +{"tank_footstep", (byte *)tank_footstep}, +{"tank_sight", (byte *)tank_sight}, +{"SP_monster_supertank", (byte *)SP_monster_supertank}, +{"supertank_die", (byte *)supertank_die}, +{"BossExplode", (byte *)BossExplode}, +{"supertank_dead", (byte *)supertank_dead}, +{"supertank_attack", (byte *)supertank_attack}, +{"supertankMachineGun", (byte *)supertankMachineGun}, +{"supertankRocket", (byte *)supertankRocket}, +{"supertank_pain", (byte *)supertank_pain}, +{"supertank_reattack1", (byte *)supertank_reattack1}, +{"supertank_run", (byte *)supertank_run}, +{"supertank_walk", (byte *)supertank_walk}, +{"supertank_forward", (byte *)supertank_forward}, +{"supertank_stand", (byte *)supertank_stand}, +{"supertank_search", (byte *)supertank_search}, +{"TreadSound", (byte *)TreadSound}, +{"SP_monster_soldier_ss", (byte *)SP_monster_soldier_ss}, +{"SP_monster_soldier", (byte *)SP_monster_soldier}, +{"SP_monster_soldier_light", (byte *)SP_monster_soldier_light}, +{"SP_monster_soldier_x", (byte *)SP_monster_soldier_x}, +{"soldier_die", (byte *)soldier_die}, +{"soldier_dead", (byte *)soldier_dead}, +{"soldier_fire7", (byte *)soldier_fire7}, +{"soldier_fire6", (byte *)soldier_fire6}, +{"soldier_dodge", (byte *)soldier_dodge}, +{"soldier_duck_hold", (byte *)soldier_duck_hold}, +{"soldier_sight", (byte *)soldier_sight}, +{"soldier_attack", (byte *)soldier_attack}, +{"soldier_attack6_refire", (byte *)soldier_attack6_refire}, +{"soldier_fire8", (byte *)soldier_fire8}, +{"soldier_fire4", (byte *)soldier_fire4}, +{"soldier_attack3_refire", (byte *)soldier_attack3_refire}, +{"soldier_fire3", (byte *)soldier_fire3}, +{"soldier_duck_up", (byte *)soldier_duck_up}, +{"soldier_duck_down", (byte *)soldier_duck_down}, +{"soldier_attack2_refire2", (byte *)soldier_attack2_refire2}, +{"soldier_attack2_refire1", (byte *)soldier_attack2_refire1}, +{"soldier_fire2", (byte *)soldier_fire2}, +{"soldier_attack1_refire2", (byte *)soldier_attack1_refire2}, +{"soldier_attack1_refire1", (byte *)soldier_attack1_refire1}, +{"soldier_fire1", (byte *)soldier_fire1}, +{"soldier_fire", (byte *)soldier_fire}, +{"soldier_pain", (byte *)soldier_pain}, +{"soldier_run", (byte *)soldier_run}, +{"soldier_walk", (byte *)soldier_walk}, +{"soldier_walk1_random", (byte *)soldier_walk1_random}, +{"soldier_stand", (byte *)soldier_stand}, +{"soldier_cock", (byte *)soldier_cock}, +{"soldier_idle", (byte *)soldier_idle}, +{"SP_monster_parasite", (byte *)SP_monster_parasite}, +{"parasite_die", (byte *)parasite_die}, +{"parasite_dead", (byte *)parasite_dead}, +{"parasite_attack", (byte *)parasite_attack}, +{"parasite_drain_attack", (byte *)parasite_drain_attack}, +{"parasite_drain_attack_ok", (byte *)parasite_drain_attack_ok}, +{"parasite_pain", (byte *)parasite_pain}, +{"parasite_walk", (byte *)parasite_walk}, +{"parasite_start_walk", (byte *)parasite_start_walk}, +{"parasite_run", (byte *)parasite_run}, +{"parasite_start_run", (byte *)parasite_start_run}, +{"parasite_stand", (byte *)parasite_stand}, +{"parasite_idle", (byte *)parasite_idle}, +{"parasite_refidget", (byte *)parasite_refidget}, +{"parasite_do_fidget", (byte *)parasite_do_fidget}, +{"parasite_end_fidget", (byte *)parasite_end_fidget}, +{"parasite_search", (byte *)parasite_search}, +{"parasite_scratch", (byte *)parasite_scratch}, +{"parasite_tap", (byte *)parasite_tap}, +{"parasite_sight", (byte *)parasite_sight}, +{"parasite_reel_in", (byte *)parasite_reel_in}, +{"parasite_launch", (byte *)parasite_launch}, +{"SP_monster_mutant", (byte *)SP_monster_mutant}, +{"mutant_die", (byte *)mutant_die}, +{"mutant_dead", (byte *)mutant_dead}, +{"mutant_pain", (byte *)mutant_pain}, +{"mutant_checkattack", (byte *)mutant_checkattack}, +{"mutant_check_jump", (byte *)mutant_check_jump}, +{"mutant_check_melee", (byte *)mutant_check_melee}, +{"mutant_jump", (byte *)mutant_jump}, +{"mutant_check_landing", (byte *)mutant_check_landing}, +{"mutant_jump_takeoff", (byte *)mutant_jump_takeoff}, +{"mutant_jump_touch", (byte *)mutant_jump_touch}, +{"mutant_melee", (byte *)mutant_melee}, +{"mutant_check_refire", (byte *)mutant_check_refire}, +{"mutant_hit_right", (byte *)mutant_hit_right}, +{"mutant_hit_left", (byte *)mutant_hit_left}, +{"mutant_run", (byte *)mutant_run}, +{"mutant_walk", (byte *)mutant_walk}, +{"mutant_walk_loop", (byte *)mutant_walk_loop}, +{"mutant_idle", (byte *)mutant_idle}, +{"mutant_idle_loop", (byte *)mutant_idle_loop}, +{"mutant_stand", (byte *)mutant_stand}, +{"mutant_swing", (byte *)mutant_swing}, +{"mutant_search", (byte *)mutant_search}, +{"mutant_sight", (byte *)mutant_sight}, +{"mutant_step", (byte *)mutant_step}, +{"M_walkmove", (byte *)M_walkmove}, +{"M_MoveToGoal", (byte *)M_MoveToGoal}, +{"SV_CloseEnough", (byte *)SV_CloseEnough}, +{"SV_NewChaseDir", (byte *)SV_NewChaseDir}, +{"SV_FixCheckBottom", (byte *)SV_FixCheckBottom}, +{"SV_StepDirection", (byte *)SV_StepDirection}, +{"M_ChangeYaw", (byte *)M_ChangeYaw}, +{"SV_movestep", (byte *)SV_movestep}, +{"M_CheckBottom", (byte *)M_CheckBottom}, +{"SP_monster_medic", (byte *)SP_monster_medic}, +{"medic_checkattack", (byte *)medic_checkattack}, +{"medic_attack", (byte *)medic_attack}, +{"medic_hook_retract", (byte *)medic_hook_retract}, +{"medic_cable_attack", (byte *)medic_cable_attack}, +{"medic_hook_launch", (byte *)medic_hook_launch}, +{"medic_continue", (byte *)medic_continue}, +{"medic_dodge", (byte *)medic_dodge}, +{"medic_duck_up", (byte *)medic_duck_up}, +{"medic_duck_hold", (byte *)medic_duck_hold}, +{"medic_duck_down", (byte *)medic_duck_down}, +{"medic_die", (byte *)medic_die}, +{"medic_dead", (byte *)medic_dead}, +{"medic_fire_blaster", (byte *)medic_fire_blaster}, +{"medic_pain", (byte *)medic_pain}, +{"medic_run", (byte *)medic_run}, +{"medic_walk", (byte *)medic_walk}, +{"medic_stand", (byte *)medic_stand}, +{"medic_sight", (byte *)medic_sight}, +{"medic_search", (byte *)medic_search}, +{"medic_idle", (byte *)medic_idle}, +{"medic_FindDeadMonster", (byte *)medic_FindDeadMonster}, +{"SP_misc_insane", (byte *)SP_misc_insane}, +{"insane_die", (byte *)insane_die}, +{"insane_dead", (byte *)insane_dead}, +{"insane_stand", (byte *)insane_stand}, +{"insane_checkup", (byte *)insane_checkup}, +{"insane_checkdown", (byte *)insane_checkdown}, +{"insane_onground", (byte *)insane_onground}, +{"insane_pain", (byte *)insane_pain}, +{"insane_run", (byte *)insane_run}, +{"insane_walk", (byte *)insane_walk}, +{"insane_cross", (byte *)insane_cross}, +{"insane_scream", (byte *)insane_scream}, +{"insane_moan", (byte *)insane_moan}, +{"insane_shake", (byte *)insane_shake}, +{"insane_fist", (byte *)insane_fist}, +{"SP_monster_infantry", (byte *)SP_monster_infantry}, +{"infantry_attack", (byte *)infantry_attack}, +{"infantry_smack", (byte *)infantry_smack}, +{"infantry_swing", (byte *)infantry_swing}, +{"infantry_fire", (byte *)infantry_fire}, +{"infantry_cock_gun", (byte *)infantry_cock_gun}, +{"infantry_dodge", (byte *)infantry_dodge}, +{"infantry_duck_up", (byte *)infantry_duck_up}, +{"infantry_duck_hold", (byte *)infantry_duck_hold}, +{"infantry_duck_down", (byte *)infantry_duck_down}, +{"infantry_die", (byte *)infantry_die}, +{"infantry_dead", (byte *)infantry_dead}, +{"infantry_sight", (byte *)infantry_sight}, +{"InfantryMachineGun", (byte *)InfantryMachineGun}, +{"infantry_pain", (byte *)infantry_pain}, +{"infantry_run", (byte *)infantry_run}, +{"infantry_walk", (byte *)infantry_walk}, +{"infantry_fidget", (byte *)infantry_fidget}, +{"infantry_stand", (byte *)infantry_stand}, +{"SP_monster_hover", (byte *)SP_monster_hover}, +{"hover_die", (byte *)hover_die}, +{"hover_dead", (byte *)hover_dead}, +{"hover_deadthink", (byte *)hover_deadthink}, +{"hover_pain", (byte *)hover_pain}, +{"hover_attack", (byte *)hover_attack}, +{"hover_start_attack", (byte *)hover_start_attack}, +{"hover_walk", (byte *)hover_walk}, +{"hover_run", (byte *)hover_run}, +{"hover_stand", (byte *)hover_stand}, +{"hover_fire_blaster", (byte *)hover_fire_blaster}, +{"hover_reattack", (byte *)hover_reattack}, +{"hover_search", (byte *)hover_search}, +{"hover_sight", (byte *)hover_sight}, +{"SP_monster_gunner", (byte *)SP_monster_gunner}, +{"gunner_refire_chain", (byte *)gunner_refire_chain}, +{"gunner_fire_chain", (byte *)gunner_fire_chain}, +{"gunner_attack", (byte *)gunner_attack}, +{"GunnerGrenade", (byte *)GunnerGrenade}, +{"GunnerFire", (byte *)GunnerFire}, +{"gunner_opengun", (byte *)gunner_opengun}, +{"gunner_dodge", (byte *)gunner_dodge}, +{"gunner_duck_up", (byte *)gunner_duck_up}, +{"gunner_duck_hold", (byte *)gunner_duck_hold}, +{"gunner_duck_down", (byte *)gunner_duck_down}, +{"gunner_die", (byte *)gunner_die}, +{"gunner_dead", (byte *)gunner_dead}, +{"gunner_pain", (byte *)gunner_pain}, +{"gunner_runandshoot", (byte *)gunner_runandshoot}, +{"gunner_run", (byte *)gunner_run}, +{"gunner_walk", (byte *)gunner_walk}, +{"gunner_stand", (byte *)gunner_stand}, +{"gunner_fidget", (byte *)gunner_fidget}, +{"gunner_search", (byte *)gunner_search}, +{"gunner_sight", (byte *)gunner_sight}, +{"gunner_idlesound", (byte *)gunner_idlesound}, +{"SP_monster_gladiator", (byte *)SP_monster_gladiator}, +{"gladiator_die", (byte *)gladiator_die}, +{"gladiator_dead", (byte *)gladiator_dead}, +{"gladiator_pain", (byte *)gladiator_pain}, +{"gladiator_attack", (byte *)gladiator_attack}, +{"GladiatorGun", (byte *)GladiatorGun}, +{"gladiator_melee", (byte *)gladiator_melee}, +{"GaldiatorMelee", (byte *)GaldiatorMelee}, +{"gladiator_run", (byte *)gladiator_run}, +{"gladiator_walk", (byte *)gladiator_walk}, +{"gladiator_stand", (byte *)gladiator_stand}, +{"gladiator_cleaver_swing", (byte *)gladiator_cleaver_swing}, +{"gladiator_search", (byte *)gladiator_search}, +{"gladiator_sight", (byte *)gladiator_sight}, +{"gladiator_idle", (byte *)gladiator_idle}, +{"SP_monster_flyer", (byte *)SP_monster_flyer}, +{"flyer_die", (byte *)flyer_die}, +{"flyer_pain", (byte *)flyer_pain}, +{"flyer_check_melee", (byte *)flyer_check_melee}, +{"flyer_melee", (byte *)flyer_melee}, +{"flyer_nextmove", (byte *)flyer_nextmove}, +{"flyer_setstart", (byte *)flyer_setstart}, +{"flyer_attack", (byte *)flyer_attack}, +{"flyer_loop_melee", (byte *)flyer_loop_melee}, +{"flyer_slash_right", (byte *)flyer_slash_right}, +{"flyer_slash_left", (byte *)flyer_slash_left}, +{"flyer_fireright", (byte *)flyer_fireright}, +{"flyer_fireleft", (byte *)flyer_fireleft}, +{"flyer_fire", (byte *)flyer_fire}, +{"flyer_start", (byte *)flyer_start}, +{"flyer_stop", (byte *)flyer_stop}, +{"flyer_stand", (byte *)flyer_stand}, +{"flyer_walk", (byte *)flyer_walk}, +{"flyer_run", (byte *)flyer_run}, +{"flyer_pop_blades", (byte *)flyer_pop_blades}, +{"flyer_idle", (byte *)flyer_idle}, +{"flyer_sight", (byte *)flyer_sight}, +{"SP_monster_floater", (byte *)SP_monster_floater}, +{"floater_die", (byte *)floater_die}, +{"floater_dead", (byte *)floater_dead}, +{"floater_pain", (byte *)floater_pain}, +{"floater_melee", (byte *)floater_melee}, +{"floater_attack", (byte *)floater_attack}, +{"floater_zap", (byte *)floater_zap}, +{"floater_wham", (byte *)floater_wham}, +{"floater_walk", (byte *)floater_walk}, +{"floater_run", (byte *)floater_run}, +{"floater_stand", (byte *)floater_stand}, +{"floater_fire_blaster", (byte *)floater_fire_blaster}, +{"floater_idle", (byte *)floater_idle}, +{"floater_sight", (byte *)floater_sight}, +{"SP_monster_flipper", (byte *)SP_monster_flipper}, +{"flipper_die", (byte *)flipper_die}, +{"flipper_sight", (byte *)flipper_sight}, +{"flipper_dead", (byte *)flipper_dead}, +{"flipper_pain", (byte *)flipper_pain}, +{"flipper_melee", (byte *)flipper_melee}, +{"flipper_preattack", (byte *)flipper_preattack}, +{"flipper_bite", (byte *)flipper_bite}, +{"flipper_start_run", (byte *)flipper_start_run}, +{"flipper_walk", (byte *)flipper_walk}, +{"flipper_run", (byte *)flipper_run}, +{"flipper_run_loop", (byte *)flipper_run_loop}, +{"flipper_stand", (byte *)flipper_stand}, +{"SP_monster_chick", (byte *)SP_monster_chick}, +{"chick_sight", (byte *)chick_sight}, +{"chick_attack", (byte *)chick_attack}, +{"chick_melee", (byte *)chick_melee}, +{"chick_slash", (byte *)chick_slash}, +{"chick_reslash", (byte *)chick_reslash}, +{"chick_attack1", (byte *)chick_attack1}, +{"chick_rerocket", (byte *)chick_rerocket}, +{"ChickReload", (byte *)ChickReload}, +{"Chick_PreAttack1", (byte *)Chick_PreAttack1}, +{"ChickRocket", (byte *)ChickRocket}, +{"ChickSlash", (byte *)ChickSlash}, +{"chick_dodge", (byte *)chick_dodge}, +{"chick_duck_up", (byte *)chick_duck_up}, +{"chick_duck_hold", (byte *)chick_duck_hold}, +{"chick_duck_down", (byte *)chick_duck_down}, +{"chick_die", (byte *)chick_die}, +{"chick_dead", (byte *)chick_dead}, +{"chick_pain", (byte *)chick_pain}, +{"chick_run", (byte *)chick_run}, +{"chick_walk", (byte *)chick_walk}, +{"chick_stand", (byte *)chick_stand}, +{"chick_fidget", (byte *)chick_fidget}, +{"ChickMoan", (byte *)ChickMoan}, +{"SP_monster_brain", (byte *)SP_monster_brain}, +{"brain_die", (byte *)brain_die}, +{"brain_dead", (byte *)brain_dead}, +{"brain_pain", (byte *)brain_pain}, +{"brain_run", (byte *)brain_run}, +{"brain_melee", (byte *)brain_melee}, +{"brain_chest_closed", (byte *)brain_chest_closed}, +{"brain_tentacle_attack", (byte *)brain_tentacle_attack}, +{"brain_chest_open", (byte *)brain_chest_open}, +{"brain_hit_left", (byte *)brain_hit_left}, +{"brain_swing_left", (byte *)brain_swing_left}, +{"brain_hit_right", (byte *)brain_hit_right}, +{"brain_swing_right", (byte *)brain_swing_right}, +{"brain_dodge", (byte *)brain_dodge}, +{"brain_duck_up", (byte *)brain_duck_up}, +{"brain_duck_hold", (byte *)brain_duck_hold}, +{"brain_duck_down", (byte *)brain_duck_down}, +{"brain_walk", (byte *)brain_walk}, +{"brain_idle", (byte *)brain_idle}, +{"brain_stand", (byte *)brain_stand}, +{"brain_search", (byte *)brain_search}, +{"brain_sight", (byte *)brain_sight}, +{"MakronToss", (byte *)MakronToss}, +{"MakronSpawn", (byte *)MakronSpawn}, +{"SP_monster_makron", (byte *)SP_monster_makron}, +{"MakronPrecache", (byte *)MakronPrecache}, +{"Makron_CheckAttack", (byte *)Makron_CheckAttack}, +{"makron_die", (byte *)makron_die}, +{"makron_dead", (byte *)makron_dead}, +{"makron_torso", (byte *)makron_torso}, +{"makron_torso_think", (byte *)makron_torso_think}, +{"makron_attack", (byte *)makron_attack}, +{"makron_sight", (byte *)makron_sight}, +{"makron_pain", (byte *)makron_pain}, +{"MakronHyperblaster", (byte *)MakronHyperblaster}, +{"MakronRailgun", (byte *)MakronRailgun}, +{"MakronSaveloc", (byte *)MakronSaveloc}, +{"makronBFG", (byte *)makronBFG}, +{"makron_run", (byte *)makron_run}, +{"makron_walk", (byte *)makron_walk}, +{"makron_prerailgun", (byte *)makron_prerailgun}, +{"makron_brainsplorch", (byte *)makron_brainsplorch}, +{"makron_step_right", (byte *)makron_step_right}, +{"makron_step_left", (byte *)makron_step_left}, +{"makron_popup", (byte *)makron_popup}, +{"makron_hit", (byte *)makron_hit}, +{"makron_stand", (byte *)makron_stand}, +{"makron_taunt", (byte *)makron_taunt}, +{"SP_monster_jorg", (byte *)SP_monster_jorg}, +{"Jorg_CheckAttack", (byte *)Jorg_CheckAttack}, +{"jorg_die", (byte *)jorg_die}, +{"jorg_dead", (byte *)jorg_dead}, +{"jorg_attack", (byte *)jorg_attack}, +{"jorg_firebullet", (byte *)jorg_firebullet}, +{"jorg_firebullet_left", (byte *)jorg_firebullet_left}, +{"jorg_firebullet_right", (byte *)jorg_firebullet_right}, +{"jorgBFG", (byte *)jorgBFG}, +{"jorg_pain", (byte *)jorg_pain}, +{"jorg_attack1", (byte *)jorg_attack1}, +{"jorg_reattack1", (byte *)jorg_reattack1}, +{"jorg_run", (byte *)jorg_run}, +{"jorg_walk", (byte *)jorg_walk}, +{"jorg_stand", (byte *)jorg_stand}, +{"jorg_step_right", (byte *)jorg_step_right}, +{"jorg_step_left", (byte *)jorg_step_left}, +{"jorg_death_hit", (byte *)jorg_death_hit}, +{"jorg_idle", (byte *)jorg_idle}, +{"jorg_search", (byte *)jorg_search}, +{"SP_monster_boss3_stand", (byte *)SP_monster_boss3_stand}, +{"Think_Boss3Stand", (byte *)Think_Boss3Stand}, +{"Use_Boss3", (byte *)Use_Boss3}, +{"SP_monster_boss2", (byte *)SP_monster_boss2}, +{"Boss2_CheckAttack", (byte *)Boss2_CheckAttack}, +{"boss2_die", (byte *)boss2_die}, +{"boss2_dead", (byte *)boss2_dead}, +{"boss2_pain", (byte *)boss2_pain}, +{"boss2_reattack_mg", (byte *)boss2_reattack_mg}, +{"boss2_attack_mg", (byte *)boss2_attack_mg}, +{"boss2_attack", (byte *)boss2_attack}, +{"boss2_walk", (byte *)boss2_walk}, +{"boss2_run", (byte *)boss2_run}, +{"boss2_stand", (byte *)boss2_stand}, +{"Boss2MachineGun", (byte *)Boss2MachineGun}, +{"boss2_firebullet_left", (byte *)boss2_firebullet_left}, +{"boss2_firebullet_right", (byte *)boss2_firebullet_right}, +{"Boss2Rocket", (byte *)Boss2Rocket}, +{"boss2_search", (byte *)boss2_search}, +{"SP_monster_berserk", (byte *)SP_monster_berserk}, +{"berserk_die", (byte *)berserk_die}, +{"berserk_dead", (byte *)berserk_dead}, +{"berserk_pain", (byte *)berserk_pain}, +{"berserk_melee", (byte *)berserk_melee}, +{"berserk_strike", (byte *)berserk_strike}, +{"berserk_attack_club", (byte *)berserk_attack_club}, +{"berserk_swing", (byte *)berserk_swing}, +{"berserk_attack_spike", (byte *)berserk_attack_spike}, +{"berserk_run", (byte *)berserk_run}, +{"berserk_walk", (byte *)berserk_walk}, +{"berserk_fidget", (byte *)berserk_fidget}, +{"berserk_stand", (byte *)berserk_stand}, +{"berserk_search", (byte *)berserk_search}, +{"berserk_sight", (byte *)berserk_sight}, +{"SP_target_actor", (byte *)SP_target_actor}, +{"target_actor_touch", (byte *)target_actor_touch}, +{"SP_misc_actor", (byte *)SP_misc_actor}, +{"actor_use", (byte *)actor_use}, +{"actor_attack", (byte *)actor_attack}, +{"actor_fire", (byte *)actor_fire}, +{"actor_die", (byte *)actor_die}, +{"actor_dead", (byte *)actor_dead}, +{"actorMachineGun", (byte *)actorMachineGun}, +{"actor_pain", (byte *)actor_pain}, +{"actor_run", (byte *)actor_run}, +{"actor_walk", (byte *)actor_walk}, +{"actor_stand", (byte *)actor_stand}, +{"fire_bfg", (byte *)fire_bfg}, +{"bfg_think", (byte *)bfg_think}, +{"bfg_touch", (byte *)bfg_touch}, +{"bfg_explode", (byte *)bfg_explode}, +{"fire_rail", (byte *)fire_rail}, +{"fire_rocket", (byte *)fire_rocket}, +{"rocket_touch", (byte *)rocket_touch}, +{"fire_grenade2", (byte *)fire_grenade2}, +{"fire_grenade", (byte *)fire_grenade}, +{"Grenade_Touch", (byte *)Grenade_Touch}, +{"Grenade_Explode", (byte *)Grenade_Explode}, +{"fire_blaster", (byte *)fire_blaster}, +{"blaster_touch", (byte *)blaster_touch}, +{"fire_shotgun", (byte *)fire_shotgun}, +{"fire_bullet", (byte *)fire_bullet}, +{"fire_lead", (byte *)fire_lead}, +{"fire_hit", (byte *)fire_hit}, +{"check_dodge", (byte *)check_dodge}, +{"KillBox", (byte *)KillBox}, +{"G_TouchSolids", (byte *)G_TouchSolids}, +{"G_TouchTriggers", (byte *)G_TouchTriggers}, +{"G_FreeEdict", (byte *)G_FreeEdict}, +{"G_Spawn", (byte *)G_Spawn}, +{"G_InitEdict", (byte *)G_InitEdict}, +{"G_CopyString", (byte *)G_CopyString}, +{"vectoangles", (byte *)vectoangles}, +{"vectoyaw", (byte *)vectoyaw}, +{"G_SetMovedir", (byte *)G_SetMovedir}, +{"vtos", (byte *)vtos}, +{"tv", (byte *)tv}, +{"G_UseTargets", (byte *)G_UseTargets}, +{"Think_Delay", (byte *)Think_Delay}, +{"G_PickTarget", (byte *)G_PickTarget}, +{"findradius", (byte *)findradius}, +{"G_Find", (byte *)G_Find}, +{"G_ProjectSource", (byte *)G_ProjectSource}, +{"SP_turret_driver", (byte *)SP_turret_driver}, +{"turret_driver_link", (byte *)turret_driver_link}, +{"turret_driver_think", (byte *)turret_driver_think}, +{"turret_driver_die", (byte *)turret_driver_die}, +{"SP_turret_base", (byte *)SP_turret_base}, +{"SP_turret_breach", (byte *)SP_turret_breach}, +{"turret_breach_finish_init", (byte *)turret_breach_finish_init}, +{"turret_breach_think", (byte *)turret_breach_think}, +{"turret_breach_fire", (byte *)turret_breach_fire}, +{"turret_blocked", (byte *)turret_blocked}, +{"SnapToEights", (byte *)SnapToEights}, +{"AnglesNormalize", (byte *)AnglesNormalize}, +{"SP_trigger_monsterjump", (byte *)SP_trigger_monsterjump}, +{"trigger_monsterjump_touch", (byte *)trigger_monsterjump_touch}, +{"SP_trigger_gravity", (byte *)SP_trigger_gravity}, +{"trigger_gravity_touch", (byte *)trigger_gravity_touch}, +{"SP_trigger_hurt", (byte *)SP_trigger_hurt}, +{"hurt_use", (byte *)hurt_use}, +{"hurt_touch", (byte *)hurt_touch}, +{"SP_trigger_push", (byte *)SP_trigger_push}, +{"trigger_push_touch", (byte *)trigger_push_touch}, +{"SP_trigger_always", (byte *)SP_trigger_always}, +{"SP_trigger_counter", (byte *)SP_trigger_counter}, +{"trigger_counter_use", (byte *)trigger_counter_use}, +{"SP_trigger_key", (byte *)SP_trigger_key}, +{"trigger_key_use", (byte *)trigger_key_use}, +{"SP_trigger_relay", (byte *)SP_trigger_relay}, +{"trigger_relay_use", (byte *)trigger_relay_use}, +{"SP_trigger_once", (byte *)SP_trigger_once}, +{"SP_trigger_multiple", (byte *)SP_trigger_multiple}, +{"trigger_enable", (byte *)trigger_enable}, +{"Touch_Multi", (byte *)Touch_Multi}, +{"Use_Multi", (byte *)Use_Multi}, +{"multi_trigger", (byte *)multi_trigger}, +{"multi_wait", (byte *)multi_wait}, +{"InitTrigger", (byte *)InitTrigger}, +{"SP_target_earthquake", (byte *)SP_target_earthquake}, +{"target_earthquake_use", (byte *)target_earthquake_use}, +{"target_earthquake_think", (byte *)target_earthquake_think}, +{"SP_target_lightramp", (byte *)SP_target_lightramp}, +{"target_lightramp_use", (byte *)target_lightramp_use}, +{"target_lightramp_think", (byte *)target_lightramp_think}, +{"SP_target_laser", (byte *)SP_target_laser}, +{"target_laser_start", (byte *)target_laser_start}, +{"target_laser_use", (byte *)target_laser_use}, +{"target_laser_off", (byte *)target_laser_off}, +{"target_laser_on", (byte *)target_laser_on}, +{"target_laser_think", (byte *)target_laser_think}, +{"SP_target_crosslevel_target", (byte *)SP_target_crosslevel_target}, +{"target_crosslevel_target_think", (byte *)target_crosslevel_target_think}, +{"SP_target_crosslevel_trigger", (byte *)SP_target_crosslevel_trigger}, +{"trigger_crosslevel_trigger_use", (byte *)trigger_crosslevel_trigger_use}, +{"SP_target_blaster", (byte *)SP_target_blaster}, +{"use_target_blaster", (byte *)use_target_blaster}, +{"SP_target_spawner", (byte *)SP_target_spawner}, +{"use_target_spawner", (byte *)use_target_spawner}, +{"SP_target_splash", (byte *)SP_target_splash}, +{"use_target_splash", (byte *)use_target_splash}, +{"SP_target_changelevel", (byte *)SP_target_changelevel}, +{"use_target_changelevel", (byte *)use_target_changelevel}, +{"SP_target_explosion", (byte *)SP_target_explosion}, +{"use_target_explosion", (byte *)use_target_explosion}, +{"target_explosion_explode", (byte *)target_explosion_explode}, +{"SP_target_goal", (byte *)SP_target_goal}, +{"use_target_goal", (byte *)use_target_goal}, +{"SP_target_secret", (byte *)SP_target_secret}, +{"use_target_secret", (byte *)use_target_secret}, +{"SP_target_help", (byte *)SP_target_help}, +{"Use_Target_Help", (byte *)Use_Target_Help}, +{"SP_target_speaker", (byte *)SP_target_speaker}, +{"Use_Target_Speaker", (byte *)Use_Target_Speaker}, +{"SP_target_temp_entity", (byte *)SP_target_temp_entity}, +{"Use_Target_Tent", (byte *)Use_Target_Tent}, +{"ServerCommand", (byte *)ServerCommand}, +{"SVCmd_WriteIP_f", (byte *)SVCmd_WriteIP_f}, +{"SVCmd_ListIP_f", (byte *)SVCmd_ListIP_f}, +{"SVCmd_RemoveIP_f", (byte *)SVCmd_RemoveIP_f}, +{"SVCmd_AddIP_f", (byte *)SVCmd_AddIP_f}, +{"SV_FilterPacket", (byte *)SV_FilterPacket}, +{"Svcmd_Test_f", (byte *)Svcmd_Test_f}, +{"SP_worldspawn", (byte *)SP_worldspawn}, +{"SpawnEntities", (byte *)SpawnEntities}, +{"G_FindTeams", (byte *)G_FindTeams}, +{"ED_ParseEdict", (byte *)ED_ParseEdict}, +{"ED_ParseField", (byte *)ED_ParseField}, +{"ED_NewString", (byte *)ED_NewString}, +{"ED_CallSpawn", (byte *)ED_CallSpawn}, +{"G_RunEntity", (byte *)G_RunEntity}, +{"SV_Physics_Step", (byte *)SV_Physics_Step}, +{"SV_AddRotationalFriction", (byte *)SV_AddRotationalFriction}, +{"SV_Physics_Toss", (byte *)SV_Physics_Toss}, +{"SV_Physics_Noclip", (byte *)SV_Physics_Noclip}, +{"SV_Physics_None", (byte *)SV_Physics_None}, +{"SV_Physics_Pusher", (byte *)SV_Physics_Pusher}, +{"SV_Push", (byte *)SV_Push}, +{"SV_PushEntity", (byte *)SV_PushEntity}, +{"SV_AddGravity", (byte *)SV_AddGravity}, +{"SV_FlyMove", (byte *)SV_FlyMove}, +{"ClipVelocity", (byte *)ClipVelocity}, +{"SV_Impact", (byte *)SV_Impact}, +{"SV_RunThink", (byte *)SV_RunThink}, +{"SV_CheckVelocity", (byte *)SV_CheckVelocity}, +{"SV_TestEntityPosition", (byte *)SV_TestEntityPosition}, +{"swimmonster_start", (byte *)swimmonster_start}, +{"swimmonster_start_go", (byte *)swimmonster_start_go}, +{"flymonster_start", (byte *)flymonster_start}, +{"flymonster_start_go", (byte *)flymonster_start_go}, +{"walkmonster_start", (byte *)walkmonster_start}, +{"walkmonster_start_go", (byte *)walkmonster_start_go}, +{"monster_start_go", (byte *)monster_start_go}, +{"monster_start", (byte *)monster_start}, +{"monster_death_use", (byte *)monster_death_use}, +{"monster_triggered_start", (byte *)monster_triggered_start}, +{"monster_triggered_spawn_use", (byte *)monster_triggered_spawn_use}, +{"monster_triggered_spawn", (byte *)monster_triggered_spawn}, +{"monster_use", (byte *)monster_use}, +{"monster_think", (byte *)monster_think}, +{"M_MoveFrame", (byte *)M_MoveFrame}, +{"M_SetEffects", (byte *)M_SetEffects}, +{"M_droptofloor", (byte *)M_droptofloor}, +{"M_WorldEffects", (byte *)M_WorldEffects}, +{"M_CatagorizePosition", (byte *)M_CatagorizePosition}, +{"M_CheckGround", (byte *)M_CheckGround}, +{"AttackFinished", (byte *)AttackFinished}, +{"M_FlyCheck", (byte *)M_FlyCheck}, +{"M_FliesOn", (byte *)M_FliesOn}, +{"M_FliesOff", (byte *)M_FliesOff}, +{"monster_fire_bfg", (byte *)monster_fire_bfg}, +{"monster_fire_railgun", (byte *)monster_fire_railgun}, +{"monster_fire_rocket", (byte *)monster_fire_rocket}, +{"monster_fire_grenade", (byte *)monster_fire_grenade}, +{"monster_fire_blaster", (byte *)monster_fire_blaster}, +{"monster_fire_shotgun", (byte *)monster_fire_shotgun}, +{"monster_fire_bullet", (byte *)monster_fire_bullet}, +{"SP_misc_teleporter_dest", (byte *)SP_misc_teleporter_dest}, +{"SP_misc_teleporter", (byte *)SP_misc_teleporter}, +{"teleporter_touch", (byte *)teleporter_touch}, +{"SP_func_clock", (byte *)SP_func_clock}, +{"func_clock_use", (byte *)func_clock_use}, +{"func_clock_think", (byte *)func_clock_think}, +{"func_clock_format_countdown", (byte *)func_clock_format_countdown}, +{"func_clock_reset", (byte *)func_clock_reset}, +{"SP_target_string", (byte *)SP_target_string}, +{"target_string_use", (byte *)target_string_use}, +{"SP_target_character", (byte *)SP_target_character}, +{"SP_misc_gib_head", (byte *)SP_misc_gib_head}, +{"SP_misc_gib_leg", (byte *)SP_misc_gib_leg}, +{"SP_misc_gib_arm", (byte *)SP_misc_gib_arm}, +{"SP_light_mine2", (byte *)SP_light_mine2}, +{"SP_light_mine1", (byte *)SP_light_mine1}, +{"SP_misc_satellite_dish", (byte *)SP_misc_satellite_dish}, +{"misc_satellite_dish_use", (byte *)misc_satellite_dish_use}, +{"misc_satellite_dish_think", (byte *)misc_satellite_dish_think}, +{"SP_misc_strogg_ship", (byte *)SP_misc_strogg_ship}, +{"misc_strogg_ship_use", (byte *)misc_strogg_ship_use}, +{"SP_misc_viper_bomb", (byte *)SP_misc_viper_bomb}, +{"misc_viper_bomb_use", (byte *)misc_viper_bomb_use}, +{"misc_viper_bomb_prethink", (byte *)misc_viper_bomb_prethink}, +{"misc_viper_bomb_touch", (byte *)misc_viper_bomb_touch}, +{"SP_misc_bigviper", (byte *)SP_misc_bigviper}, +{"SP_misc_viper", (byte *)SP_misc_viper}, +{"misc_viper_use", (byte *)misc_viper_use}, +{"SP_misc_deadsoldier", (byte *)SP_misc_deadsoldier}, +{"misc_deadsoldier_die", (byte *)misc_deadsoldier_die}, +{"SP_misc_banner", (byte *)SP_misc_banner}, +{"misc_banner_think", (byte *)misc_banner_think}, +{"SP_monster_commander_body", (byte *)SP_monster_commander_body}, +{"commander_body_drop", (byte *)commander_body_drop}, +{"commander_body_use", (byte *)commander_body_use}, +{"commander_body_think", (byte *)commander_body_think}, +{"SP_misc_easterchick2", (byte *)SP_misc_easterchick2}, +{"misc_easterchick2_think", (byte *)misc_easterchick2_think}, +{"SP_misc_easterchick", (byte *)SP_misc_easterchick}, +{"misc_easterchick_think", (byte *)misc_easterchick_think}, +{"SP_misc_eastertank", (byte *)SP_misc_eastertank}, +{"misc_eastertank_think", (byte *)misc_eastertank_think}, +{"SP_misc_blackhole", (byte *)SP_misc_blackhole}, +{"misc_blackhole_transparent", (byte *)misc_blackhole_transparent}, +{"misc_blackhole_think", (byte *)misc_blackhole_think}, +{"misc_blackhole_use", (byte *)misc_blackhole_use}, +{"SP_misc_explobox", (byte *)SP_misc_explobox}, +{"barrel_delay", (byte *)barrel_delay}, +{"barrel_explode", (byte *)barrel_explode}, +{"barrel_touch", (byte *)barrel_touch}, +{"SP_func_explosive", (byte *)SP_func_explosive}, +{"func_explosive_spawn", (byte *)func_explosive_spawn}, +{"func_explosive_use", (byte *)func_explosive_use}, +{"func_explosive_explode", (byte *)func_explosive_explode}, +{"SP_func_object", (byte *)SP_func_object}, +{"func_object_use", (byte *)func_object_use}, +{"func_object_release", (byte *)func_object_release}, +{"func_object_touch", (byte *)func_object_touch}, +{"SP_func_wall", (byte *)SP_func_wall}, +{"func_wall_use", (byte *)func_wall_use}, +{"SP_light", (byte *)SP_light}, +{"light_use", (byte *)light_use}, +{"SP_info_notnull", (byte *)SP_info_notnull}, +{"SP_info_null", (byte *)SP_info_null}, +{"SP_viewthing", (byte *)SP_viewthing}, +{"TH_viewthing", (byte *)TH_viewthing}, +{"SP_point_combat", (byte *)SP_point_combat}, +{"point_combat_touch", (byte *)point_combat_touch}, +{"SP_path_corner", (byte *)SP_path_corner}, +{"path_corner_touch", (byte *)path_corner_touch}, +{"BecomeExplosion2", (byte *)BecomeExplosion2}, +{"BecomeExplosion1", (byte *)BecomeExplosion1}, +{"ThrowDebris", (byte *)ThrowDebris}, +{"debris_die", (byte *)debris_die}, +{"ThrowClientHead", (byte *)ThrowClientHead}, +{"ThrowHead", (byte *)ThrowHead}, +{"ThrowGib", (byte *)ThrowGib}, +{"gib_die", (byte *)gib_die}, +{"gib_touch", (byte *)gib_touch}, +{"gib_think", (byte *)gib_think}, +{"ClipGibVelocity", (byte *)ClipGibVelocity}, +{"VelocityForDamage", (byte *)VelocityForDamage}, +{"SP_func_areaportal", (byte *)SP_func_areaportal}, +{"Use_Areaportal", (byte *)Use_Areaportal}, +{"G_RunFrame", (byte *)G_RunFrame}, +{"ExitLevel", (byte *)ExitLevel}, +{"CheckDMRules", (byte *)CheckDMRules}, +{"CheckNeedPass", (byte *)CheckNeedPass}, +{"EndDMLevel", (byte *)EndDMLevel}, +{"CreateTargetChangeLevel", (byte *)CreateTargetChangeLevel}, +{"ClientEndServerFrames", (byte *)ClientEndServerFrames}, +{"Com_Printf", (byte *)Com_Printf}, +{"Sys_Error", (byte *)Sys_Error}, +{"GetGameAPI", (byte *)GetGameAPI}, +{"ShutdownGame", (byte *)ShutdownGame}, +{"SetItemNames", (byte *)SetItemNames}, +{"InitItems", (byte *)InitItems}, +{"SP_item_health_mega", (byte *)SP_item_health_mega}, +{"SP_item_health_large", (byte *)SP_item_health_large}, +{"SP_item_health_small", (byte *)SP_item_health_small}, +{"SP_item_health", (byte *)SP_item_health}, +{"SpawnItem", (byte *)SpawnItem}, +{"PrecacheItem", (byte *)PrecacheItem}, +{"droptofloor", (byte *)droptofloor}, +{"Use_Item", (byte *)Use_Item}, +{"Drop_Item", (byte *)Drop_Item}, +{"drop_make_touchable", (byte *)drop_make_touchable}, +{"drop_temp_touch", (byte *)drop_temp_touch}, +{"Touch_Item", (byte *)Touch_Item}, +{"Drop_PowerArmor", (byte *)Drop_PowerArmor}, +{"Pickup_PowerArmor", (byte *)Pickup_PowerArmor}, +{"Use_PowerArmor", (byte *)Use_PowerArmor}, +{"PowerArmorType", (byte *)PowerArmorType}, +{"Pickup_Armor", (byte *)Pickup_Armor}, +{"ArmorIndex", (byte *)ArmorIndex}, +{"Pickup_Health", (byte *)Pickup_Health}, +{"MegaHealth_think", (byte *)MegaHealth_think}, +{"Drop_Ammo", (byte *)Drop_Ammo}, +{"Pickup_Ammo", (byte *)Pickup_Ammo}, +{"Add_Ammo", (byte *)Add_Ammo}, +{"Pickup_Key", (byte *)Pickup_Key}, +{"Use_Silencer", (byte *)Use_Silencer}, +{"Use_Invulnerability", (byte *)Use_Invulnerability}, +{"Use_Envirosuit", (byte *)Use_Envirosuit}, +{"Use_Breather", (byte *)Use_Breather}, +{"Use_Quad", (byte *)Use_Quad}, +{"Pickup_Pack", (byte *)Pickup_Pack}, +{"Pickup_Bandolier", (byte *)Pickup_Bandolier}, +{"Pickup_AncientHead", (byte *)Pickup_AncientHead}, +{"Pickup_Adrenaline", (byte *)Pickup_Adrenaline}, +{"Drop_General", (byte *)Drop_General}, +{"Pickup_Powerup", (byte *)Pickup_Powerup}, +{"SetRespawn", (byte *)SetRespawn}, +{"DoRespawn", (byte *)DoRespawn}, +{"FindItem", (byte *)FindItem}, +{"FindItemByClassname", (byte *)FindItemByClassname}, +{"GetItemByIndex", (byte *)GetItemByIndex}, +{"SP_func_killbox", (byte *)SP_func_killbox}, +{"use_killbox", (byte *)use_killbox}, +{"SP_func_door_secret", (byte *)SP_func_door_secret}, +{"door_secret_die", (byte *)door_secret_die}, +{"door_secret_blocked", (byte *)door_secret_blocked}, +{"door_secret_done", (byte *)door_secret_done}, +{"door_secret_move6", (byte *)door_secret_move6}, +{"door_secret_move5", (byte *)door_secret_move5}, +{"door_secret_move4", (byte *)door_secret_move4}, +{"door_secret_move3", (byte *)door_secret_move3}, +{"door_secret_move2", (byte *)door_secret_move2}, +{"door_secret_move1", (byte *)door_secret_move1}, +{"door_secret_use", (byte *)door_secret_use}, +{"SP_func_conveyor", (byte *)SP_func_conveyor}, +{"func_conveyor_use", (byte *)func_conveyor_use}, +{"SP_func_timer", (byte *)SP_func_timer}, +{"func_timer_use", (byte *)func_timer_use}, +{"func_timer_think", (byte *)func_timer_think}, +{"SP_trigger_elevator", (byte *)SP_trigger_elevator}, +{"trigger_elevator_init", (byte *)trigger_elevator_init}, +{"trigger_elevator_use", (byte *)trigger_elevator_use}, +{"SP_func_train", (byte *)SP_func_train}, +{"train_use", (byte *)train_use}, +{"func_train_find", (byte *)func_train_find}, +{"train_resume", (byte *)train_resume}, +{"train_next", (byte *)train_next}, +{"train_wait", (byte *)train_wait}, +{"train_blocked", (byte *)train_blocked}, +{"SP_func_water", (byte *)SP_func_water}, +{"SP_func_door_rotating", (byte *)SP_func_door_rotating}, +{"SP_func_door", (byte *)SP_func_door}, +{"door_touch", (byte *)door_touch}, +{"door_killed", (byte *)door_killed}, +{"door_blocked", (byte *)door_blocked}, +{"Think_SpawnDoorTrigger", (byte *)Think_SpawnDoorTrigger}, +{"Think_CalcMoveSpeed", (byte *)Think_CalcMoveSpeed}, +{"Touch_DoorTrigger", (byte *)Touch_DoorTrigger}, +{"door_use", (byte *)door_use}, +{"door_go_up", (byte *)door_go_up}, +{"door_go_down", (byte *)door_go_down}, +{"door_hit_bottom", (byte *)door_hit_bottom}, +{"door_hit_top", (byte *)door_hit_top}, +{"door_use_areaportals", (byte *)door_use_areaportals}, +{"SP_func_button", (byte *)SP_func_button}, +{"button_killed", (byte *)button_killed}, +{"button_touch", (byte *)button_touch}, +{"button_use", (byte *)button_use}, +{"button_fire", (byte *)button_fire}, +{"button_wait", (byte *)button_wait}, +{"button_return", (byte *)button_return}, +{"button_done", (byte *)button_done}, +{"SP_func_rotating", (byte *)SP_func_rotating}, +{"rotating_use", (byte *)rotating_use}, +{"rotating_touch", (byte *)rotating_touch}, +{"rotating_blocked", (byte *)rotating_blocked}, +{"SP_func_plat", (byte *)SP_func_plat}, +{"plat_spawn_inside_trigger", (byte *)plat_spawn_inside_trigger}, +{"Touch_Plat_Center", (byte *)Touch_Plat_Center}, +{"Use_Plat", (byte *)Use_Plat}, +{"plat_blocked", (byte *)plat_blocked}, +{"plat_go_up", (byte *)plat_go_up}, +{"plat_go_down", (byte *)plat_go_down}, +{"plat_hit_bottom", (byte *)plat_hit_bottom}, +{"plat_hit_top", (byte *)plat_hit_top}, +{"Think_AccelMove", (byte *)Think_AccelMove}, +{"plat_Accelerate", (byte *)plat_Accelerate}, +{"plat_CalcAcceleratedMove", (byte *)plat_CalcAcceleratedMove}, +{"AngleMove_Calc", (byte *)AngleMove_Calc}, +{"AngleMove_Begin", (byte *)AngleMove_Begin}, +{"AngleMove_Final", (byte *)AngleMove_Final}, +{"AngleMove_Done", (byte *)AngleMove_Done}, +{"Move_Calc", (byte *)Move_Calc}, +{"Move_Begin", (byte *)Move_Begin}, +{"Move_Final", (byte *)Move_Final}, +{"Move_Done", (byte *)Move_Done}, +{"T_RadiusDamage", (byte *)T_RadiusDamage}, +{"T_Damage", (byte *)T_Damage}, +{"M_ReactToDamage", (byte *)M_ReactToDamage}, +{"CheckArmor", (byte *)CheckArmor}, +{"CheckPowerArmor", (byte *)CheckPowerArmor}, +{"SpawnDamage", (byte *)SpawnDamage}, +{"Killed", (byte *)Killed}, +{"CanDamage", (byte *)CanDamage}, +{"ClientCommand", (byte *)ClientCommand}, +{"Cmd_PlayerList_f", (byte *)Cmd_PlayerList_f}, +{"Cmd_Say_f", (byte *)Cmd_Say_f}, +{"Cmd_Wave_f", (byte *)Cmd_Wave_f}, +{"Cmd_Players_f", (byte *)Cmd_Players_f}, +{"PlayerSort", (byte *)PlayerSort}, +{"Cmd_PutAway_f", (byte *)Cmd_PutAway_f}, +{"Cmd_Kill_f", (byte *)Cmd_Kill_f}, +{"Cmd_InvDrop_f", (byte *)Cmd_InvDrop_f}, +{"Cmd_WeapLast_f", (byte *)Cmd_WeapLast_f}, +{"Cmd_WeapNext_f", (byte *)Cmd_WeapNext_f}, +{"Cmd_WeapPrev_f", (byte *)Cmd_WeapPrev_f}, +{"Cmd_InvUse_f", (byte *)Cmd_InvUse_f}, +{"Cmd_Inven_f", (byte *)Cmd_Inven_f}, +{"Cmd_Drop_f", (byte *)Cmd_Drop_f}, +{"Cmd_Use_f", (byte *)Cmd_Use_f}, +{"Cmd_Noclip_f", (byte *)Cmd_Noclip_f}, +{"Cmd_Notarget_f", (byte *)Cmd_Notarget_f}, +{"Cmd_God_f", (byte *)Cmd_God_f}, +{"Cmd_Give_f", (byte *)Cmd_Give_f}, +{"ValidateSelectedItem", (byte *)ValidateSelectedItem}, +{"SelectPrevItem", (byte *)SelectPrevItem}, +{"SelectNextItem", (byte *)SelectNextItem}, +{"OnSameTeam", (byte *)OnSameTeam}, +{"ClientTeam", (byte *)ClientTeam}, +{"GetChaseTarget", (byte *)GetChaseTarget}, +{"ChasePrev", (byte *)ChasePrev}, +{"ChaseNext", (byte *)ChaseNext}, +{"UpdateChaseCam", (byte *)UpdateChaseCam}, +{"ai_run", (byte *)ai_run}, +{"ai_checkattack", (byte *)ai_checkattack}, +{"ai_run_slide", (byte *)ai_run_slide}, +{"ai_run_missile", (byte *)ai_run_missile}, +{"ai_run_melee", (byte *)ai_run_melee}, +{"M_CheckAttack", (byte *)M_CheckAttack}, +{"FacingIdeal", (byte *)FacingIdeal}, +{"FindTarget", (byte *)FindTarget}, +{"FoundTarget", (byte *)FoundTarget}, +{"HuntTarget", (byte *)HuntTarget}, +{"infront", (byte *)infront}, +{"visible", (byte *)visible}, +{"range", (byte *)range}, +{"ai_turn", (byte *)ai_turn}, +{"ai_charge", (byte *)ai_charge}, +{"ai_walk", (byte *)ai_walk}, +{"ai_stand", (byte *)ai_stand}, +{"ai_move", (byte *)ai_move}, +{"AI_SetSightClient", (byte *)AI_SetSightClient}, +{0, 0} diff --git a/src/game/baseq2/savegame/tables/gamemmove_decs.h b/src/game/baseq2/savegame/tables/gamemmove_decs.h new file mode 100644 index 00000000..b5c9eb12 --- /dev/null +++ b/src/game/baseq2/savegame/tables/gamemmove_decs.h @@ -0,0 +1,286 @@ +extern mmove_t tank_move_death ; +extern mmove_t tank_move_attack_chain ; +extern mmove_t tank_move_attack_post_rocket ; +extern mmove_t tank_move_attack_fire_rocket ; +extern mmove_t tank_move_attack_pre_rocket ; +extern mmove_t tank_move_attack_strike ; +extern mmove_t tank_move_attack_post_blast ; +extern mmove_t tank_move_reattack_blast ; +extern mmove_t tank_move_attack_blast ; +extern mmove_t tank_move_pain3 ; +extern mmove_t tank_move_pain2 ; +extern mmove_t tank_move_pain1 ; +extern mmove_t tank_move_stop_run ; +extern mmove_t tank_move_run ; +extern mmove_t tank_move_start_run ; +extern mmove_t tank_move_stop_walk ; +extern mmove_t tank_move_walk ; +extern mmove_t tank_move_start_walk ; +extern mmove_t tank_move_stand ; +extern mmove_t supertank_move_end_attack1 ; +extern mmove_t supertank_move_attack1 ; +extern mmove_t supertank_move_attack2 ; +extern mmove_t supertank_move_attack3 ; +extern mmove_t supertank_move_attack4 ; +extern mmove_t supertank_move_backward ; +extern mmove_t supertank_move_death ; +extern mmove_t supertank_move_pain1 ; +extern mmove_t supertank_move_pain2 ; +extern mmove_t supertank_move_pain3 ; +extern mmove_t supertank_move_turn_left ; +extern mmove_t supertank_move_turn_right ; +extern mmove_t supertank_move_forward ; +extern mmove_t supertank_move_run ; +extern mmove_t supertank_move_stand ; +extern mmove_t soldier_move_death6 ; +extern mmove_t soldier_move_death5 ; +extern mmove_t soldier_move_death4 ; +extern mmove_t soldier_move_death3 ; +extern mmove_t soldier_move_death2 ; +extern mmove_t soldier_move_death1 ; +extern mmove_t soldier_move_duck ; +extern mmove_t soldier_move_attack6 ; +extern mmove_t soldier_move_attack4 ; +extern mmove_t soldier_move_attack3 ; +extern mmove_t soldier_move_attack2 ; +extern mmove_t soldier_move_attack1 ; +extern mmove_t soldier_move_pain4 ; +extern mmove_t soldier_move_pain3 ; +extern mmove_t soldier_move_pain2 ; +extern mmove_t soldier_move_pain1 ; +extern mmove_t soldier_move_run ; +extern mmove_t soldier_move_start_run ; +extern mmove_t soldier_move_walk2 ; +extern mmove_t soldier_move_walk1 ; +extern mmove_t soldier_move_stand3 ; +extern mmove_t soldier_move_stand1 ; +extern mmove_t parasite_move_death ; +extern mmove_t parasite_move_break ; +extern mmove_t parasite_move_drain ; +extern mmove_t parasite_move_pain1 ; +extern mmove_t parasite_move_stop_walk ; +extern mmove_t parasite_move_start_walk ; +extern mmove_t parasite_move_walk ; +extern mmove_t parasite_move_stop_run ; +extern mmove_t parasite_move_start_run ; +extern mmove_t parasite_move_run ; +extern mmove_t parasite_move_stand ; +extern mmove_t parasite_move_end_fidget ; +extern mmove_t parasite_move_fidget ; +extern mmove_t parasite_move_start_fidget ; +extern mmove_t mutant_move_death2 ; +extern mmove_t mutant_move_death1 ; +extern mmove_t mutant_move_pain3 ; +extern mmove_t mutant_move_pain2 ; +extern mmove_t mutant_move_pain1 ; +extern mmove_t mutant_move_jump ; +extern mmove_t mutant_move_attack ; +extern mmove_t mutant_move_run ; +extern mmove_t mutant_move_start_walk ; +extern mmove_t mutant_move_walk ; +extern mmove_t mutant_move_idle ; +extern mmove_t mutant_move_stand ; +extern mmove_t medic_move_attackCable ; +extern mmove_t medic_move_attackBlaster ; +extern mmove_t medic_move_attackHyperBlaster ; +extern mmove_t medic_move_duck ; +extern mmove_t medic_move_death ; +extern mmove_t medic_move_pain2 ; +extern mmove_t medic_move_pain1 ; +extern mmove_t medic_move_run ; +extern mmove_t medic_move_walk ; +extern mmove_t medic_move_stand ; +extern mmove_t insane_move_struggle_cross ; +extern mmove_t insane_move_cross ; +extern mmove_t insane_move_crawl_death ; +extern mmove_t insane_move_crawl_pain ; +extern mmove_t insane_move_runcrawl ; +extern mmove_t insane_move_crawl ; +extern mmove_t insane_move_stand_death ; +extern mmove_t insane_move_stand_pain ; +extern mmove_t insane_move_run_insane ; +extern mmove_t insane_move_walk_insane ; +extern mmove_t insane_move_run_normal ; +extern mmove_t insane_move_walk_normal ; +extern mmove_t insane_move_down ; +extern mmove_t insane_move_jumpdown ; +extern mmove_t insane_move_downtoup ; +extern mmove_t insane_move_uptodown ; +extern mmove_t insane_move_stand_insane ; +extern mmove_t insane_move_stand_normal ; +extern mmove_t infantry_move_attack2 ; +extern mmove_t infantry_move_attack1 ; +extern mmove_t infantry_move_duck ; +extern mmove_t infantry_move_death3 ; +extern mmove_t infantry_move_death2 ; +extern mmove_t infantry_move_death1 ; +extern mmove_t infantry_move_pain2 ; +extern mmove_t infantry_move_pain1 ; +extern mmove_t infantry_move_run ; +extern mmove_t infantry_move_walk ; +extern mmove_t infantry_move_fidget ; +extern mmove_t infantry_move_stand ; +extern mmove_t hover_move_end_attack ; +extern mmove_t hover_move_attack1 ; +extern mmove_t hover_move_start_attack ; +extern mmove_t hover_move_backward ; +extern mmove_t hover_move_death1 ; +extern mmove_t hover_move_run ; +extern mmove_t hover_move_walk ; +extern mmove_t hover_move_forward ; +extern mmove_t hover_move_land ; +extern mmove_t hover_move_pain1 ; +extern mmove_t hover_move_pain2 ; +extern mmove_t hover_move_pain3 ; +extern mmove_t hover_move_takeoff ; +extern mmove_t hover_move_stop2 ; +extern mmove_t hover_move_stop1 ; +extern mmove_t hover_move_stand ; +extern mmove_t gunner_move_attack_grenade ; +extern mmove_t gunner_move_endfire_chain ; +extern mmove_t gunner_move_fire_chain ; +extern mmove_t gunner_move_attack_chain ; +extern mmove_t gunner_move_duck ; +extern mmove_t gunner_move_death ; +extern mmove_t gunner_move_pain1 ; +extern mmove_t gunner_move_pain2 ; +extern mmove_t gunner_move_pain3 ; +extern mmove_t gunner_move_runandshoot ; +extern mmove_t gunner_move_run ; +extern mmove_t gunner_move_walk ; +extern mmove_t gunner_move_stand ; +extern mmove_t gunner_move_fidget ; +extern mmove_t gladiator_move_death ; +extern mmove_t gladiator_move_pain_air ; +extern mmove_t gladiator_move_pain ; +extern mmove_t gladiator_move_attack_gun ; +extern mmove_t gladiator_move_attack_melee ; +extern mmove_t gladiator_move_run ; +extern mmove_t gladiator_move_walk ; +extern mmove_t gladiator_move_stand ; +extern mmove_t flyer_move_loop_melee ; +extern mmove_t flyer_move_end_melee ; +extern mmove_t flyer_move_start_melee ; +extern mmove_t flyer_move_attack2 ; +extern mmove_t flyer_move_bankleft ; +extern mmove_t flyer_move_bankright ; +extern mmove_t flyer_move_defense ; +extern mmove_t flyer_move_pain1 ; +extern mmove_t flyer_move_pain2 ; +extern mmove_t flyer_move_pain3 ; +extern mmove_t flyer_move_rollleft ; +extern mmove_t flyer_move_rollright ; +extern mmove_t flyer_move_stop ; +extern mmove_t flyer_move_start ; +extern mmove_t flyer_move_run ; +extern mmove_t flyer_move_walk ; +extern mmove_t flyer_move_stand ; +extern mmove_t floater_move_run ; +extern mmove_t floater_move_walk ; +extern mmove_t floater_move_pain3 ; +extern mmove_t floater_move_pain2 ; +extern mmove_t floater_move_pain1 ; +extern mmove_t floater_move_death ; +extern mmove_t floater_move_attack3 ; +extern mmove_t floater_move_attack2 ; +extern mmove_t floater_move_attack1 ; +extern mmove_t floater_move_activate ; +extern mmove_t floater_move_stand2 ; +extern mmove_t floater_move_stand1 ; +extern mmove_t flipper_move_death ; +extern mmove_t flipper_move_attack ; +extern mmove_t flipper_move_pain1 ; +extern mmove_t flipper_move_pain2 ; +extern mmove_t flipper_move_start_run ; +extern mmove_t flipper_move_walk ; +extern mmove_t flipper_move_run_start ; +extern mmove_t flipper_move_run_loop ; +extern mmove_t flipper_move_stand ; +extern mmove_t chick_move_start_slash ; +extern mmove_t chick_move_end_slash ; +extern mmove_t chick_move_slash ; +extern mmove_t chick_move_end_attack1 ; +extern mmove_t chick_move_attack1 ; +extern mmove_t chick_move_start_attack1 ; +extern mmove_t chick_move_duck ; +extern mmove_t chick_move_death1 ; +extern mmove_t chick_move_death2 ; +extern mmove_t chick_move_pain3 ; +extern mmove_t chick_move_pain2 ; +extern mmove_t chick_move_pain1 ; +extern mmove_t chick_move_walk ; +extern mmove_t chick_move_run ; +extern mmove_t chick_move_start_run ; +extern mmove_t chick_move_stand ; +extern mmove_t chick_move_fidget ; +extern mmove_t brain_move_run ; +extern mmove_t brain_move_attack2 ; +extern mmove_t brain_move_attack1 ; +extern mmove_t brain_move_death1 ; +extern mmove_t brain_move_death2 ; +extern mmove_t brain_move_duck ; +extern mmove_t brain_move_pain1 ; +extern mmove_t brain_move_pain2 ; +extern mmove_t brain_move_pain3 ; +extern mmove_t brain_move_defense ; +extern mmove_t brain_move_walk1 ; +extern mmove_t brain_move_idle ; +extern mmove_t brain_move_stand ; +extern mmove_t makron_move_attack5 ; +extern mmove_t makron_move_attack4 ; +extern mmove_t makron_move_attack3 ; +extern mmove_t makron_move_sight ; +extern mmove_t makron_move_death3 ; +extern mmove_t makron_move_death2 ; +extern mmove_t makron_move_pain4 ; +extern mmove_t makron_move_pain5 ; +extern mmove_t makron_move_pain6 ; +extern mmove_t makron_move_walk ; +extern mmove_t makron_move_run ; +extern mmove_t makron_move_stand ; +extern mmove_t jorg_move_end_attack1 ; +extern mmove_t jorg_move_attack1 ; +extern mmove_t jorg_move_start_attack1 ; +extern mmove_t jorg_move_attack2 ; +extern mmove_t jorg_move_death ; +extern mmove_t jorg_move_pain1 ; +extern mmove_t jorg_move_pain2 ; +extern mmove_t jorg_move_pain3 ; +extern mmove_t jorg_move_end_walk ; +extern mmove_t jorg_move_walk ; +extern mmove_t jorg_move_start_walk ; +extern mmove_t jorg_move_run ; +extern mmove_t jorg_move_stand ; +extern mmove_t boss2_move_death ; +extern mmove_t boss2_move_pain_light ; +extern mmove_t boss2_move_pain_heavy ; +extern mmove_t boss2_move_attack_rocket ; +extern mmove_t boss2_move_attack_post_mg ; +extern mmove_t boss2_move_attack_mg ; +extern mmove_t boss2_move_attack_pre_mg ; +extern mmove_t boss2_move_run ; +extern mmove_t boss2_move_walk ; +extern mmove_t boss2_move_fidget ; +extern mmove_t boss2_move_stand ; +extern mmove_t berserk_move_death2 ; +extern mmove_t berserk_move_death1 ; +extern mmove_t berserk_move_pain2 ; +extern mmove_t berserk_move_pain1 ; +extern mmove_t berserk_move_attack_strike ; +extern mmove_t berserk_move_attack_club ; +extern mmove_t berserk_move_attack_spike ; +extern mmove_t berserk_move_run1 ; +extern mmove_t berserk_move_walk ; +extern mmove_t berserk_move_stand_fidget ; +extern mmove_t berserk_move_stand ; +extern mmove_t actor_move_attack ; +extern mmove_t actor_move_death2 ; +extern mmove_t actor_move_death1 ; +extern mmove_t actor_move_taunt ; +extern mmove_t actor_move_flipoff ; +extern mmove_t actor_move_pain3 ; +extern mmove_t actor_move_pain2 ; +extern mmove_t actor_move_pain1 ; +extern mmove_t actor_move_run ; +extern mmove_t actor_move_walk ; +extern mmove_t actor_move_stand ; diff --git a/src/game/baseq2/savegame/tables/gamemmove_list.h b/src/game/baseq2/savegame/tables/gamemmove_list.h new file mode 100644 index 00000000..6cda2705 --- /dev/null +++ b/src/game/baseq2/savegame/tables/gamemmove_list.h @@ -0,0 +1,287 @@ +{"tank_move_death", &tank_move_death}, +{"tank_move_attack_chain", &tank_move_attack_chain}, +{"tank_move_attack_post_rocket", &tank_move_attack_post_rocket}, +{"tank_move_attack_fire_rocket", &tank_move_attack_fire_rocket}, +{"tank_move_attack_pre_rocket", &tank_move_attack_pre_rocket}, +{"tank_move_attack_strike", &tank_move_attack_strike}, +{"tank_move_attack_post_blast", &tank_move_attack_post_blast}, +{"tank_move_reattack_blast", &tank_move_reattack_blast}, +{"tank_move_attack_blast", &tank_move_attack_blast}, +{"tank_move_pain3", &tank_move_pain3}, +{"tank_move_pain2", &tank_move_pain2}, +{"tank_move_pain1", &tank_move_pain1}, +{"tank_move_stop_run", &tank_move_stop_run}, +{"tank_move_run", &tank_move_run}, +{"tank_move_start_run", &tank_move_start_run}, +{"tank_move_stop_walk", &tank_move_stop_walk}, +{"tank_move_walk", &tank_move_walk}, +{"tank_move_start_walk", &tank_move_start_walk}, +{"tank_move_stand", &tank_move_stand}, +{"supertank_move_end_attack1", &supertank_move_end_attack1}, +{"supertank_move_attack1", &supertank_move_attack1}, +{"supertank_move_attack2", &supertank_move_attack2}, +{"supertank_move_attack3", &supertank_move_attack3}, +{"supertank_move_attack4", &supertank_move_attack4}, +{"supertank_move_backward", &supertank_move_backward}, +{"supertank_move_death", &supertank_move_death}, +{"supertank_move_pain1", &supertank_move_pain1}, +{"supertank_move_pain2", &supertank_move_pain2}, +{"supertank_move_pain3", &supertank_move_pain3}, +{"supertank_move_turn_left", &supertank_move_turn_left}, +{"supertank_move_turn_right", &supertank_move_turn_right}, +{"supertank_move_forward", &supertank_move_forward}, +{"supertank_move_run", &supertank_move_run}, +{"supertank_move_stand", &supertank_move_stand}, +{"soldier_move_death6", &soldier_move_death6}, +{"soldier_move_death5", &soldier_move_death5}, +{"soldier_move_death4", &soldier_move_death4}, +{"soldier_move_death3", &soldier_move_death3}, +{"soldier_move_death2", &soldier_move_death2}, +{"soldier_move_death1", &soldier_move_death1}, +{"soldier_move_duck", &soldier_move_duck}, +{"soldier_move_attack6", &soldier_move_attack6}, +{"soldier_move_attack4", &soldier_move_attack4}, +{"soldier_move_attack3", &soldier_move_attack3}, +{"soldier_move_attack2", &soldier_move_attack2}, +{"soldier_move_attack1", &soldier_move_attack1}, +{"soldier_move_pain4", &soldier_move_pain4}, +{"soldier_move_pain3", &soldier_move_pain3}, +{"soldier_move_pain2", &soldier_move_pain2}, +{"soldier_move_pain1", &soldier_move_pain1}, +{"soldier_move_run", &soldier_move_run}, +{"soldier_move_start_run", &soldier_move_start_run}, +{"soldier_move_walk2", &soldier_move_walk2}, +{"soldier_move_walk1", &soldier_move_walk1}, +{"soldier_move_stand3", &soldier_move_stand3}, +{"soldier_move_stand1", &soldier_move_stand1}, +{"parasite_move_death", ¶site_move_death}, +{"parasite_move_break", ¶site_move_break}, +{"parasite_move_drain", ¶site_move_drain}, +{"parasite_move_pain1", ¶site_move_pain1}, +{"parasite_move_stop_walk", ¶site_move_stop_walk}, +{"parasite_move_start_walk", ¶site_move_start_walk}, +{"parasite_move_walk", ¶site_move_walk}, +{"parasite_move_stop_run", ¶site_move_stop_run}, +{"parasite_move_start_run", ¶site_move_start_run}, +{"parasite_move_run", ¶site_move_run}, +{"parasite_move_stand", ¶site_move_stand}, +{"parasite_move_end_fidget", ¶site_move_end_fidget}, +{"parasite_move_fidget", ¶site_move_fidget}, +{"parasite_move_start_fidget", ¶site_move_start_fidget}, +{"mutant_move_death2", &mutant_move_death2}, +{"mutant_move_death1", &mutant_move_death1}, +{"mutant_move_pain3", &mutant_move_pain3}, +{"mutant_move_pain2", &mutant_move_pain2}, +{"mutant_move_pain1", &mutant_move_pain1}, +{"mutant_move_jump", &mutant_move_jump}, +{"mutant_move_attack", &mutant_move_attack}, +{"mutant_move_run", &mutant_move_run}, +{"mutant_move_start_walk", &mutant_move_start_walk}, +{"mutant_move_walk", &mutant_move_walk}, +{"mutant_move_idle", &mutant_move_idle}, +{"mutant_move_stand", &mutant_move_stand}, +{"medic_move_attackCable", &medic_move_attackCable}, +{"medic_move_attackBlaster", &medic_move_attackBlaster}, +{"medic_move_attackHyperBlaster", &medic_move_attackHyperBlaster}, +{"medic_move_duck", &medic_move_duck}, +{"medic_move_death", &medic_move_death}, +{"medic_move_pain2", &medic_move_pain2}, +{"medic_move_pain1", &medic_move_pain1}, +{"medic_move_run", &medic_move_run}, +{"medic_move_walk", &medic_move_walk}, +{"medic_move_stand", &medic_move_stand}, +{"insane_move_struggle_cross", &insane_move_struggle_cross}, +{"insane_move_cross", &insane_move_cross}, +{"insane_move_crawl_death", &insane_move_crawl_death}, +{"insane_move_crawl_pain", &insane_move_crawl_pain}, +{"insane_move_runcrawl", &insane_move_runcrawl}, +{"insane_move_crawl", &insane_move_crawl}, +{"insane_move_stand_death", &insane_move_stand_death}, +{"insane_move_stand_pain", &insane_move_stand_pain}, +{"insane_move_run_insane", &insane_move_run_insane}, +{"insane_move_walk_insane", &insane_move_walk_insane}, +{"insane_move_run_normal", &insane_move_run_normal}, +{"insane_move_walk_normal", &insane_move_walk_normal}, +{"insane_move_down", &insane_move_down}, +{"insane_move_jumpdown", &insane_move_jumpdown}, +{"insane_move_downtoup", &insane_move_downtoup}, +{"insane_move_uptodown", &insane_move_uptodown}, +{"insane_move_stand_insane", &insane_move_stand_insane}, +{"insane_move_stand_normal", &insane_move_stand_normal}, +{"infantry_move_attack2", &infantry_move_attack2}, +{"infantry_move_attack1", &infantry_move_attack1}, +{"infantry_move_duck", &infantry_move_duck}, +{"infantry_move_death3", &infantry_move_death3}, +{"infantry_move_death2", &infantry_move_death2}, +{"infantry_move_death1", &infantry_move_death1}, +{"infantry_move_pain2", &infantry_move_pain2}, +{"infantry_move_pain1", &infantry_move_pain1}, +{"infantry_move_run", &infantry_move_run}, +{"infantry_move_walk", &infantry_move_walk}, +{"infantry_move_fidget", &infantry_move_fidget}, +{"infantry_move_stand", &infantry_move_stand}, +{"hover_move_end_attack", &hover_move_end_attack}, +{"hover_move_attack1", &hover_move_attack1}, +{"hover_move_start_attack", &hover_move_start_attack}, +{"hover_move_backward", &hover_move_backward}, +{"hover_move_death1", &hover_move_death1}, +{"hover_move_run", &hover_move_run}, +{"hover_move_walk", &hover_move_walk}, +{"hover_move_forward", &hover_move_forward}, +{"hover_move_land", &hover_move_land}, +{"hover_move_pain1", &hover_move_pain1}, +{"hover_move_pain2", &hover_move_pain2}, +{"hover_move_pain3", &hover_move_pain3}, +{"hover_move_takeoff", &hover_move_takeoff}, +{"hover_move_stop2", &hover_move_stop2}, +{"hover_move_stop1", &hover_move_stop1}, +{"hover_move_stand", &hover_move_stand}, +{"gunner_move_attack_grenade", &gunner_move_attack_grenade}, +{"gunner_move_endfire_chain", &gunner_move_endfire_chain}, +{"gunner_move_fire_chain", &gunner_move_fire_chain}, +{"gunner_move_attack_chain", &gunner_move_attack_chain}, +{"gunner_move_duck", &gunner_move_duck}, +{"gunner_move_death", &gunner_move_death}, +{"gunner_move_pain1", &gunner_move_pain1}, +{"gunner_move_pain2", &gunner_move_pain2}, +{"gunner_move_pain3", &gunner_move_pain3}, +{"gunner_move_runandshoot", &gunner_move_runandshoot}, +{"gunner_move_run", &gunner_move_run}, +{"gunner_move_walk", &gunner_move_walk}, +{"gunner_move_stand", &gunner_move_stand}, +{"gunner_move_fidget", &gunner_move_fidget}, +{"gladiator_move_death", &gladiator_move_death}, +{"gladiator_move_pain_air", &gladiator_move_pain_air}, +{"gladiator_move_pain", &gladiator_move_pain}, +{"gladiator_move_attack_gun", &gladiator_move_attack_gun}, +{"gladiator_move_attack_melee", &gladiator_move_attack_melee}, +{"gladiator_move_run", &gladiator_move_run}, +{"gladiator_move_walk", &gladiator_move_walk}, +{"gladiator_move_stand", &gladiator_move_stand}, +{"flyer_move_loop_melee", &flyer_move_loop_melee}, +{"flyer_move_end_melee", &flyer_move_end_melee}, +{"flyer_move_start_melee", &flyer_move_start_melee}, +{"flyer_move_attack2", &flyer_move_attack2}, +{"flyer_move_bankleft", &flyer_move_bankleft}, +{"flyer_move_bankright", &flyer_move_bankright}, +{"flyer_move_defense", &flyer_move_defense}, +{"flyer_move_pain1", &flyer_move_pain1}, +{"flyer_move_pain2", &flyer_move_pain2}, +{"flyer_move_pain3", &flyer_move_pain3}, +{"flyer_move_rollleft", &flyer_move_rollleft}, +{"flyer_move_rollright", &flyer_move_rollright}, +{"flyer_move_stop", &flyer_move_stop}, +{"flyer_move_start", &flyer_move_start}, +{"flyer_move_run", &flyer_move_run}, +{"flyer_move_walk", &flyer_move_walk}, +{"flyer_move_stand", &flyer_move_stand}, +{"floater_move_run", &floater_move_run}, +{"floater_move_walk", &floater_move_walk}, +{"floater_move_pain3", &floater_move_pain3}, +{"floater_move_pain2", &floater_move_pain2}, +{"floater_move_pain1", &floater_move_pain1}, +{"floater_move_death", &floater_move_death}, +{"floater_move_attack3", &floater_move_attack3}, +{"floater_move_attack2", &floater_move_attack2}, +{"floater_move_attack1", &floater_move_attack1}, +{"floater_move_activate", &floater_move_activate}, +{"floater_move_stand2", &floater_move_stand2}, +{"floater_move_stand1", &floater_move_stand1}, +{"flipper_move_death", &flipper_move_death}, +{"flipper_move_attack", &flipper_move_attack}, +{"flipper_move_pain1", &flipper_move_pain1}, +{"flipper_move_pain2", &flipper_move_pain2}, +{"flipper_move_start_run", &flipper_move_start_run}, +{"flipper_move_walk", &flipper_move_walk}, +{"flipper_move_run_start", &flipper_move_run_start}, +{"flipper_move_run_loop", &flipper_move_run_loop}, +{"flipper_move_stand", &flipper_move_stand}, +{"chick_move_start_slash", &chick_move_start_slash}, +{"chick_move_end_slash", &chick_move_end_slash}, +{"chick_move_slash", &chick_move_slash}, +{"chick_move_end_attack1", &chick_move_end_attack1}, +{"chick_move_attack1", &chick_move_attack1}, +{"chick_move_start_attack1", &chick_move_start_attack1}, +{"chick_move_duck", &chick_move_duck}, +{"chick_move_death1", &chick_move_death1}, +{"chick_move_death2", &chick_move_death2}, +{"chick_move_pain3", &chick_move_pain3}, +{"chick_move_pain2", &chick_move_pain2}, +{"chick_move_pain1", &chick_move_pain1}, +{"chick_move_walk", &chick_move_walk}, +{"chick_move_run", &chick_move_run}, +{"chick_move_start_run", &chick_move_start_run}, +{"chick_move_stand", &chick_move_stand}, +{"chick_move_fidget", &chick_move_fidget}, +{"brain_move_run", &brain_move_run}, +{"brain_move_attack2", &brain_move_attack2}, +{"brain_move_attack1", &brain_move_attack1}, +{"brain_move_death1", &brain_move_death1}, +{"brain_move_death2", &brain_move_death2}, +{"brain_move_duck", &brain_move_duck}, +{"brain_move_pain1", &brain_move_pain1}, +{"brain_move_pain2", &brain_move_pain2}, +{"brain_move_pain3", &brain_move_pain3}, +{"brain_move_defense", &brain_move_defense}, +{"brain_move_walk1", &brain_move_walk1}, +{"brain_move_idle", &brain_move_idle}, +{"brain_move_stand", &brain_move_stand}, +{"makron_move_attack5", &makron_move_attack5}, +{"makron_move_attack4", &makron_move_attack4}, +{"makron_move_attack3", &makron_move_attack3}, +{"makron_move_sight", &makron_move_sight}, +{"makron_move_death3", &makron_move_death3}, +{"makron_move_death2", &makron_move_death2}, +{"makron_move_pain4", &makron_move_pain4}, +{"makron_move_pain5", &makron_move_pain5}, +{"makron_move_pain6", &makron_move_pain6}, +{"makron_move_walk", &makron_move_walk}, +{"makron_move_run", &makron_move_run}, +{"makron_move_stand", &makron_move_stand}, +{"jorg_move_end_attack1", &jorg_move_end_attack1}, +{"jorg_move_attack1", &jorg_move_attack1}, +{"jorg_move_start_attack1", &jorg_move_start_attack1}, +{"jorg_move_attack2", &jorg_move_attack2}, +{"jorg_move_death", &jorg_move_death}, +{"jorg_move_pain1", &jorg_move_pain1}, +{"jorg_move_pain2", &jorg_move_pain2}, +{"jorg_move_pain3", &jorg_move_pain3}, +{"jorg_move_end_walk", &jorg_move_end_walk}, +{"jorg_move_walk", &jorg_move_walk}, +{"jorg_move_start_walk", &jorg_move_start_walk}, +{"jorg_move_run", &jorg_move_run}, +{"jorg_move_stand", &jorg_move_stand}, +{"boss2_move_death", &boss2_move_death}, +{"boss2_move_pain_light", &boss2_move_pain_light}, +{"boss2_move_pain_heavy", &boss2_move_pain_heavy}, +{"boss2_move_attack_rocket", &boss2_move_attack_rocket}, +{"boss2_move_attack_post_mg", &boss2_move_attack_post_mg}, +{"boss2_move_attack_mg", &boss2_move_attack_mg}, +{"boss2_move_attack_pre_mg", &boss2_move_attack_pre_mg}, +{"boss2_move_run", &boss2_move_run}, +{"boss2_move_walk", &boss2_move_walk}, +{"boss2_move_fidget", &boss2_move_fidget}, +{"boss2_move_stand", &boss2_move_stand}, +{"berserk_move_death2", &berserk_move_death2}, +{"berserk_move_death1", &berserk_move_death1}, +{"berserk_move_pain2", &berserk_move_pain2}, +{"berserk_move_pain1", &berserk_move_pain1}, +{"berserk_move_attack_strike", &berserk_move_attack_strike}, +{"berserk_move_attack_club", &berserk_move_attack_club}, +{"berserk_move_attack_spike", &berserk_move_attack_spike}, +{"berserk_move_run1", &berserk_move_run1}, +{"berserk_move_walk", &berserk_move_walk}, +{"berserk_move_stand_fidget", &berserk_move_stand_fidget}, +{"berserk_move_stand", &berserk_move_stand}, +{"actor_move_attack", &actor_move_attack}, +{"actor_move_death2", &actor_move_death2}, +{"actor_move_death1", &actor_move_death1}, +{"actor_move_taunt", &actor_move_taunt}, +{"actor_move_flipoff", &actor_move_flipoff}, +{"actor_move_pain3", &actor_move_pain3}, +{"actor_move_pain2", &actor_move_pain2}, +{"actor_move_pain1", &actor_move_pain1}, +{"actor_move_run", &actor_move_run}, +{"actor_move_walk", &actor_move_walk}, +{"actor_move_stand", &actor_move_stand}, +{0, 0} diff --git a/src/game/baseq2/savegame/tables/levelfields.h b/src/game/baseq2/savegame/tables/levelfields.h new file mode 100644 index 00000000..2d00210b --- /dev/null +++ b/src/game/baseq2/savegame/tables/levelfields.h @@ -0,0 +1,6 @@ +{"changemap", LLOFS(changemap), F_LSTRING}, +{"sight_client", LLOFS(sight_client), F_EDICT}, +{"sight_entity", LLOFS(sight_entity), F_EDICT}, +{"sound_entity", LLOFS(sound_entity), F_EDICT}, +{"sound2_entity", LLOFS(sound2_entity), F_EDICT}, +{NULL, 0, F_INT}