g_edicts.c

Go to the documentation of this file.

/*
All original material Copyright (C) 2002-2010 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_local.h"

static edict_t *g_edicts;

edict_t* G_EdictsInit (void)
{
    g_edicts = (edict_t *)G_TagMalloc(game.sv_maxentities * sizeof(g_edicts[0]), TAG_GAME);
    return g_edicts;
}

void G_EdictsReset (void)
{
    memset(g_edicts, 0, game.sv_maxentities * sizeof(g_edicts[0]));
}

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

qboolean G_EdictsIsValidNum (const int num)
{
    if (num >= 0 && num < globals.num_edicts)
        return qtrue;
    return qfalse;
}

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

    return g_edicts + num;
}

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

edict_t* G_EdictsGetNext (edict_t* lastEnt)
{
    edict_t* endOfEnts = &g_edicts[globals.num_edicts];
    edict_t* ent;

    if (!globals.num_edicts)
        return NULL;

    if (!lastEnt)
        return g_edicts;
    assert(lastEnt >= g_edicts);
    assert(lastEnt < endOfEnts);

    ent = lastEnt;

    ent++;
    if (ent >= endOfEnts)
        return NULL;
    else
        return ent;
}

edict_t* G_EdictsGetNewEdict (void)
{
    edict_t* ent = NULL;

    /* 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 NULL;
    else
        return ent;
}

edict_t* G_EdictsGetNextInUse (edict_t* lastEnt)
{
    edict_t* ent = lastEnt;

    while ((ent = G_EdictsGetNext(ent))) {
        if (ent->inuse)
            break;
    }
    return ent;
}

edict_t* G_EdictsGetNextLivingActor (edict_t* lastEnt)
{
    edict_t* ent = lastEnt;

    while ((ent = G_EdictsGetNextInUse(ent))) {
        if (G_IsLivingActor(ent))
            break;
    }
    return ent;
}

edict_t* G_EdictsGetNextLivingActorOfTeam (edict_t* lastEnt, const int team)
{
    edict_t* ent = lastEnt;

    while ((ent = G_EdictsGetNextLivingActor(ent))) {
        if (ent->team == team)
            break;
    }
    return ent;
}

edict_t* G_EdictsGetNextActor (edict_t* lastEnt)
{
    edict_t* ent = lastEnt;

    assert(lastEnt < &g_edicts[globals.num_edicts]);

    while ((ent = G_EdictsGetNextInUse(ent))) {
        if (G_IsActor(ent))
            break;
    }
    return ent;
}

void G_EdictCalcOrigin (edict_t* ent)
{
    gi.GridPosToVec(gi.routingMap, ent->fieldSize, ent->pos, ent->origin);
}

void G_EdictSetOrigin (edict_t* ent, const pos3_t newPos)
{
    VectorCopy(newPos, ent->pos);
    gi.GridPosToVec(gi.routingMap, ent->fieldSize, ent->pos, ent->origin);
}

qboolean G_EdictPosIsSameAs (edict_t* ent, const pos3_t cmpPos)
{
    return VectorCompare(cmpPos, ent->pos);
}