cl_localentity.h

Go to the documentation of this file.

 
/*
Copyright (C) 2002-2022 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.
 
*/
 
#pragma once
 
#include "../renderer/r_entity.h"
 
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 bool (*localEntitiyAddFunc_t) (struct le_s*  le, entity_t* ent);
typedef void (*localEntityThinkFunc_t) (struct le_s*  le);
 
#define LE_CHECK_LEVELFLAGS     0x0001
#define LE_ALWAYS_VISIBLE       0x0002
#define LE_LOCKED               0x0004  
#define LE_REMOVE_NEXT_FRAME    0x0008  
#define LE_INVISIBLE            0x0010
#define LE_SELECTED             0x0020  
typedef struct leStep_s {
    int steps;
    int lastMoveTime;
    int lastMoveDuration;
    int stepTimes[MAX_ROUTE];   
    struct leStep_s* next;
} leStep_t;
 
typedef struct le_s {
    bool inuse;
    entity_type_t type;         
    int entnum;                 
    vec3_t origin, oldOrigin;   
    pos3_t pos, oldPos, newPos; 
    int angle;                  
    int dir;
 
    int TU, maxTU;              
    int morale, maxMorale;      
    int HP, maxHP;              
    int STUN;                   
    int state;                  
    woundInfo_t wounds;
 
    float angles[3];    
    float alpha;        
    int team;       
    int pnum;       
    int ucn;        
    int flags;
 
    fireDefIndex_t currentSelectedFiremode;
 
    actorModes_t actorMode;     
    pos3_t mousePendPos;
    byte actorMoveLength;
 
    struct le_s* clientAction;  
    int contents;               
    AABB aabb;                  
    vec3_t size;
 
    char inlineModelName[8];    
    unsigned int modelnum1;     
    unsigned int modelnum2;     
    unsigned int bodySkin;      
    unsigned int headSkin;      
    model_t* model1, *model2;   
    localEntityThinkFunc_t think;
    int thinkDelay;
 
    dvec_t dvtab[MAX_ROUTE];
    int pathContents[MAX_ROUTE];    
    int positionContents;           
    int pathLength, pathPos;
    leStep_t* stepList;             
    int stepIndex;                  
    int startTime, endTime;
    int speed[MAX_ROUTE];           
    float rotationSpeed;
    int slidingSpeed;
 
    inline bool isMoving () const
    {
        return pathLength > 0;
    }
 
    int sampleIdx;
    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 inv;
    int left, right, headgear;  
    actorSizeEnum_t fieldSize;  
    lighting_t lighting;
 
    teamDef_t* teamDef;
    int gender;             
    const fireDef_t* fd;    
    localEntitiyAddFunc_t addFunc;
 
    inline Item* getRightHandItem () const
    {
        return inv.getRightHandContainer();
    }
    inline Item* getLeftHandItem () const
    {
        return inv.getLeftHandContainer();
    }
    inline Item* getHandItem (actorHands_t hand) const
    {
        if (hand == ACTOR_HAND_RIGHT)
            return inv.getRightHandContainer();
        else if (hand == ACTOR_HAND_LEFT)
            return inv.getLeftHandContainer();
        return nullptr;
    }
    inline Item* getFloorContainer () const
    {
        return inv.getFloorContainer();
    }
    inline void setFloorContainer (Item* il)
    {
        inv.setFloorContainer(il);
    }
    inline void setFloor (le_s* other)
    {
        inv.setFloorContainer(other->getFloorContainer());
    }
    inline void resetFloor ()
    {
        inv.setFloorContainer(nullptr);
    }
    void init ();
} le_t;
 
#define MAX_LOCALMODELS     1024
 
typedef struct localModel_s {
    char id[MAX_VAR];               
    char name[MAX_QPATH];           
    char target[MAX_VAR];
    char tagname[MAX_VAR];          
    char animname[MAX_QPATH];       
    struct localModel_s* parent;    
    bool inuse;
 
    vec3_t origin;
    vec3_t angles;
    vec3_t scale;           
    int entnum;             
    int renderEntityNum;    
    int skin;
    int renderFlags;        
    int frame;              
    int levelflags;
    animState_t as;
    lighting_t lighting;
 
    void (*think) (struct localModel_s*  localModel);
 
    model_t* model;
 
    inline void setScale(const vec3_t scale_) {
        VectorCopy(scale_, scale);
    }
} 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_trace_debug;
extern cvar_t* cl_leshowinvis;
extern cvar_t* cl_map_draw_rescue_zone;
 
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_IsPanicked(le)   ((le)->state & STATE_PANIC)
#define LE_IsRaged(le)      ((le)->state & STATE_RAGE)
#define LE_IsInsane(le)     ((le)->state & STATE_INSANE)
#define LE_IsShaken(le)     ((le)->state & STATE_SHAKEN)
#define LE_IsCrouched(le)   ((le)->state & STATE_CROUCHED)
#define LE_IsDazed(le)      ((le)->state & STATE_DAZED)
 
#define LE_IsInvisible(le)  ((le)->flags & LE_INVISIBLE)
#define LE_IsSelected(le)   ((le)->flags & LE_SELECTED)
 
#define LE_SetInvisible(le) do { if (cl_leshowinvis->integer) le->flags &= ~LE_INVISIBLE; else le->flags |= LE_INVISIBLE; } while (0)
 
#define LE_IsItem(le)       ((le)->type == ET_ITEM)
#define LE_IsCamera(le)     ((le)->type == ET_CAMERA)
#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_IsRotating(le)   ((le)->type == ET_ROTATING)
#define LE_IsDoor(le)       ((le)->type == ET_DOOR || (le)->type == ET_DOOR_SLIDING)
#define LE_IsBreakable(le)  ((le)->type == ET_BREAKABLE)
#define LE_IsBrushModel(le) (LE_IsBreakable(le) || LE_IsDoor(le) || LE_IsRotating(le))
#define LE_IsNotSolid(le)   ((le)->type == ET_TRIGGER_RESCUE || (le)->type == ET_TRIGGER_NEXTMAP)
 
#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, localEntityThinkFunc_t think);
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_HiddenMove(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(dbuffer* msg);
void LM_AddToScene(void);
 
bool LE_BrushModelAction(le_t* le, entity_t* ent);
void CL_RecalcRouting(const le_t* le);
void CL_CompleteRecalcRouting(void);
 
void LE_LinkFloorContainer(le_t* le);
bool LE_IsLivingAndVisibleActor(const le_t* le);
bool LE_IsLivingActor(const le_t* le);
bool 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);
bool LE_IsLocked(int entnum);
#define LE_NotFoundError(entnum) _LE_NotFoundError(entnum, -1, __FILE__, __LINE__)
#define LE_NotFoundWithTypeError(entnum, type) _LE_NotFoundError(entnum, type, __FILE__, __LINE__)
void _LE_NotFoundError(int entnum, int type, const char* file, const int line) __attribute__((noreturn));
le_t* LE_Find(entity_type_t 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);
const cBspModel_t* LE_GetClipModel(const le_t* le);
model_t* LE_GetDrawModel(unsigned int modelIndex);
void LET_SlideDoor(le_t* le, int speed);
void LET_RotateDoor(le_t* le, int speed);
 
trace_t CL_Trace(const Line& traceLine, const AABB& box, const le_t* passle, le_t* passle2, int contentmask, int worldLevel);
 
void LM_Register(void);
localModel_t* LM_GetByID(const char* id);