Quake 2 Oop conversion project - Id's Quake2 Structures


Id's Original Structures - Reference ( back to table of contents ) :
Quake2 Structs (ID's Version)
From q2source_12_11.zip
Original Reference formated by PeteDog hoganpet@pilot.msu.edu
Reformated By : ZeroDiVide zerodiv@students.johnco.cc.ks.us
Note: the struct definitions are in a c++ style that won't compile in c.  This is to get rid of the redundant names: edict_s and edict_t.  Now there is just the one, edict_t.  You may still find in this file struct data members defined with the old c-style declaration to these structs (ie. struct edict_s* AnEntity), but you should read them as if you know what you just read (ie edict_t* AnEntity).
 
Structure TOC :

q_shared.h ( back to the header toc )

cvar_t ( back to the header toc ) ( back to q_shared.h's structure list ) :

struct cvar_t
{
 // nothing outside the Cvar_*() functions should modify these fields!
 char  *name;
 char  *string;
 char  *latched_string; // for CVAR_LATCH vars
 int   flags;
 qboolean modified; // set each time the cvar is changed
 float  value;
 cvar_t  *next;
};



cplane_t ( back to the header toc ) ( back to q_shared.h's structure list ) :

struct cplane_t
{
 // plane_t structure
 // !!! if this is changed, it must be changed in asm code too !!!
 vec3_t normal;
 float dist;
 byte type;   // for fast side tests
 byte signbits;  // signx + (signy<<1) + (signz<<1)
 byte pad[2];
};



cmodel_t ( back to the header toc ) ( back to q_shared.h's structure list ) :

struct cmodel_t
{
 vec3_t  mins, maxs;
 vec3_t  origin;  // for sounds or lights
 int   headnode;
};



csurface_t ( back to the header toc ) ( back to q_shared.h's structure list ) :

struct csurface_t
{
 char  name[16];
 int   flags;
 int   value;
};



trace_t ( back to the header toc ) ( back to q_shared.h's structure list ) :

struct trace_t
{
 // a trace is returned when a box is swept through the world
 qboolean allsolid; // if true, plane is not valid
 qboolean startsolid; // if true, the initial point was in a solid area
 float  fraction; // time completed, 1.0 = didn't hit anything
 vec3_t  endpos;  // final position
 cplane_t plane;  // surface normal at impact
 csurface_t *surface; // surface hit
 int   contents; // contents on other side of surface hit
 edict_t *ent;  // not set by CM_*() functions
};



pmove_state_t ( back to the header toc ) ( back to q_shared.h's structure list ) :

struct pmove_state_t
{
 // this structure needs to be communicated bit-accurate
 // from the server to the client to guarantee that
 // prediction stays in sync, so no floats are used.
 // if any part of the game code modifies this struct, it
 // will result in a prediction error of some degree.
 pmtype_t pm_type;

 short  origin[3];  // 12.3
 short  velocity[3]; // 12.3
 byte  pm_flags;  // ducked, jump_held, etc
 byte  teleport_time;
 short  gravity;
 short  delta_angles[3]; // add to command angles to get view direction
         // changed by spawns, rotating objects, and teleporters
};



usercmd_t ( back to the header toc ) ( back to q_shared.h's structure list ) :

struct usercmd_t
{
 // usercmd_t is sent to the server each client frame
 byte msec;
 byte buttons;
 short angles[3];
 short forwardmove, sidemove, upmove;
 byte impulse;  // remove?
 byte lightlevel;  // light level the player is standing on
};



pmove_t ( back to the header toc ) ( back to q_shared.h's structure list ) :

struct pmove_t
{
 // state (in / out)
 pmove_state_t s;

 // command (in)
 usercmd_t  cmd;
 qboolean  snapinitial; // if s has been changed outside pmove

 // results (out)
 int   numtouch;
 struct edict_s *touchents[MAXTOUCH];

 vec3_t  viewangles;   // clamped
 float  viewheight;

 vec3_t  mins, maxs;   // bounding box size

 struct edict_s *groundentity;
 int   watertype;
 int   waterlevel;

 // callbacks to test the world
 trace_t  (*trace) (vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end);
 int   (*pointcontents) (vec3_t point);
};



entity_state_t ( back to the header toc ) ( back to q_shared.h's structure list ) :

struct entity_state_t
{
 // entity_state_t is the information conveyed from the server
 // in an update message about entities that the client will
 // need to render in some way
 int  number;   // edict index

 vec3_t origin;
 vec3_t angles;
 vec3_t old_origin;  // for lerping
 int  modelindex;
 int  modelindex2, modelindex3, modelindex4; // weapons, CTF flags, etc
 int  frame;
 int  skinnum;
 int  effects;
 int  renderfx;
 int  solid;   // for client side prediction, 8*(bits 0-4) is x/y radius
       // 8*(bits 5-9) is z down distance, 8(bits10-15) is z up
       // gi.linkentity sets this properly
 int  sound;   // for looping sounds, to guarantee shutoff
 int  event;   // impulse events -- muzzle flashes, footsteps, etc
       // events only go out for a single frame, they
       // are automatically cleared each frame
};



player_state_t ( back to the header toc ) ( back to q_shared.h's structure list ) :

struct player_state_t
{
 // player_state_t is the information needed in addition to pmove_state_t
 // to rendered a view.  There will only be 10 player_state_t sent each second,
 // but the number of pmove_state_t changes will be reletive to client
 // frame rates
 pmove_state_t pmove;  // for prediction

 // these fields do not need to be communicated bit-precise

 vec3_t  viewangles;  // for fixed views
 vec3_t  viewoffset;  // add to pmovestate->origin
 vec3_t  kick_angles; // add to view direction to get render angles
        // set by weapon kicks, pain effects, etc

 vec3_t  gunangles;
 vec3_t  gunoffset;
 int   gunindex;
 int   gunframe;

 float  blend[4];  // rgba full screen effect
 
 float  fov;   // horizontal field of view

 int   rdflags;  // refdef flags

 short  stats[MAX_STATS];  // fast status bar updates
};



game.h ( back to the header toc )

clink_t ( back to the header toc ) ( back to game.h's structure list ) :

struct link_t
{
 // link_t is only used for entity area links now
 link_t *prev, *next;
};



gclient_t (server_version) ( back to the header toc ) ( back to game.h's structure list ) :

struct gclient_t
{
 player_state_t ps;  // communicated by server to clients
 int    ping;
 // the game dll can add anything it wants after
 // this point in the structure
};  



edict_t (server_version) ( back to the header toc ) ( back to game.h's structure list ) :

struct edict_t
{
 entity_state_t s;
 gclient_t *client;
 qboolean inuse;
 int   linkcount;

 // FIXME: move these fields to a server private sv_entity_t
 link_t  area;    // linked to a division node or leaf
 
 int   num_clusters;  // if -1, use headnode instead
 int   clusternums[MAX_ENT_CLUSTERS];
 int   headnode;   // unused if num_clusters != -1
 int   areanum, areanum2;

 //================================

 int   svflags;   // SVF_NOCLIENT, SVF_DEADMONSTER, SVF_MONSTER, etc
 vec3_t  mins, maxs;
 vec3_t  absmin, absmax, size;
 solid_t  solid;
 int   clipmask;
 edict_t  *owner;

 // the game dll can add anything it wants after
 // this point in the structure
};



game_import_t ( back to the header toc ) ( back to game.h's structure list ) :

struct game_import_t
{
 // functions provided by the main engine

 // special messages
 void (*bprintf) (int printlevel, char *fmt, ...);
 void (*dprintf) (char *fmt, ...);
 void (*cprintf) (edict_t *ent, int printlevel, char *fmt, ...);
 void (*centerprintf) (edict_t *ent, char *fmt, ...);
 void (*sound) (edict_t *ent, int channel, int soundindex, float volume, float attenuation, float timeofs);
 void (*positioned_sound) (vec3_t origin, edict_t *ent, int channel, int soundinedex, float volume, float attenuation, float timeofs);

 // config strings hold all the index strings, the lightstyles,
 // and misc data like the sky definition and cdtrack.
 // All of the current configstrings are sent to clients when
 // they connect, and changes are sent to all connected clients.
 void (*configstring) (int num, char *string);

 void (*error) (char *fmt, ...);

 // new names can only be added during spawning
 // existing names can be looked up at any time
 int  (*modelindex) (char *name);
 int  (*soundindex) (char *name);
 int  (*imageindex) (char *name);

 void (*setmodel) (edict_t *ent, char *name);

 // collision detection
 trace_t (*trace) (vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, edict_t *passent, int contentmask);
 int  (*pointcontents) (vec3_t point);
 qboolean (*inPVS) (vec3_t p1, vec3_t p2);
 qboolean (*inPHS) (vec3_t p1, vec3_t p2);
 void  (*SetAreaPortalState) (int portalnum, qboolean open);
 qboolean (*AreasConnected) (int area1, int area2);

 // an entity will never be sent to a client or used for collision
 // if it is not passed to linkentity.  If the size, position, or
 // solidity changes, it must be relinked.
 void (*linkentity) (edict_t *ent);
 void (*unlinkentity) (edict_t *ent);  // call before removing an interactive edict
 int  (*BoxEdicts) (vec3_t mins, vec3_t maxs, edict_t **list, int maxcount, int areatype);
 void (*Pmove) (pmove_t *pmove);  // player movement code common with client prediction

 // network messaging
 void (*multicast) (vec3_t origin, multicast_t to);
 void (*unicast) (edict_t *ent, qboolean reliable);
 void (*WriteChar) (int c);
 void (*WriteByte) (int c);
 void (*WriteShort) (int c);
 void (*WriteLong) (int c);
 void (*WriteFloat) (float f);
 void (*WriteString) (char *s);
 void (*WritePosition) (vec3_t pos); // some fractional bits
 void (*WriteDir) (vec3_t pos);  // single byte encoded, very coarse
 void (*WriteAngle) (float f);

 // managed memory allocation
 void *(*TagMalloc) (int size, int tag);
 void (*TagFree) (void *block);
 void (*FreeTags) (int tag);

 // console variable interaction
 cvar_t *(*cvar) (char *var_name, char *value, int flags);
 cvar_t *(*cvar_set) (char *var_name, char *value);
 cvar_t *(*cvar_forceset) (char *var_name, char *value);

 // ClientCommand and coneole command parameter checking
 int  (*argc) (void);
 char *(*argv) (int n);
 char *(*args) (void);

 // add commands to the server console as if they were typed in
 // for map changing, etc
 void (*AddCommandString) (char *text);

 void (*DebugGraph) (float value, int color);
};
  



game_export_t ( back to the header toc ) ( back to game.h's structure list ) :

struct game_export_t
{
 // functions exported by the game subsystem

 int   apiversion;

 // the init function will only be called when a game starts,
 // not each time a level is loaded.  Persistant data for clients
 // and the server can be allocated in init
 void  (*Init) (void);
 void  (*Shutdown) (void);

 // each new level entered will cause a call to SpawnEntities
 void  (*SpawnEntities) (char *mapname, char *entstring, char *spawnpoint);

 // Read/Write Game is for storing persistant cross level information
 // about the world state and the clients.
 // WriteGame is called every time a level is exited.
 // ReadGame is called on a loadgame.
 void  (*WriteGame) (char *filename);
 void  (*ReadGame) (char *filename);

 // ReadLevel is called after the default map information has been
 // loaded with SpawnEntities, so any stored client spawn spots will
 // be used when the clients reconnect.
 void  (*WriteLevel) (char *filename);
 void  (*ReadLevel) (char *filename);

 qboolean (*ClientConnect) (edict_t *ent, char *userinfo, qboolean loadgame);
 void  (*ClientBegin) (edict_t *ent, qboolean loadgame);
 void  (*ClientUserinfoChanged) (edict_t *ent, char *userinfo);
 void  (*ClientDisconnect) (edict_t *ent);
 void  (*ClientCommand) (edict_t *ent);
 void  (*ClientThink) (edict_t *ent, usercmd_t *cmd);

 void  (*RunFrame) (void);

 //
 // global variables shared between game and server
 //

 // The edict array is allocated in the game dll so it
 // can vary in size from one game to another.
 //
 // The size will be fixed when ge->Init() is called
 edict_t *edicts;
 int   edict_size;
 int   num_edicts;  // current number, <= max_edicts
 int   max_edicts;
};



g_local.h ( back to the header toc )

gitem_armor_t ( back to the header toc ) ( back to g_local.h's structure list ) :

struct gitem_armor_t
{
 int  base_count;
 int  max_count;
 float normal_protection;
 float energy_protection;
 int  armor;
};
  



gitem_t ( back to the header toc ) ( back to g_local.h's structure list ) :

struct gitem_t
{
 char  *classname; // spawning name
 qboolean (*pickup)(struct edict_s *ent, struct edict_s *other);
 void  (*use)(struct edict_s *ent, struct gitem_s *item);
 void  (*drop)(struct edict_s *ent, struct gitem_s *item);
 void  (*weaponthink)(struct edict_s *ent);
 char  *pickup_sound;
 char  *world_model;
 int   world_model_flags;
 char  *view_model;

 // client side info
 char  *icon;
 char  *pickup_name; // for printing on pickup
 int   count_width;  // number of digits to display by icon

 int   quantity;  // for ammo how much, for weapons how much is used per shot
 char  *ammo;   // for weapons
 int   flags;   // IT_* flags

 void  *info;
 int   tag;

 char  *precaches;  // string of all models, sounds, and images this item will use
};   



game_locals_t ( back to the header toc ) ( back to g_local.h's structure list ) :

struct game_locals_t
{
 // this structure is left intact through an entire game
 // it should be initialized at dll load time, and read/written to
 // the server.ssv file for savegames

 char  helpmessage1[512];
 char  helpmessage2[512];
 qboolean helpchanged;

 gclient_t *clients;  // [maxclients]

 // can't store spawnpoint in level, because
 // it would get overwritten by the savegame restore
 char  spawnpoint[512]; // needed for coop respawns

 // store latched cvars here that we want to get at often
 int   maxclients;
 int   maxentities;

 // cross level triggers
 int   serverflags;

 // items
 int   num_items;
};



level_locals_t ( back to the header toc ) ( back to g_local.h's structure list ) :

struct level_locals_t
{
 // this structure is cleared as each map is entered
 // it is read/written to the level.sav file for savegames

 int   framenum;
 float  time;

 char  level_name[MAX_QPATH]; // the descriptive name (Outer Base, etc)
 char  mapname[MAX_QPATH];  // the server name (base1, etc)
 char  nextmap[MAX_QPATH];  // go here when fraglimit is hit

 // intermission state
 float  intermissiontime;  // time the intermission was started
 char  *changemap;
 int   exitintermission;
 vec3_t  intermission_origin;
 vec3_t  intermission_angle;

 int   players;  // FIXME: count when needed, don't store

 edict_t  *sight_client; // changed once each frame for coop games

 edict_t  *sight_entity;
 int   sight_entity_framenum;
 edict_t  *sound_entity;
 int   sound_entity_framenum;
 edict_t  *sound2_entity;
 int   sound2_entity_framenum;

 int   pic_health;

 int   total_secrets;
 int   found_secrets;

 int   total_goals;
 int   found_goals;

 int   total_monsters;
 int   killed_monsters;

 edict_t  *current_entity; // entity running from G_RunFrame
 edict_t  *body_que;   // looped chain of dead bodies
};



spawn_temp_t ( back to the header toc ) ( back to g_local.h's structure list ) :

struct spawn_temp_t
{
 // spawn_temp_t is only used to hold entity field values that
 // can be set from the editor, but aren't actualy present
 // in edict_t during gameplay

 // world vars
 char  *sky;
 float  skyrotate;
 vec3_t  skyaxis;
 char  *nextmap;

 int   lip;
 int   distance;
 int   height;
 char  *noise;
 float  pausetime;
 char  *item;
 char  *gravity;

 float  minyaw;
 float  maxyaw;
 float  minpitch;
 float  maxpitch;
};



moveinfo_t ( back to the header toc ) ( back to g_local.h's structure list ) :

struct moveinfo_t
{
 // fixed data
 vec3_t  start_origin;
 vec3_t  start_angles;
 vec3_t  end_origin;
 vec3_t  end_angles;

 int   sound_start;
 int   sound_middle;
 int   sound_end;

 float  accel;
 float  speed;
 float  decel;
 float  distance;

 float  wait;

 // state data
 int   state;
 vec3_t  dir;
 float  current_speed;
 float  move_speed;
 float  next_speed;
 float  remaining_distance;
 float  decel_distance;
 void  (*endfunc)(edict_t *);
};



mframe_t ( back to the header toc ) ( back to g_local.h's structure list ) :

struct mframe_t
{
 void (*aifunc)(edict_t *self, float dist);
 float dist;
 void (*thinkfunc)(edict_t *self);
};



mmove_t ( back to the header toc ) ( back to g_local.h's structure list ) :

struct mmove_t
{
 int   firstframe;
 int   lastframe;
 mframe_t *frame;
 void  (*endfunc)(edict_t *self);
};



monsterinfo_t ( back to the header toc ) ( back to g_local.h's structure list ) :

struct monsterinfo_t
{
 mmove_t  *currentmove;
 int   aiflags;
 int   nextframe;
 float  scale;

 void  (*stand)(edict_t *self);
 void  (*idle)(edict_t *self);
 void  (*search)(edict_t *self);
 void  (*walk)(edict_t *self);
 void  (*run)(edict_t *self);
 void  (*dodge)(edict_t *self, edict_t *other, float eta);
 void  (*attack)(edict_t *self);
 void  (*melee)(edict_t *self);
 void  (*sight)(edict_t *self, edict_t *other);
 qboolean (*checkattack)(edict_t *self);

 float  pausetime;
 float  attack_finished;

 vec3_t  saved_goal;
 float  search_time;
 float  trail_time;
 vec3_t  last_sighting;
 int   attack_state;
 int   lefty;
 float  idle_time;
 int   linkcount;

 int   power_armor_type;
 int   power_armor_power;
};



field_t ( back to the header toc ) ( back to g_local.h's structure list ) :

struct field_t
{
 char *name;
 int  ofs;
 fieldtype_t type;
 int  flags;
};



client_persistant_t ( back to the header toc ) ( back to g_local.h's structure list ) :

struct client_persistant_t
{
 // client data that stays across multiple level loads
 char  userinfo[MAX_INFO_STRING];
 char  netname[16];
 char  sounddir[MAX_QPATH];  // player/male, etc
 int   hand;

 // values saved and restored from edicts when changing levels
 int   health;
 int   max_health;

 int   selected_item;
 int   inventory[MAX_ITEMS];

 // ammo capacities
 int   max_bullets;
 int   max_shells;
 int   max_rockets;
 int   max_grenades;
 int   max_cells;
 int   max_slugs;

 gitem_t  *weapon;
};
  



client_respawn_t ( back to the header toc ) ( back to g_local.h's structure list ) :

struct client_respawn_t
{
 // client data that staus across deathmatch respawns
 int   enterframe;   // level.framenum the client entered the game
 int   score;    // frags, etc
 vec3_t  cmd_angles;   // angles sent over in the last command
};
  



gclient_t (client_version) ( back to the header toc ) ( back to g_local.h's structure list ) :

struct gclient_t
{
 // this structure is cleared on each PutClientInServer(),
 // except for 'client->pers'

 // known to server
 player_state_t ps;    // communicated by server to clients
 int    ping;

 // private to game
 client_persistant_t pers;
 client_respawn_t resp;
 pmove_state_t  old_pmove; // for detecting out-of-pmove changes

 qboolean showscores;   // set layout stat
 qboolean showinventory;  // set layout stat
 qboolean showhelpicon;

 int   ammo_index;

 int   buttons;
 int   oldbuttons;
 int   latched_buttons;

 qboolean weapon_thunk;

 gitem_t  *newweapon;

 // sum up damage over an entire frame, so
 // shotgun blasts give a single big kick
 int   damage_armor;  // damage absorbed by armor
 int   damage_parmor;  // damage absorbed by power armor
 int   damage_blood;  // damage taken out of health
 int   damage_knockback; // impact damage
 vec3_t  damage_from;  // origin for vector calculation

 float  killer_yaw;   // when dead, look at killer

 weaponstate_t weaponstate;
 vec3_t  kick_angles; // weapon kicks
 vec3_t  kick_origin;
 float  v_dmg_roll, v_dmg_pitch, v_dmg_time; // damage kicks
 float  fall_time, fall_value;  // for view drop on fall
 float  damage_alpha;
 float  bonus_alpha;
 vec3_t  damage_blend;
 vec3_t  v_angle;   // aiming direction
 float  bobtime;   // so off-ground doesn't change it
 vec3_t  oldviewangles;
 vec3_t  oldvelocity;

 float  next_drown_time;
 int   old_waterlevel;
 int   breather_sound;

 int   machinegun_shots; // for weapon raising

 // animation vars
 int   anim_end;
 int   anim_priority;
 qboolean anim_duck;
 qboolean anim_run;

 // powerup timers
 float  quad_framenum;
 float  invincible_framenum;
 float  breather_framenum;
 float  enviro_framenum;

 qboolean grenade_blew_up;
 float  grenade_time;
 int   silencer_shots;
 int   weapon_sound;

 float  pickup_msg_time;

 float  respawn_time;  // can respawn when time > this
};
  



edict_t (client_version) ( back to the header toc ) ( back to g_local.h's structure list ) :

struct edict_t
{
 entity_state_t s;
 struct gclient_s *client; // NULL if not a player
         // the server expects the first part
         // of gclient_s to be a player_state_t
         // but the rest of it is opaque

 qboolean inuse;
 int   linkcount;

 // FIXME: move these fields to a server private sv_entity_t
 link_t  area;    // linked to a division node or leaf
 
 int   num_clusters;  // if -1, use headnode instead
 int   clusternums[MAX_ENT_CLUSTERS];
 int   headnode;   // unused if num_clusters != -1
 int   areanum, areanum2;

 //================================

 int   svflags;
 vec3_t  mins, maxs;
 vec3_t  absmin, absmax, size;
 solid_t  solid;
 int   clipmask;
 edict_t  *owner;
 

 // DO NOT MODIFY ANYTHING ABOVE THIS, THE SERVER
 // EXPECTS THE FIELDS IN THAT ORDER!

 //================================
 int   movetype;
 int   flags;

 char  *model;
 float  freetime;   // sv.time when the object was freed
 
 //
 // only used locally in game, not by server
 //
 char  *message;
 char  *classname;
 int   spawnflags;

 float  timestamp;

 float  angle;   // set in qe3, -1 = up, -2 = down
 char  *target;
 char  *targetname;
 char  *killtarget;
 char  *team;
 char  *pathtarget;
 char  *deathtarget;
 char  *combattarget;
 edict_t  *target_ent;

 float  speed, accel, decel;
 vec3_t  movedir;
 vec3_t  pos1, pos2;

 vec3_t  velocity;
 vec3_t  avelocity;
 int   mass;
 float  air_finished;
 float  gravity;  // per entity gravity multiplier (1.0 is normal)
        // use for lowgrav artifact, flares

 edict_t  *goalentity;
 edict_t  *movetarget;
 float  yaw_speed;
 float  ideal_yaw;

 float  nextthink;
 void  (*prethink) (edict_t *ent);
 void  (*think)(edict_t *self);
 void  (*blocked)(edict_t *self, edict_t *other); //move to moveinfo?
 void  (*touch)(edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf);
 void  (*use)(edict_t *self, edict_t *other, edict_t *activator);
 void  (*pain)(edict_t *self, edict_t *other, float kick, int damage);
 void  (*die)(edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point);

 float  touch_debounce_time;  // are all these legit?  do we need more/less of them?
 float  pain_debounce_time;
 float  damage_debounce_time;
 float  fly_sound_debounce_time; //move to clientinfo
 float  last_move_time;

 int   health;
 int   max_health;
 int   gib_health;
 int   deadflag;
 qboolean show_hostile;

 float  powerarmor_time;

 char  *map;   // target_changelevel

 int   viewheight;  // height above origin where eyesight is determined
 int   takedamage;
 int   dmg;
 int   radius_dmg;
 float  dmg_radius;
 int   sounds;   //make this a spawntemp var?
 int   count;

 edict_t  *chain;
 edict_t  *enemy;
 edict_t  *oldenemy;
 edict_t  *activator;
 edict_t  *groundentity;
 int   groundentity_linkcount;
 edict_t  *teamchain;
 edict_t  *teammaster;

 edict_t  *mynoise;  // can go in client only
 edict_t  *mynoise2;

 int   noise_index;
 int   noise_index2;
 float  volume;
 float  attenuation;

 // timing variables
 float  wait;
 float  delay;   // before firing targets
 float  random;

 float  teleport_time;

 int   watertype;
 int   waterlevel;

 vec3_t  move_origin;
 vec3_t  move_angles;

 // move this to clientinfo?
 int   light_level;

 int   style;   // also used as areaportal number

 gitem_t  *item;   // for bonus items

 // common data blocks
 moveinfo_t  moveinfo;
 monsterinfo_t monsterinfo;
};
  


g_spawn.c ( back to the header toc )

spawn_t ( back to the header toc ) ( back to g_spwan.c's structure list ) :

struct spawn_t
{
 char *name;
 void (*spawn)(edict_t *ent);
};