g_edict.h

Go to the documentation of this file.

 
/*
All original material Copyright (C) 2002-2025 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.
 
*/
 
#pragma once
 
#include "../shared/ufotypes.h"

#define INH 0
/* This is an attempt to inherit Edict from the part known to the server.
 * This fails because the server knows about parent/child relations between Edicts. */
#if INH
#include "srvedict.h"
class Edict : public SrvEdict {
public:
#else
class Edict {
public:
    bool inuse;
    int linkcount;      
 
    int number;         
 
    vec3_t origin;      
    vec3_t angles;      
    pos3_t pos;         

    solid_t solid;
 
    AABB entBox;        
    AABB absBox;        
    vec3_t size;
 
    Edict* _child;      
    Edict* _owner;      
    int modelindex;     
    const char* classname;
#endif
    /*================================ */
    /* don't change anything above here - the server expects the fields in that order */
    /*================================ */
 
    int mapNum;                 
    const char* model;          

 
    Edict* particleLink;
    const Edict* link;          
    entity_type_t type;
    teammask_t visflags;        
 
    int contentFlags;           
 
    byte dir;                   
 
    int TU;                     
    int HP;                     
    int _STUN;                  
    int morale;                 
 
    int state;                  
 
protected:
    int team;                   
    int pnum;                   
    unsigned int body;
    unsigned int head;
public:
    int frame;                  
 
    char* group;                
protected:
    bool inRescueZone;          
public:
    Edict* clientAction;

    character_t chr;
 
    int spawnflags;             
 
    float angle;                
 
    int radius;                 
    int speed;                  
    const char* target;         
    const char* targetname;     
    const char* item;           
    const char* particle;
    const char* nextmap;
    const char* message;        
    const char* description;    
    const char* noise;          
    edictMaterial_t material;   
    camera_edict_data_t camera;
    int count;                  
    int time;                   
    int sounds;                 
    int dmg;                    
    byte dmgtype;               
    actorSizeEnum_t fieldSize;  
    bool hiding;                

    bool (*_touch)(Edict* self, Edict* activator);
    void (*reset)(Edict* self, Edict* activator);
    float nextthink;
    void (*think)(Edict* self);
    bool (*use)(Edict* self, Edict* activator);
    bool (*destroy)(Edict* self);
 
    linkedList_t* touchedList;          
    int doorState;              
 
    moveinfo_t      moveinfo;

    Edict* groupChain;
    Edict* groupMaster;         
    int flags;                  
 
    AI_t AI;                    
 
    pos3_t* forbiddenListPos;   
    int forbiddenListSize;      
 
    bool active;                
 
    /*==================
     * ctors
     *==================*/
    void init (int idx);
    /*==================
     * setters
     *==================*/
    inline void setPlayerNum(int num) {
        pnum = num;
    }
    inline void setTeam(int team_) {
        team = team_;
    }
    inline void setChild (Edict* child) {
        _child = child;
    }
    inline void nativeReset () {    /* strange name, but there is also a complex function named 'reset' */
        init(number);           /* ... preserve the number */
    }
    inline void setActive() {
        active = true;
    }
    inline void toggleActive() {
        active ^= true;
    }
    inline void resetContainer (const containerIndex_t idx) {
        chr.inv.resetContainer(idx);
    }
    inline void setFloor (const Edict* other) {
        chr.inv.setFloorContainer(other->getFloor());
    }
    inline void resetFloor () {
        chr.inv.setFloorContainer(nullptr);
    }

    inline void calcOrigin () {
        gi.GridPosToVec(fieldSize, pos, origin);
    }

    inline void setOrigin (const pos3_t newPos) {
        VectorCopy(newPos, pos);
        calcOrigin();
    }
 
    /*==================
     * getters
     *==================*/
    inline int getIdNum() const {
        return number;
    }
    inline int getPlayerNum() const {
        return pnum;
    }
    inline Edict* child () {
        return _child;
    }
    inline Edict* owner () {
        return _owner;
    }
    inline Item* getContainer (const containerIndex_t idx) const {
        return chr.inv.getContainer2(idx);
    }
    inline Item* getArmour () const {
        return chr.inv.getArmour();
    }
    inline Item* getRightHandItem () const {
        return chr.inv.getRightHandContainer();
    }
    inline Item* getLeftHandItem () const {
        return chr.inv.getLeftHandContainer();
    }
    inline Item* getHandItem (actorHands_t hand) const {
        if (hand == ACTOR_HAND_RIGHT)
            return chr.inv.getRightHandContainer();
        else if (hand == ACTOR_HAND_LEFT)
            return chr.inv.getLeftHandContainer();
        else return nullptr;
    }
    inline Item* getFloor () const {
        return chr.inv.getFloorContainer();
    }
    inline Player& getPlayer () const {
        return game.players[this->pnum];
    }
    /* also used by camera, mission and civilian_target! */
    inline int getTeam() const {
        return team;
    }
    /*==================
     * checkers
     *==================*/
    inline bool isSameAs (const Edict* other) const {
        return this->getIdNum() == other->getIdNum();
    }
    inline bool isSameTeamAs (const Edict* other) const {
        return this->getTeam() == other->getTeam();
    }

    inline bool isSamePosAs (const pos3_t cmpPos) {
        return VectorCompare(cmpPos, this->pos);
    }
 
    /*
     * Check if given actor is an enemy.
     * Note: Also used by misc_mission to check if an opponent controls the target.
     */
    bool isOpponent (const Actor* actor) const;
    /*==================
     * manipulators
     *==================*/
 
    /*
     * A set of unsorted functions that are to be moved to class Actor later
     */
    inline void setStun(int stu) {
        _STUN = stu;
    }
    inline void addStun(int stu) {
        _STUN += stu;
    }
    inline int getStun() const {
        return _STUN;
    }
    inline void setMorale(int mor) {
        morale = mor;
    }
    /* only Actors should have TUs */
    inline void setTus(int tus) {
        TU = tus;
    }
    inline int getTus() const {
        return TU;
    }
    inline void setTouch(bool (*touch_)(Edict* self, Edict* activator)) {
        _touch = touch_;
    }
    inline bool hasTouch() const {
        return _touch;
    }
    /* This is usually called with an Actor* as a param, except for G_TouchEdicts().
     * The various touch-functions seem to expect an actor, but are not protected against something else. */
    inline bool callTouch(Edict* activator) {
        return _touch(this, activator);
    }

    inline int getReservedTUs () const {
        const chrReservations_t* res = &chr.reservedTus;
        return res->reaction + res->shot + res->crouch;
    }
};

class Actor : public Edict {
public:
    inline int getMorale() const {
        return morale;
    }
    inline bool isState(int flag) const {return state & flag;}
    inline bool isShaken() const        {return isState(STATE_SHAKEN);}
    inline bool isStunned() const       {return isState(STATE_STUN & ~STATE_DEAD);}
    inline bool isPanicked() const      {return isState(STATE_PANIC);}
    inline bool isReaction() const      {return isState(STATE_REACTION);}
    inline bool isRaged() const         {return isState(STATE_RAGE);}
    inline bool isInsane() const        {return isState(STATE_INSANE);}
    inline bool isDazed() const         {return isState(STATE_DAZED);}
    inline bool isCrouched() const      {return isState(STATE_CROUCHED);}
    inline bool isDead() const          {return isState(STATE_DEAD);}
 
    inline void setState(int flag)      {state |= flag;}
    inline void setShaken()             {setState(STATE_SHAKEN);}
    inline void setStunned()            {setState(STATE_STUN);}
    inline void setPanicked()           {setState(STATE_PANIC);}
    inline void setReaction()           {setState(STATE_REACTION);}
    inline void setRaged()              {setState(STATE_RAGE);}
    inline void setInsane()             {setState(STATE_INSANE);}
    inline void setDazed()              {setState(STATE_DAZED);}
    inline void setCrouched()           {setState(STATE_CROUCHED);}
 
    inline void unsetState(int flag)    {state &= ~flag;}
    inline void removeShaken()          {unsetState(STATE_SHAKEN);}
    inline void removeStunned()         {unsetState(STATE_STUN);}
    inline void removePanicked()        {unsetState(STATE_PANIC);}
    inline void removeReaction()        {unsetState(STATE_REACTION);}
    inline void removeRaged()           {unsetState(STATE_RAGE);}
    inline void removeInsane()          {unsetState(STATE_INSANE);}
    inline void removeDazed()           {unsetState(STATE_DAZED);}
    inline void removeCrouched()        {unsetState(STATE_CROUCHED);}
 
    inline unsigned int getBody() const {
        return body;
    }
    inline void setBody(unsigned int body_) {
        body = body_;
    }
    inline unsigned int getHead() const {
        return head;
    }
    inline void setHead(unsigned int head_) {
        head = head_;
    }

    inline int getUsableTUs () const {
        return getTus() - getReservedTUs();
    }

    inline bool isInRescueZone () const {
        return inRescueZone;
    }

    inline void setInRescueZone (bool inRescueZone_) {
        if (inRescueZone_ == isInRescueZone())
            return;
 
        inRescueZone = inRescueZone_;
    }
};
 
Actor* makeActor (Edict* ent);