g_utils.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"
#include <time.h>

void G_FreeEdict (edict_t *ent)
{
    G_EventDestroyEdict(ent);

    /* unlink from world */
    gi.UnlinkEdict(ent);

    memset(ent, 0, sizeof(*ent));
    ent->classname = "freed";
    ent->inuse = qfalse;
}

edict_t *G_GetEdictFromPos (const pos3_t pos, const entity_type_t type)
{
    edict_t *floor = NULL;

    while ((floor = G_EdictsGetNextInUse(floor))) {
        if (type > ET_NULL && floor->type != type)
            continue;
        if (!VectorCompare(pos, floor->pos))
            continue;

        return floor;
    }
    /* nothing found at this pos */
    return NULL;
}

qboolean G_UseEdict (edict_t *ent, edict_t* activator)
{
    if (!ent)
        return qfalse;

    /* no use function assigned */
    if (!ent->use)
        return qfalse;

    if (!ent->use(ent, activator))
        return qfalse;

    /* only the master edict is calling the opening for the other group parts */
    if (!(ent->flags & FL_GROUPSLAVE)) {
        edict_t* chain = ent->groupChain;
        while (chain) {
            G_UseEdict(chain, activator);
            chain = chain->groupChain;
        }
    }

    return qtrue;
}

static const objDef_t* G_GetObjectForFiredef (const fireDef_t* fd)
{
    int i, j, k;

    /* For each object ... */
    for (i = 0; i < gi.csi->numODs; i++) {
        const objDef_t *od = &gi.csi->ods[i];
        /* For each weapon-entry in the object ... */
        for (j = 0; j < od->numWeapons; j++) {
            /* For each fire-definition in the weapon entry  ... */
            for (k = 0; k < od->numFiredefs[j]; k++) {
                const fireDef_t *csiFD = &od->fd[j][k];
                if (csiFD == fd)
                    return od;
            }
        }
    }

    return NULL;
}

const char* G_GetWeaponNameForFiredef (const fireDef_t *fd)
{
    const objDef_t* obj = G_GetObjectForFiredef(fd);
    if (!obj)
        return "unknown";
    else
        return obj->id;
}

player_t* G_GetPlayerForTeam (int team)
{
    int i;
    player_t *p;

    /* search corresponding player (even ai players) */
    for (i = 0, p = game.players; i < game.sv_maxplayersperteam * 2; i++, p++)
        if (p->inuse && p->pers.team == team)
            /* found player */
            return p;

    return NULL;
}

void G_TakeDamage (edict_t *ent, int damage)
{
    if (G_IsBreakable(ent) || G_IsActor(ent))
        ent->HP = max(ent->HP - damage, 0);
}

static void G_TraceDraw (const vec3_t start, const vec3_t end)
{
    if (g_drawtraces->integer)
        G_EventParticleSpawn(PM_ALL, "fadeTracerDebug", TRACING_ALL_VISIBLE_LEVELS, start, end, vec3_origin);
}

qboolean G_TestLineWithEnts (const vec3_t start, const vec3_t end)
{
    const char *entList[MAX_EDICTS];
    /* generate entity list */
    G_GenerateEntList(entList);
    G_TraceDraw(start, end);
    /* test for visibility */
    return gi.TestLineWithEnt(start, end, TL_FLAG_NONE, entList);
}

qboolean G_TestLine (const vec3_t start, const vec3_t end)
{
    G_TraceDraw(start, end);
    return gi.TestLine(start, end, TL_FLAG_NONE);
}

trace_t G_Trace (const vec3_t start, const vec3_t end, const edict_t * passent, int contentmask)
{
    G_TraceDraw(start, end);
    return gi.Trace(start, NULL, NULL, end, passent, contentmask);
}

const char* G_GetPlayerName (int pnum)
{
    if (pnum >= game.sv_maxplayersperteam)
        return "";
    else
        return game.players[pnum].pers.netname;
}

void G_PrintStats (const char *buffer)
{
    gi.DPrintf("[STATS] %s\n", buffer);
    if (logstatsfile) {
        struct tm *t;
        char tbuf[32];
        time_t aclock;

        time(&aclock);
        t = localtime(&aclock);

        Com_sprintf(tbuf, sizeof(tbuf), "%4i/%02i/%02i %02i:%02i:%02i", t->tm_year + 1900,
                t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);

        fprintf(logstatsfile, "[STATS] %s - %s\n", tbuf, buffer);
    }
}

void G_PrintActorStats (const edict_t *victim, const edict_t *attacker, const fireDef_t *fd)
{
    char buffer[512];

    if (attacker != NULL) {
        if (victim->pnum != attacker->pnum) {
            const char *victimName = G_GetPlayerName(victim->pnum);
            const char *attackerName = G_GetPlayerName(attacker->pnum);
            if (victimName[0] == '\0') { /* empty string */
                switch (victim->team) {
                case TEAM_CIVILIAN:
                    victimName = "civilian";
                    break;
                case TEAM_ALIEN:
                    victimName = "alien";
                    break;
                default:
                    victimName = "unknown";
                    break;
                }
            }
            if (attackerName[0] == '\0') { /* empty string */
                switch (attacker->team) {
                case TEAM_CIVILIAN:
                    attackerName = "civilian";
                    break;
                case TEAM_ALIEN:
                    attackerName = "alien";
                    break;
                default:
                    attackerName = "unknown";
                    break;
                }
            }
            if (victim->team != attacker->team) {
                Com_sprintf(buffer, sizeof(buffer), "%s (%s) %s %s (%s) with %s of %s",
                    attackerName, attacker->chr.name,
                    (victim->HP == 0 ? "kills" : "stuns"),
                    victimName, victim->chr.name, fd->name, G_GetWeaponNameForFiredef(fd));
            } else {
                Com_sprintf(buffer, sizeof(buffer), "%s (%s) %s %s (%s) (teamkill) with %s of %s",
                    attackerName, attacker->chr.name,
                    (victim->HP == 0 ? "kills" : "stuns"),
                    victimName, victim->chr.name, fd->name, G_GetWeaponNameForFiredef(fd));
            }
        } else {
            const char *attackerName = G_GetPlayerName(attacker->pnum);
            Com_sprintf(buffer, sizeof(buffer), "%s %s %s (own team) with %s of %s",
                attackerName, (victim->HP == 0 ? "kills" : "stuns"),
                victim->chr.name, fd->name, G_GetWeaponNameForFiredef(fd));
        }
    } else {
        const char *victimName = G_GetPlayerName(victim->pnum);
        Com_sprintf(buffer, sizeof(buffer), "%s (%s) was %s",
            victimName, victim->chr.name, (victim->HP == 0 ? "killed" : "stunned"));
    }
    G_PrintStats(buffer);
}

edict_t *G_Find (edict_t * from, int fieldofs, char *match)
{
    edict_t *ent = from;

    while ((ent = G_EdictsGetNextInUse(ent))) {
        const char *s = *(const char **) ((byte *) ent + fieldofs);
        if (!s)
            continue;
        if (!Q_strcasecmp(s, match))
            return ent;
    }

    return NULL;
}

edict_t *G_FindTargetEntity (const char *target)
{
    edict_t *ent = NULL;

    while ((ent = G_EdictsGetNext(ent))) {
        const char *n = ent->targetname;
        if (n && !strcmp(n, target))
            return ent;
    }

    return NULL;
}

edict_t *G_FindRadius (edict_t * from, const vec3_t org, float rad, entity_type_t type)
{
    edict_t *ent = from;

    while ((ent = G_EdictsGetNextInUse(ent))) {
        int j;
        vec3_t eorg;
        for (j = 0; j < 3; j++)
            eorg[j] = org[j] - (ent->origin[j] + (ent->mins[j] + ent->maxs[j]) * 0.5);
        if (VectorLength(eorg) > rad)
            continue;
        if (type != ET_NULL && ent->type != type)
            continue;
        return ent;
    }

    return NULL;
}

#define IS_BMODEL(ent) ((ent)->model && (ent)->model[0] == '*' && (ent)->solid == SOLID_BSP)

void G_GenerateEntList (const char *entList[MAX_EDICTS])
{
    int i = 0;
    edict_t *ent = NULL;

    /* generate entity list */
    while ((ent = G_EdictsGetNextInUse(ent)))
        if (IS_BMODEL(ent))
            entList[i++] = ent->model;
    entList[i] = NULL;
}

void G_RecalcRouting (const edict_t * ent)
{
    const char *entList[MAX_EDICTS];
    /* generate entity list */
    G_GenerateEntList(entList);
    /* recalculate routing */
    gi.GridRecalcRouting(gi.routingMap, ent->model, entList);
}

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

    while ((ent = G_EdictsGetNextInUse(ent)))
        if (IS_BMODEL(ent))
            G_RecalcRouting(ent);
}

static void G_ResetTriggers (edict_t *ent, edict_t **touched, int num)
{
    edict_t *trigger = NULL;
    while ((trigger = G_EdictsGetNextInUse(trigger))) {
        if (trigger->solid == SOLID_TRIGGER) {
            if (trigger->reset != NULL) {
                int i;
                for (i = 0; i < num; i++) {
                    if (touched[i] == ent)
                        break;
                }
                if (i == num)
                    trigger->reset(trigger, ent);
            }
        }
    }
}

int G_TouchTriggers (edict_t *ent)
{
    int i, num, usedNum = 0;
    edict_t *touch[MAX_EDICTS];

    if (!G_IsLivingActor(ent))
        return 0;

    num = gi.BoxEdicts(ent->absmin, ent->absmax, touch, MAX_EDICTS);

    G_ResetTriggers(ent, touch, num);

    /* be careful, it is possible to have an entity in this
     * list removed before we get to it (killtriggered) */
    for (i = 0; i < num; i++) {
        edict_t *hit = touch[i];
        if (hit->solid != SOLID_TRIGGER)
            continue;
        if (!hit->touch)
            continue;
        if (hit->touch(hit, ent))
            usedNum++;
    }
    return usedNum;
}

void G_TouchSolids (edict_t *ent)
{
    int i, num;
    edict_t *touch[MAX_EDICTS];

    num = gi.BoxEdicts(ent->absmin, ent->absmax, touch, MAX_EDICTS);

    /* be careful, it is possible to have an entity in this
     * list removed before we get to it (killtriggered) */
    for (i = 0; i < num; i++) {
        edict_t* hit = touch[i];
        if (!hit->inuse)
            continue;
        if (hit->solid == SOLID_TRIGGER)
            continue;
        if (ent->touch)
            ent->touch(ent, hit);
        if (!ent->inuse)
            break;
    }
}

void G_TouchEdicts (edict_t *ent, float extend)
{
    int i, num;
    edict_t *touch[MAX_EDICTS];
    vec3_t absmin, absmax;
    const char *entName = (ent->model) ? ent->model : ent->chr.name;

    for (i = 0; i < 3; i++) {
        absmin[i] = ent->absmin[i] - extend;
        absmax[i] = ent->absmax[i] + extend;
    }

    num = gi.TouchEdicts(absmin, absmax, touch, MAX_EDICTS, ent);
    Com_DPrintf(DEBUG_GAME, "G_TouchEdicts: Entities touching %s: %i (%f extent).\n", entName, num, extend);

    /* be careful, it is possible to have an entity in this
     * list removed before we get to it (killtriggered) */
    for (i = 0; i < num; i++) {
        edict_t* hit = touch[i];
        if (!hit->inuse)
            continue;
        if (ent->touch)
            ent->touch(ent, hit);
    }
}