g_edicts.cpp

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_utils.c
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.
 
*/
 
#include "g_edicts.h"
#include "g_actor.h"

static Edict* g_edicts;

Edict* G_EdictsConstruct (void)
{
    g_edicts = static_cast<Edict*>(G_TagMalloc(game.sv_maxentities * sizeof(g_edicts[0]), TAG_GAME));
    return g_edicts;
}

void G_EdictsInit (void)
{
    for (int i = 0; i < game.sv_maxentities; i++)
        g_edicts[i].init(i);
}

int G_EdictsGetNumber (const Edict* ent)
{
    const int idx = ent - g_edicts;
    assert(idx >= 0 && idx < globals.num_edicts);
    return idx;
}

bool G_EdictsIsValidNum (const int num)
{
    if (num >= 0 && num < globals.num_edicts)
        return true;
    return false;
}

Edict* G_EdictsGetByNum (const int num)
{
    if (!G_EdictsIsValidNum(num)) {
        gi.DPrintf("Invalid edict num %i\n", num);
        return nullptr;
    }
 
    return g_edicts + num;
}

Edict* G_EdictsGetFirst (void)
{
    return &g_edicts[0];
}

Edict* G_EdictsGetNext (Edict* lastEnt)
{
    if (!globals.num_edicts)
        return nullptr;
 
    if (!lastEnt)
        return g_edicts;
 
    const Edict* endOfEnts = &g_edicts[globals.num_edicts];
    assert(lastEnt >= g_edicts);
    assert(lastEnt < endOfEnts);
 
    Edict* ent = lastEnt;
 
    ent++;
    if (ent >= endOfEnts)
        return nullptr;
 
    return ent;
}
 
Edict* G_EdictDuplicate (const Edict* edict)
{
    Edict* duplicate = G_EdictsGetNewEdict();
    if (duplicate == nullptr)
        return nullptr;
    *duplicate = *edict;
    duplicate->number = G_EdictsGetNumber(duplicate);
    return duplicate;
}

Edict* G_EdictsGetNewEdict (void)
{
    Edict* ent = nullptr;
 
    /* try to recycle an edict */
    while ((ent = G_EdictsGetNext(ent))) {
        if (!ent->inuse)
            return ent;
    }
 
    /* no unused edict found, create a new one */
    ent = &g_edicts[globals.num_edicts];
    globals.num_edicts++;
    if (globals.num_edicts > game.sv_maxentities)
        return nullptr;
 
    return ent;
}

Edict* G_EdictsGetNextInUse (Edict* lastEnt)
{
    Edict* ent = lastEnt;
 
    while ((ent = G_EdictsGetNext(ent))) {
        if (ent->inuse)
            break;
    }
    return ent;
}

Edict* G_EdictsGetTriggerNextMaps (Edict* lastEnt)
{
    Edict* ent = lastEnt;
 
    while ((ent = G_EdictsGetNextInUse(ent))) {
        if (G_IsTriggerNextMap(ent))
            break;
    }
    return ent;
}

Actor* G_EdictsGetNextLivingActor (Actor* lastEnt)
{
    Edict* ent = lastEnt;
 
    while ((ent = G_EdictsGetNextInUse(ent))) {
        if (G_IsLivingActor(ent)) {
            Actor* actor = static_cast<Actor*>(ent);
            if (actor)
                return actor;
            Sys_Error("dynamic_cast to Actor failed.");
        }
    }
    return nullptr;
}

Actor* G_EdictsGetNextLivingActorOfTeam (Actor* lastEnt, const int team)
{
    Actor* actor = lastEnt;
 
    while ((actor = G_EdictsGetNextLivingActor(actor))) {
        if (actor->getTeam() == team)
            break;
    }
    return actor;
}

Actor* G_EdictsGetNextActor (Actor* lastEnt)
{
    Edict* ent = lastEnt;
 
    assert(lastEnt < &g_edicts[globals.num_edicts]);
 
    while ((ent = G_EdictsGetNextInUse(ent))) {
        if (G_IsActor(ent)) {
            Actor* actor = static_cast<Actor*>(ent);
            if (actor)
                return actor;
            Sys_Error("dynamic_cast to Actor failed.");
        }
    }
    return nullptr;
}

Actor* G_EdictsGetActorByUCN (const int ucn, const int team)
{
    Actor* actor = nullptr;
 
    while ((actor = G_EdictsGetNextActor(actor)))
        if (team == actor->getTeam() && actor->chr.ucn == ucn)
            return actor;
 
    return nullptr;
}

Actor* G_EdictsGetLivingActorFromPos (const pos3_t pos)
{
    Actor* actor = nullptr;
 
    while ((actor = G_EdictsGetNextLivingActor(actor))) {
        if (!VectorCompare(pos, actor->pos))
            continue;
 
        return actor;
    }
    /* nothing found at this pos */
    return nullptr;
}

Edict* G_EdictsFindTargetEntity (const char* target)
{
    Edict* ent = nullptr;
 
    while ((ent = G_EdictsGetNextInUse(ent))) {
        const char* n = ent->targetname;
        if (n && Q_streq(n, target))
            return ent;
    }
 
    return nullptr;
}

void G_EdictsThink (void)
{
    /* treat each object in turn */
    /* even the world gets a chance to think */
    Edict* ent = nullptr;
    while ((ent = G_EdictsGetNextInUse(ent))) {
        if (!ent->think)
            continue;
        if (ent->nextthink <= 0)
            continue;
        if (ent->nextthink > level.time + 0.001f)
            continue;
 
        ent->nextthink = level.time + SERVER_FRAME_SECONDS;
        ent->think(ent);
    }
}

Actor* makeActor (Edict* ent)
{
    if (G_IsActor(ent)) {
        /* should be a dynamic_cast one fine day */
        Actor* actor = static_cast<Actor*>(ent);
        if (actor)
            return actor;
    }
    Sys_Error("Unexpected non-Actor Edict found.");
    return nullptr;
}
 
void Edict::init (int idx)
{
    inuse = inRescueZone = hiding = active = false;
    linkcount = modelindex = mapNum = contentFlags = TU = HP = _STUN = morale = state = team = pnum = frame = 0;
    spawnflags = radius = speed = count = time = sounds = dmg = doorState = flags = forbiddenListSize = 0;
    body = head = 0;
    visflags = 0;
    dir = dmgtype = 0;
    angle = nextthink = 0.0f;
    solid = SOLID_NOT;
    type = ET_NULL;
    material = MAT_GLASS;
    fieldSize = ACTOR_SIZE_INVALID;
    entBox = absBox = AABB::EMPTY;
    _child = _owner = particleLink = clientAction = groupChain = groupMaster = nullptr;
    link = nullptr;
    classname = model = target = targetname = item = particle = nextmap = message = description = noise = nullptr;
    group = nullptr;
    _touch = nullptr;
    reset = nullptr;
    think = nullptr;
    use = nullptr;
    destroy = nullptr;
    touchedList = nullptr;
    forbiddenListPos = nullptr;
 
    VectorClear(origin);
    VectorClear(angles);
    VectorClear(pos);
    VectorClear(size);
    camera = camera_edict_data_t();
    moveinfo = moveinfo_t();
    AI = AI_t();
 
    number = idx;
    chr.init();
}

bool Edict::isOpponent (const Actor* actor) const
{
    const bool actControlled = actor->isState(STATE_XVI);
    const bool selfControlled = G_IsState(this, STATE_XVI);
    if (actor->isSameTeamAs(this))
        return selfControlled ? !actControlled : actControlled;
 
    bool opponent = true;
    switch (this->getTeam()) {
    /* Aliens: hostile to everyone */
    case TEAM_ALIEN:
        opponent = !actControlled;
        break;
    /* Civilians: Only hostile to aliens */
    case TEAM_CIVILIAN:
        opponent = G_IsAlien(actor) || actControlled;
        break;
    /* PHALANX and MP teams: Hostile to aliens and rival teams
     * (under AI control while under panic/rage or when g_aihumans is non-zero) */
    default:
        opponent = !G_IsCivilian(actor) || actControlled;
        break;
    }
 
    return selfControlled ? !opponent : opponent;
}