g_edicts.cpp

Go to the documentation of this file.

/*
All original material Copyright (C) 2002-2020 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;
    memcpy(duplicate, edict, sizeof(*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);
        OBJZERO(camera);
        OBJZERO(moveinfo);
        OBJZERO(AI);

        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;
}