g_local.h

Go to the documentation of this file.

/*
All original material Copyright (C) 2002-2010 UFO: Alien Invasion.

Original file from Quake 2 v3.21: quake2-2.31/game/g_local.h
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.

*/

#ifndef GAME_G_LOCAL_H
#define GAME_G_LOCAL_H

#include "q_shared.h"
#include "inventory.h"
#include "../shared/infostring.h"
#include "lua/lua.h"

#define _(String) String
#define ngettext(x, y, cnt) x

#define GAME_INCLUDE
#include "game.h"

#define GAMEVERSION "baseufo"

#define MAX_SPOT_DIST   4096 /* 768 */

#define PM_ALL          0xFFFFFFFF

#define TEAM_ALL        0xFFFFFFFF

#define G_PlayerToPM(player) ((player)->num < game.sv_maxplayersperteam ? 1 << ((player)->num) : 0)

#define SERVER_FRAME_SECONDS        0.1

#define TAG_GAME    765         /* clear when unloading the game library */
#define TAG_LEVEL   766         /* clear when loading a new level */

#define CONTAINER(e, containerID) ((e)->chr.i.c[(containerID)])
#define ARMOUR(e) (CONTAINER(e, gi.csi->idArmour))
#define RIGHT(e) (CONTAINER(e, gi.csi->idRight))
#define LEFT(e)  (CONTAINER(e, gi.csi->idLeft))
#define EXTENSION(e)  (CONTAINER(e, gi.csi->idExtension))
#define HEADGEAR(e)  (CONTAINER(e, gi.csi->idHeadgear))
#define FLOOR(e) (CONTAINER(e, gi.csi->idFloor))

#define INVDEF(containerID) (&gi.csi->ids[(containerID)])

#define ACTOR_VIS_100   1.0
#define ACTOR_VIS_50    0.5
#define ACTOR_VIS_10    0.1
#define ACTOR_VIS_0     0.0

#define G_FreeTags(tag) gi.FreeTags((tag), __FILE__, __LINE__)
#define G_TagMalloc(size, tag) gi.TagMalloc((size), (tag), __FILE__, __LINE__)
#define G_MemFree(ptr) gi.TagFree((ptr), __FILE__, __LINE__)

#define G_PLAYER_FROM_ENT(ent) (game.players + (ent)->pnum)

typedef struct {
    player_t *players;          /* [maxplayers] */

    /* store latched cvars here that we want to get at often */
    int sv_maxplayersperteam;
    int sv_maxentities;

    inventoryInterface_t i;
} game_locals_t;

typedef struct {
    int framenum;       
    float time;         
    char mapname[MAX_QPATH];    
    char nextmap[MAX_QPATH];    
    qboolean routed;
    qboolean day;
    qboolean hurtAliens;

    /* intermission state */
    float intermissionTime;     
    int winningTeam;            
    float roundstartTime;       
    /* round statistics */
    int numplayers;
    int activeTeam;
    int nextEndRound;
    int actualRound;    
    pathing_t pathingMap;   
    int randomSpawn;    
    byte num_alive[MAX_TEAMS];      
    byte num_spawned[MAX_TEAMS];    
    byte num_spawnpoints[MAX_TEAMS];    
    byte num_2x2spawnpoints[MAX_TEAMS]; 
    byte num_kills[MAX_TEAMS][MAX_TEAMS];   
    byte num_stuns[MAX_TEAMS][MAX_TEAMS];   
} level_locals_t;


typedef struct {
    /* world vars */
    char *nextmap;  
    int randomSpawn;    
} spawn_temp_t;

typedef struct {
    int enemyCount;         
    int friendCount;        
    int civilian;           
    int self;               
    int damage;
    qboolean allow_self;
} shot_mock_t;

extern game_locals_t game;
extern level_locals_t level;
extern game_import_t gi;
extern game_export_t globals;

#define random()    ((rand() & 0x7fff) / ((float)0x7fff))
#define crandom()   (2.0 * (random() - 0.5))

#define G_IsState(ent, s)       ((ent)->state & (s))
#define G_IsShaken(ent)         G_IsState(ent, STATE_SHAKEN)
#define G_IsStunned(ent)        (G_IsState(ent, STATE_STUN) & ~STATE_DEAD)
#define G_IsPaniced(ent)        G_IsState(ent, STATE_PANIC)
#define G_IsReaction(ent)       G_IsState(ent, STATE_REACTION)
#define G_IsRaged(ent)          G_IsState(ent, STATE_RAGE)
#define G_IsInsane(ent)         G_IsState(ent, STATE_INSANE)
#define G_IsDazed(ent)          G_IsState(ent, STATE_DAZED)
#define G_IsCrouched(ent)       G_IsState(ent, STATE_CROUCHED)

#define G_IsDead(ent)           G_IsState(ent, STATE_DEAD)
#define G_IsActor(ent)          ((ent)->type == ET_ACTOR || (ent)->type == ET_ACTOR2x2)
#define G_IsBreakable(ent)      ((ent)->flags & FL_DESTROYABLE)
#define G_IsBrushModel(ent)     ((ent)->type == ET_BREAKABLE || (ent)->type == ET_DOOR)

#define G_IsVisibleOnBattlefield(ent)   (G_IsActor((ent)) || (ent)->type == ET_ITEM || (ent)->type == ET_PARTICLE)
#define G_IsAI(ent)             (G_PLAYER_FROM_ENT((ent))->pers.ai)
#define G_IsAIPlayer(player)    ((player)->pers.ai)
#define G_TeamToVisMask(team)   (1 << (team))
#define G_IsVisibleForTeam(ent, team) ((ent)->visflags & G_TeamToVisMask(team))

#define G_IsCivilian(ent)       ((ent)->team == TEAM_CIVILIAN)
#define G_IsAlien(ent)          ((ent)->team == TEAM_ALIEN)
#define G_IsBlockingMovementActor(ent)  (((ent)->type == ET_ACTOR && !G_IsDead(ent)) || ent->type == ET_ACTOR2x2)

#define G_ToggleState(ent, s)   (ent)->state ^= (s)
#define G_ToggleCrouched(ent)   G_ToggleState(ent, STATE_CROUCHED)

#define G_SetState(ent, s)      (ent)->state |= (s)
#define G_SetShaken(ent)        G_SetState((ent), STATE_SHAKEN)
#define G_SetDazed(ent)         G_SetState((ent), STATE_DAZED)
#define G_SetStunned(ent)       G_SetState((ent), STATE_STUN)
#define G_SetDead(ent)          G_SetState((ent), STATE_DEAD)
#define G_SetInsane(ent)        G_SetState((ent), STATE_INSANE)
#define G_SetRage(ent)          G_SetState((ent), STATE_RAGE)
#define G_SetPanic(ent)         G_SetState((ent), STATE_PANIC)
#define G_SetCrouched(ent)      G_SetState((ent), STATE_CROUCHED)

#define G_RemoveState(ent, s)   (ent)->state &= ~(s)
#define G_RemoveShaken(ent)     G_RemoveState((ent), STATE_SHAKEN)
#define G_RemoveDazed(ent)      G_RemoveState((ent), STATE_DAZED)
#define G_RemoveStunned(ent)    G_RemoveState((ent), STATE_STUN)
#define G_RemoveDead(ent)       G_RemoveState((ent), STATE_DEAD)
#define G_RemoveInsane(ent)     G_RemoveState((ent), STATE_INSANE)
#define G_RemoveRage(ent)       G_RemoveState((ent), STATE_RAGE)
#define G_RemovePanic(ent)      G_RemoveState((ent), STATE_PANIC)
#define G_RemoveCrouched(ent)   G_RemoveState((ent), STATE_CROUCHED)
#define G_RemoveReaction(ent)   G_RemoveState((ent), STATE_REACTION)

extern cvar_t *sv_maxentities;
extern cvar_t *password;
extern cvar_t *sv_needpass;
extern cvar_t *sv_dedicated;

extern cvar_t *logstats;
extern FILE *logstatsfile;

extern cvar_t *sv_filterban;

extern cvar_t *sv_maxvelocity;

extern cvar_t *sv_maxclients;
extern cvar_t *sv_shot_origin;
extern cvar_t *sv_hurtaliens;
extern cvar_t *sv_maxplayersperteam;
extern cvar_t *sv_maxsoldiersperteam;
extern cvar_t *sv_maxsoldiersperplayer;
extern cvar_t *sv_enablemorale;
extern cvar_t *sv_roundtimelimit;

extern cvar_t *sv_maxteams;

extern cvar_t *sv_ai;
extern cvar_t *sv_teamplay;

extern cvar_t *ai_alien;
extern cvar_t *ai_civilian;
extern cvar_t *ai_equipment;
extern cvar_t *ai_numaliens;
extern cvar_t *ai_numcivilians;
extern cvar_t *ai_numactors;

extern cvar_t *mob_death;
extern cvar_t *mob_wound;
extern cvar_t *mof_watching;
extern cvar_t *mof_teamkill;
extern cvar_t *mof_civilian;
extern cvar_t *mof_enemy;
extern cvar_t *mor_pain;

/*everyone gets this times morale damage */
extern cvar_t *mor_default;

/* at this distance the following two get halfed (exponential scale) */
extern cvar_t *mor_distance;

/* at this distance the following two get halfed (exponential scale) */
extern cvar_t *mor_victim;

/* at this distance the following two get halfed (exponential scale) */
extern cvar_t *mor_attacker;

/* how much the morale depends on the size of the damaged team */
extern cvar_t *mon_teamfactor;

extern cvar_t *mor_regeneration;
extern cvar_t *mor_shaken;
extern cvar_t *mor_panic;
extern cvar_t *mor_brave;

extern cvar_t *m_sanity;
extern cvar_t *m_rage;
extern cvar_t *m_rage_stop;
extern cvar_t *m_panic_stop;

extern cvar_t *g_reaction_fair;
extern cvar_t *g_ailua;
extern cvar_t *g_aidebug;
extern cvar_t *g_drawtraces;
extern cvar_t *g_nodamage;
extern cvar_t *g_notu;
extern cvar_t *g_nospawn;
extern cvar_t *g_actorspeed;

extern cvar_t *flood_msgs;
extern cvar_t *flood_persecond;
extern cvar_t *flood_waitdelay;

extern cvar_t *difficulty;

/* fields are needed for spawning from the entity string */
#define FFL_SPAWNTEMP       1
#define FFL_NOSPAWN         2

/* g_stats.c */
void G_SendPlayerStats(const player_t *player);

/* g_inventory.c */
void G_WriteItem(const item_t *item, const invDef_t *container, int x, int y);
void G_ReadItem(item_t *item, invDef_t **container, int *x, int *y);
void G_InventoryToFloor(edict_t *ent);
qboolean G_AddItemToFloor(const pos3_t pos, const char *itemID);
edict_t *G_GetFloorItemsFromPos(const pos3_t pos);

/* g_morale */
void G_MoraleBehaviour(int team);

/* g_phys.c */
void G_PhysicsRun(void);
void G_PhysicsStep(edict_t *ent);

/* g_actor.c */
void G_ActorReserveTUs(edict_t *ent, int resReaction, int resShot, int resCrouch);
int G_ActorGetTUForReactionFire(const edict_t *ent);
int G_ActorUsableTUs(const edict_t *ent);
int G_ActorGetReservedTUs(const edict_t *ent);
void G_ActorCheckRevitalise(edict_t *ent);

/* g_mission.c */
qboolean G_MissionTouch(edict_t *self, edict_t *activator);
qboolean G_MissionUse(edict_t *self, edict_t *activator);
qboolean G_MissionDestroy(edict_t *self);
void G_MissionThink(edict_t *self);

/* g_utils.c */
edict_t *G_Find(edict_t *from, int fieldofs, char *match);
edict_t *G_FindRadius(edict_t *from, const vec3_t org, float rad, entity_type_t type);
edict_t *G_FindTargetEntity(const char *target);
const char* G_GetPlayerName(int pnum);
player_t* G_GetPlayerForTeam(int team);
int G_GetActiveTeam(void);
const char* G_GetWeaponNameForFiredef(const fireDef_t *fd);
void G_PrintActorStats(const edict_t *victim, const edict_t *attacker, const fireDef_t *fd);
void G_PrintStats(const char *buffer);
int G_TouchTriggers(edict_t *ent);
void G_TouchSolids(edict_t *ent);
void G_TouchEdicts(edict_t *ent, float extend);
edict_t *G_Spawn(void);
edict_t *G_SpawnParticle(const vec3_t origin, int spawnflags, const char *particle);
void G_FreeEdict(edict_t *e);
qboolean G_UseEdict(edict_t *ent, edict_t* activator);
edict_t *G_GetEdictFromPos(const pos3_t pos, const entity_type_t type);
void G_TakeDamage(edict_t *ent, int damage);
trace_t G_Trace(const vec3_t start, const vec3_t end, const edict_t * passent, int contentmask);
qboolean G_TestLineWithEnts(const vec3_t start, const vec3_t end);
qboolean G_TestLine(const vec3_t start, const vec3_t end);

/* g_reaction.c */
void G_ReactionFirePreShot(const edict_t *target, const int fdTime);
void G_ReactionFirePostShot(edict_t *target);
void G_ReactionFireReset(int team);
qboolean G_ReactionFireCanBeEnabled(const edict_t *ent);
qboolean G_ReactionFireSetDefault(edict_t *ent);
void G_ReactionFireUpdate(edict_t *ent, fireDefIndex_t fmIdx, actorHands_t hand, const objDef_t *od);
qboolean G_ReactionFireOnMovement(edict_t *target);
void G_ReactionFireEndTurn(void);

void G_CompleteRecalcRouting(void);
void G_RecalcRouting(const edict_t * ent);
void G_GenerateEntList(const char *entList[MAX_EDICTS]);

/* g_events.c */
void G_EventSpawnSound(const edict_t* ent, const vec3_t origin, const char *sound);
void G_EventActorTurn(const edict_t* ent);
void G_EventActorFall(const edict_t* ent);
void G_EventActorDie(const edict_t* ent);
void G_EventActorRevitalise(const edict_t* ent);
void G_EventActorSendReservations(const edict_t *ent);
void G_EventInventoryDelete(const edict_t* ent, int playerMask, const invDef_t* invDef, int x, int y);
void G_EventInventoryAdd(const edict_t* ent, int playerMask, int itemAmount);
void G_EventPerish(const edict_t* ent);
void G_EventDestroyEdict(const edict_t* ent);
void G_EventInventoryAmmo(const edict_t* ent, const objDef_t* ammo, int amount, shoot_types_t shootType);
void G_EventStartShoot(const edict_t* ent, int visMask, shoot_types_t shootType, const pos3_t at);
void G_EventShootHidden(int visMask, const fireDef_t* fd, qboolean firstShoot);
void G_EventShoot(const edict_t* ent, int visMask, const fireDef_t* fd, qboolean firstShoot, shoot_types_t shootType, int flags, const trace_t* trace, const vec3_t from, const vec3_t impact);
void G_EventSetClientAction(const edict_t *ent);
void G_EventResetClientAction(const edict_t* ent);
void G_EventActorStats(const edict_t* ent);
void G_EventEndRound(void);
void G_EventInventoryReload(const edict_t* ent, int playerMask, const item_t* item, const invDef_t* invDef, const invList_t* ic);
void G_EventThrow(int visMask, const fireDef_t *fd, float dt, byte flags, const vec3_t position, const vec3_t velocity);
void G_EventReactionFireChange(const edict_t* ent);
void G_EventParticleSpawn(int playerMask, const char *name, int levelFlags, const vec3_t s, const vec3_t v, const vec3_t a);
void G_EventSendEdict(const edict_t *ent);

/* g_vis.c */
#define VIS_APPEAR  1
#define VIS_PERISH  2

#define VIS_CHANGE  1

#define VIS_YES     2

#define VIS_STOP    4

/* g_client.c */
#define VT_PERISH       1

#define VT_NOFRUSTUM    2

#define MORALE_RANDOM( mod )    ( (mod) * (1.0 + 0.3*crand()) )

#define MAX_DVTAB 32

edict_t* G_ClientGetFreeSpawnPointForActorSize(const player_t *player, const actorSizeEnum_t actorSize);
qboolean G_ClientUseEdict(const player_t *player, edict_t *actor, edict_t *door);
qboolean G_ActionCheckForCurrentTeam(const player_t *player, edict_t *ent, int TU);
qboolean G_ActionCheckWithoutTeam(const player_t *player, edict_t *ent, int TU);
void G_SendStats(edict_t *ent) __attribute__((nonnull));
edict_t *G_SpawnFloor(const pos3_t pos);
int G_CheckVisTeam(const int team, edict_t *check, qboolean perish, const edict_t *ent);
int G_CheckVisTeamAll(const int team, qboolean perish, const edict_t *ent);
edict_t *G_GetFloorItems(edict_t *ent) __attribute__((nonnull));
qboolean G_InventoryRemoveItemByID(const char *itemID, edict_t *ent, containerIndex_t index);
void G_SendState(unsigned int playerMask, const edict_t *ent);
void G_SetTeamForPlayer(player_t* player, const int team);
void G_CenterView(const edict_t *ent);

qboolean G_ActorIsInRescueZone(const edict_t* actor);
void G_ActorSetInRescueZone(edict_t* actor, qboolean inRescueZone);
void G_ActorUseDoor(edict_t *actor, edict_t *door);
qboolean G_IsLivingActor(const edict_t *ent) __attribute__((nonnull));
void G_ActorSetClientAction(edict_t *actor, edict_t *ent);
edict_t *G_ActorGetByUCN(const int ucn, const int team);
void G_CheckForceEndRound(void);
void G_ActorDieOrStun(edict_t *ent, edict_t *attacker);
void G_ActorSetMaxs(edict_t* ent);
void G_ActorGiveTimeUnits(edict_t *ent);
void G_ActorSetTU(edict_t *ent, int tus);
void G_ActorUseTU(edict_t *ent, int tus);
int G_ClientAction(player_t * player);
void G_ClientEndRound(player_t * player);
void G_ClientTeamInfo(const player_t * player);
void G_ClientInitActorStates(const player_t * player);
int G_ClientGetTeamNum(const player_t * player);
int G_ClientGetTeamNumPref(const player_t * player);
qboolean G_ClientIsReady(const player_t * player);
void G_ClientPrintf(const player_t * player, int printlevel, const char *fmt, ...) __attribute__((format(printf, 3, 4)));
void G_ResetClientData(void);

void G_ClientCommand(player_t * player);
void G_ClientUserinfoChanged(player_t * player, char *userinfo);
qboolean G_ClientBegin(player_t * player);
void G_ClientSpawn(player_t * player);
qboolean G_ClientConnect(player_t * player, char *userinfo, size_t userinfoSize);
void G_ClientDisconnect(player_t * player);

void G_ActorReload(edict_t* ent, const invDef_t *invDef);
qboolean G_ClientCanReload(edict_t *ent, containerIndex_t containerID);
void G_ClientGetWeaponFromInventory(edict_t *ent);
void G_ClientMove(const player_t * player, int visTeam, edict_t* ent, const pos3_t to);
void G_ActorFall(edict_t *ent);
void G_MoveCalc(int team, const edict_t *movingActor, const pos3_t from, byte crouchingState, int distance);
void G_MoveCalcLocal(pathing_t *pt, int team, const edict_t *movingActor, const pos3_t from, byte crouchingState, int distance);
void G_ActorInvMove(edict_t *ent, const invDef_t * from, invList_t *fItem, const invDef_t * to, int tx, int ty, qboolean checkaction);
void G_ClientStateChange(const player_t* player, edict_t* ent, int reqState, qboolean checkaction);
int G_ActorDoTurn(edict_t * ent, byte dir);

edict_t *G_GetActorFromPos(const pos3_t pos);

void G_SendInvisible(player_t *player);
void G_GiveTimeUnits(int team);

void G_AppearPerishEvent(unsigned int player_mask, qboolean appear, edict_t * check, const edict_t *ent);
unsigned int G_VisToPM(unsigned int vis_mask);
void G_SendInventory(unsigned int player_mask, const edict_t * ent);
unsigned int G_TeamToPM(int team);

void G_SpawnEntities(const char *mapname, qboolean day, const char *entities);
qboolean G_RunFrame(void);

#ifdef DEBUG
void G_InvList_f(const player_t *player);
#endif

/* g_vis.c */
qboolean G_FrustumVis(const edict_t *from, const vec3_t point);
float G_ActorVis(const vec3_t from, const edict_t *check, qboolean full);
void G_ClearVisFlags(int team);
int G_CheckVis(edict_t *check, qboolean perish);
int G_CheckVisPlayer(player_t* player, qboolean perish);
int G_TestVis(const int team, edict_t * check, int flags);
float G_Vis(const int team, const edict_t * from, const edict_t * check, int flags);

/* g_combat.c */
qboolean G_ClientShoot(const player_t *player, edict_t* ent, const pos3_t at, shoot_types_t shootType, fireDefIndex_t firemode, shot_mock_t *mock, qboolean allowReaction, int z_align);

/* g_ai.c */
extern edict_t *ai_waypointList;
void G_AddToWayPointList(edict_t *ent);
void AI_Run(void);
void AI_ActorThink(player_t *player, edict_t *ent);
player_t *AI_CreatePlayer(int team);
qboolean AI_CheckUsingDoor(const edict_t *ent, const edict_t *door);

/* g_svcmds.c */
void G_ServerCommand(void);
qboolean SV_FilterPacket(const char *from);

/* g_match.c */
qboolean G_MatchIsRunning(void);
void G_MatchEndTrigger(int team, int timeGap);
void G_MatchEndCheck(void);
qboolean G_MatchDoEnd(void);

/* g_trigger.c */
edict_t* G_TriggerSpawn(edict_t *owner);
void SP_trigger_hurt(edict_t *ent);
void SP_trigger_touch(edict_t *ent);
void SP_trigger_rescue(edict_t *ent);

/* g_func.c */
void SP_func_rotating(edict_t *ent);
void SP_func_door(edict_t *ent);
void SP_func_breakable(edict_t *ent);

edict_t* G_EdictsInit(void);
void G_EdictsReset(void);
edict_t* G_EdictsGetNewEdict(void);
int G_EdictsGetNumber(const edict_t* ent);
qboolean G_EdictsIsValidNum(const int idx);
edict_t* G_EdictsGetByNum(const int num);
edict_t* G_EdictsGetFirst(void);
edict_t* G_EdictsGetNext(edict_t* lastEnt);
edict_t* G_EdictsGetNextInUse(edict_t* lastEnt);
edict_t* G_EdictsGetNextActor(edict_t* lastEnt);
edict_t* G_EdictsGetNextLivingActor(edict_t* lastEnt);
edict_t* G_EdictsGetNextLivingActorOfTeam (edict_t* lastEnt, const int team);

void G_EdictCalcOrigin(edict_t* ent);
void G_EdictSetOrigin(edict_t* ent, const pos3_t newPos);
qboolean G_EdictPosIsSameAs(edict_t* ent, const pos3_t cmpPos);

/*============================================================================ */

typedef enum {
    MAT_GLASS,      /* default */
    MAT_METAL,
    MAT_ELECTRICAL,
    MAT_WOOD,

    MAT_MAX
} edictMaterial_t;

typedef struct {
    int         contentFlags[MAX_DVTAB];
    int         visflags[MAX_DVTAB];
    byte        steps;
    int         currentStep;
} moveinfo_t;

typedef struct {
    char userinfo[MAX_INFO_STRING];
    char netname[16];

    int team;
    qboolean ai;                
    edict_t *last; 
    float       flood_locktill;     
    float       flood_when[10];     
    int         flood_whenhead;     
} client_persistant_t;

struct player_s {
    /* known to server */
    qboolean inuse;
    int num;
    qboolean isReady;           
    /* private to game */
    qboolean spawned;           
    qboolean began;             
    qboolean roundDone;         
    int reactionLeftover;       
    qboolean autostand;         
    client_persistant_t pers;
};

#define FL_GROUPSLAVE   0x00000008

#define FL_DESTROYABLE  0x00000004

#define FL_TRIGGERED    0x00000100

typedef struct AI_s {
    char type[MAX_QPATH];   
    char subtype[MAX_VAR];  
    lua_State* L;           
} AI_t;

struct edict_s {
    qboolean inuse;
    int linkcount;      
    int number;         
    vec3_t origin;      
    vec3_t angles;      
    solid_t solid;

    vec3_t mins, maxs; 
    vec3_t absmin, absmax; 
    vec3_t size;

    edict_t *child; 
    edict_t *owner; 
    int modelindex;  
    /*================================ */
    /* don't change anything above here - the server expects the fields in that order */
    /*================================ */

    int mapNum;     
    const char *model;  
    entity_type_t type;
    int visflags;               
    int contentFlags;           
    pos3_t pos;
    byte dir;                   
    int TU;                     
    int HP;                     
    int STUN;                   
    int morale;                 
    int state;                  
    int team;                   
    int pnum;                   
    int body;
    int head;
    int frame;                  
    char *group;                
    const edict_t *reactionTarget;  
    float reactionTUs;  
    qboolean reactionNoDraw;
    qboolean inRescueZone;  
    edict_t *clientAction;

    character_t chr;

    int spawnflags; 
    const char *classname;

    float angle;    
    int speed;  
    const char *target; 
    const char *targetname; 
    const char *item;   
    const char *particle;
    const char *message; 
    const char *noise;  
    edictMaterial_t material;   
    int count;      
    int time;       
    int sounds;     
    int dmg;        
    actorSizeEnum_t fieldSize;  /* ACTOR_SIZE_* */
    qboolean hiding;        
    qboolean (*touch)(edict_t * self, edict_t * activator);
    void (*reset)(edict_t * self, edict_t * activator);
    float nextthink;
    void (*think)(edict_t *self);
    qboolean (*use)(edict_t *self, edict_t *activator);
    qboolean (*destroy)(edict_t *self);

    int doorState;  
    moveinfo_t      moveinfo;

    edict_t *groupChain;
    edict_t *groupMaster;   
    int flags;      
    AI_t AI; 
    pos3_t *forbiddenListPos; 
    int forbiddenListSize;      
};

#endif /* GAME_G_LOCAL_H */