cl_localentity.h

Go to the documentation of this file.

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

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 CLIENT_CL_LOCALENTITY_H
#define CLIENT_CL_LOCALENTITY_H

#include "../renderer/r_entity.h"

#define MAX_LE_PATHLENGTH 32

typedef enum {
    M_MOVE,     
    M_FIRE_R,   
    M_FIRE_L,   
    M_FIRE_HEADGEAR, 
    M_PEND_MOVE,    
    M_PEND_FIRE_R,  
    M_PEND_FIRE_L   
} actorModes_t;

#define IS_MODE_FIRE_RIGHT(x)       ((x) == M_FIRE_R || (x) == M_PEND_FIRE_R)
#define IS_MODE_FIRE_LEFT(x)        ((x) == M_FIRE_L || (x) == M_PEND_FIRE_L)
#define IS_MODE_FIRE_HEADGEAR(x)    ((x) == M_FIRE_HEADGEAR)
#define IS_MODE_FIRE_PENDING(x)     ((x) == M_PEND_FIRE_L || (x) == M_PEND_FIRE_R)

typedef struct le_s {
    qboolean inuse;
    qboolean removeNextFrame;   
    qboolean invis;
    qboolean selected;      
    entity_type_t type;             
    int entnum;             
    vec3_t origin, oldOrigin;   
    pos3_t pos, oldPos, newPos;     
    int dir;                
    int TU, maxTU;              
    int morale, maxMorale;      
    int HP, maxHP;              
    int STUN;                   
    int state;                  
    float angles[3];    
    float alpha;        
    int team;       
    int pnum;       
    fireDefIndex_t currentSelectedFiremode;

    actorModes_t actorMode;     
    pos3_t mousePendPos;
    byte actorMoveLength;

    struct le_s *clientAction;      
    int contents;           
    vec3_t mins, maxs;

    char inlineModelName[8];    
    int modelnum1;  
    int modelnum2;  
    int skinnum;    
    model_t *model1, *model2;   
    void (*think) (struct le_s * le);
    int thinkDelay;

    byte path[MAX_LE_PATHLENGTH];
    int pathContents[MAX_LE_PATHLENGTH];    
    int positionContents;                   
    int pathLength, pathPos;
    int startTime, endTime;
    int speed[MAX_LE_PATHLENGTH];           
    float rotationSpeed;

    struct s_sample_s* sample;
    float attenuation;      
    float volume;           
    animState_t as; 
    const char *particleID;
    int levelflags; 
    ptl_t *ptl;             
    const char *ref1, *ref2;
    const struct le_s *ref3;
    inventory_t i;
    int left, right, extension, headgear; 
    actorSizeEnum_t fieldSize;              
    teamDef_t* teamDef;
    int gender; 
    const fireDef_t *fd;    
    pathing_t *pathMap; 
    qboolean(*addFunc) (struct le_s * le, entity_t * ent);

    qboolean locked;    
} le_t;

#define MAX_LOCALMODELS     512

typedef struct localModel_s {
    char id[MAX_VAR];   
    char name[MAX_QPATH];   
    char target[MAX_VAR];
    char tagname[MAX_VAR];      
    struct localModel_s *parent;    
    qboolean inuse;

    vec3_t origin;
    vec3_t angles;
    vec3_t scale;   
    int entnum; 
    int renderEntityNum;    
    int skin;
    int renderFlags;    
    int frame;  
    char animname[MAX_QPATH];   
    int levelflags;
    animState_t as;

    void (*think) (struct localModel_s * localModel);

    struct model_s *model;
} localModel_t;

static const vec3_t player_mins = { -PLAYER_WIDTH, -PLAYER_WIDTH, PLAYER_MIN };
static const vec3_t player_maxs = { PLAYER_WIDTH, PLAYER_WIDTH, PLAYER_STAND };
static const vec3_t player_dead_maxs = { PLAYER_WIDTH, PLAYER_WIDTH, PLAYER_DEAD };

extern cvar_t* cl_le_debug;
extern cvar_t *cl_leshowinvis;

const char *LE_GetAnim(const char *anim, int right, int left, int state);
void LE_AddProjectile(const fireDef_t *fd, int flags, const vec3_t muzzle, const vec3_t impact, int normal, le_t *leVictim);
void LE_AddGrenade(const fireDef_t *fd, int flags, const vec3_t muzzle, const vec3_t v0, int dt, le_t* leVictim);
void LE_AddAmbientSound(const char *sound, const vec3_t origin, int levelflags, float volume, float attenuation);
int LE_ActorGetStepTime(const le_t *le, const pos3_t pos, const pos3_t oldPos, const int dir, const int sped);

#define LE_IsStunned(le)    (((le)->state & STATE_STUN) & ~STATE_DEAD)

#define LE_IsDead(le)       ((le)->state & STATE_DEAD)
#define LE_IsPaniced(le)    ((le)->state & STATE_PANIC)
#define LE_IsCrouched(le)   ((le)->state & STATE_CROUCHED)

#define LE_IsItem(le)       ((le)->type == ET_ITEM)
#define LE_IsCivilian(le)   ((le)->team == TEAM_CIVILIAN)
#define LE_IsAlien(le)      ((le)->team == TEAM_ALIEN)
#define LE_IsPhalanx(le)    ((le)->team == TEAM_PHALANX)

#define LE_GetAnimationIndexForDeath(le)    ((le)->state & MAX_DEATH)

#ifdef DEBUG
void LE_List_f(void);
void LM_List_f(void);
#endif

void LE_SetThink(le_t *le, void (*think) (le_t *le));
void LE_ExecuteThink(le_t *le);
void LE_Think(void);
/* think functions */
void LET_StartIdle(le_t *le);
void LET_Appear(le_t *le);
void LET_StartPathMove(le_t *le);
void LET_BrushModel(le_t *le);
void LE_DoEndPathMove(le_t *le);

/* local model functions */
void LM_Think(void);
void LMT_Init(localModel_t *localModel);
localModel_t *LM_AddModel(const char *model, const vec3_t origin, const vec3_t angles, int entnum, int levelflags, int flags, const vec3_t scale);
void LM_Perish(struct dbuffer *msg);
void LM_AddToScene(void);

qboolean LE_BrushModelAction(le_t *le, entity_t *ent);
void CL_RecalcRouting(const le_t *le);
void CL_CompleteRecalcRouting(void);

qboolean LE_IsLivingAndVisibleActor(const le_t *le);
qboolean LE_IsLivingActor(const le_t *le);
qboolean LE_IsActor(const le_t *le);
le_t *LE_Add(int entnum);
le_t *LE_Get(int entnum);
le_t* LE_GetNextInUse(le_t* lastLE);
le_t* LE_GetNext(le_t* lastLE);
void LE_Lock(le_t *le);
void LE_Unlock(le_t *le);
qboolean LE_IsLocked(int entnum);
#define LE_NotFoundError(entnum) _LE_NotFoundError(entnum, __FILE__, __LINE__)
void _LE_NotFoundError(int entnum, const char *file, const int line) __attribute__((noreturn));
le_t *LE_Find(int type, const pos3_t pos);
le_t *LE_FindRadius(le_t *from, const vec3_t org, float rad, entity_type_t type);
le_t *LE_GetFromPos(const pos3_t pos);
void LE_PlaceItem(le_t *le);
void LE_Cleanup(void);
void LE_AddToScene(void);
void LE_CenterView(const le_t *le);

trace_t CL_Trace(const vec3_t start, const vec3_t end, const vec3_t mins, const vec3_t maxs, const le_t * passle, le_t * passle2, int contentmask, int worldLevel);

void LM_Register(void);
localModel_t *LM_GetByID(const char *id);

#endif