g_vis.c

Go to the documentation of this file.

/*
Copyright (C) 2002-2010 UFO: Alien Invasion.

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"

qboolean G_FrustumVis (const edict_t *from, const vec3_t point)
{
    return FrustumVis(from->origin, from->dir, point);
}

static qboolean G_LineVis (const vec3_t from, const vec3_t to)
{
    return G_TestLineWithEnts(from, to);
}

float G_ActorVis (const vec3_t from, const edict_t *check, qboolean full)
{
    vec3_t test, dir;
    float delta;
    int i, n;

    /* start on eye height */
    VectorCopy(check->origin, test);
    if (G_IsDead(check)) {
        test[2] += PLAYER_DEAD;
        delta = 0;
    } else if (G_IsCrouched(check)) {
        test[2] += PLAYER_CROUCH - 2;
        delta = (PLAYER_CROUCH - PLAYER_MIN) / 2 - 2;
    } else {
        test[2] += PLAYER_STAND;
        delta = (PLAYER_STAND - PLAYER_MIN) / 2 - 2;
    }

    /* side shifting -> better checks */
    dir[0] = from[1] - check->origin[1];
    dir[1] = check->origin[0] - from[0];
    dir[2] = 0;
    VectorNormalize(dir);
    VectorMA(test, -7, dir, test);

    /* do 3 tests */
    n = 0;
    for (i = 0; i < 3; i++) {
        if (!G_LineVis(from, test)) {
            if (full)
                n++;
            else
                return ACTOR_VIS_100;
        }

        /* look further down or stop */
        if (!delta) {
            if (n > 0)
                return ACTOR_VIS_100;
            else
                return ACTOR_VIS_0;
        }
        VectorMA(test, 7, dir, test);
        test[2] -= delta;
    }

    /* return factor */
    switch (n) {
    case 0:
        return ACTOR_VIS_0;
    case 1:
        return ACTOR_VIS_10;
    case 2:
        return ACTOR_VIS_50;
    default:
        return ACTOR_VIS_100;
    }
}

float G_Vis (const int team, const edict_t *from, const edict_t *check, int flags)
{
    vec3_t eye;

    /* if any of them isn't in use, then they're not visible */
    if (!from->inuse || !check->inuse)
        return ACTOR_VIS_0;

    /* only actors and 2x2 units can see anything */
    if (!G_IsLivingActor(from))
        return ACTOR_VIS_0;

    /* living team members are always visible */
    if (team >= 0 && check->team == team && !G_IsDead(check))
        return ACTOR_VIS_100;

    /* standard team rules */
    if (team >= 0 && from->team != team)
        return ACTOR_VIS_0;

    /* inverse team rules */
    if (team < 0 && (from->team == -team || G_IsCivilian(from) || check->team != -team))
        return ACTOR_VIS_0;

    /* check for same pos */
    if (VectorCompare(from->pos, check->pos))
        return ACTOR_VIS_100;

    if (!G_IsVisibleOnBattlefield(check))
        return ACTOR_VIS_0;

    /* view distance check */
    if (VectorDistSqr(from->origin, check->origin) > MAX_SPOT_DIST * MAX_SPOT_DIST)
        return ACTOR_VIS_0;

    /* view frustum check */
    if (!(flags & VT_NOFRUSTUM) && !G_FrustumVis(from, check->origin))
        return ACTOR_VIS_0;

    /* get viewers eye height */
    VectorCopy(from->origin, eye);
    if (G_IsCrouched(from) || G_IsPaniced(from))
        eye[2] += EYE_CROUCH;
    else
        eye[2] += EYE_STAND;

    /* line trace check */
    switch (check->type) {
    case ET_ACTOR:
    case ET_ACTOR2x2:
        return G_ActorVis(eye, check, qfalse);
    case ET_ITEM:
    case ET_PARTICLE:
        return !G_LineVis(eye, check->origin);
    default:
        return ACTOR_VIS_0;
    }
}

int G_TestVis (const int team, edict_t * check, int flags)
{
    edict_t *from = NULL;
    /* store old flag */
    const int old = G_IsVisibleForTeam(check, team) ? 1 : 0;

    if (g_aidebug->integer)
        return VIS_YES | !old;

    if (!(flags & VT_PERISH) && old)
        return VIS_YES;

    /* test if check is visible */
    while ((from = G_EdictsGetNextInUse(from)))
        if (G_Vis(team, from, check, flags))
            /* visible */
            return VIS_YES | !old;

    /* just return the old state */
    return old;
}

static qboolean G_VisShouldStop (const edict_t *ent)
{
    return G_IsLivingActor(ent) && !G_IsCivilian(ent);
}

static int G_DoTestVis (const int team, edict_t * check, qboolean perish, int playerMask, const edict_t *ent)
{
    int status = 0;
    const int visFlags = perish ? VT_PERISH : 0;
    const int vis = G_TestVis(team, check, visFlags);

    /* visibility has changed ... */
    if (vis & VIS_CHANGE) {
        /* swap the vis mask for the given team */
        check->visflags ^= G_TeamToVisMask(team);
        G_AppearPerishEvent(playerMask, vis & VIS_YES, check, ent);

        /* ... to visible */
        if (vis & VIS_YES) {
            status |= VIS_APPEAR;
            if (G_VisShouldStop(check))
                status |= VIS_STOP;
        } else
            status |= VIS_PERISH;
    }
    return status;
}

int G_CheckVisPlayer (player_t* player, qboolean perish)
{
    int status = 0;
    edict_t* ent = NULL;

    /* check visibility */
    while ((ent = G_EdictsGetNextInUse(ent))) {
        /* check if he's visible */
        status |= G_DoTestVis(player->pers.team, ent, perish, G_PlayerToPM(player), NULL);
    }

    return status;
}

int G_CheckVisTeam (const int team, edict_t *check, qboolean perish, const edict_t *ent)
{
    int status = 0;

    /* check visibility */
    if (check->inuse) {
        /* check if he's visible */
        status |= G_DoTestVis(team, check, perish, G_TeamToPM(team), ent);
    }

    return status;
}

int G_CheckVisTeamAll (const int team, qboolean perish, const edict_t *ent)
{
    edict_t *chk = NULL;
    int status = 0;

    while ((chk = G_EdictsGetNextInUse(chk))) {
        status |= G_CheckVisTeam(team, chk, perish, ent);
    }
    return status;
}

int G_CheckVis (edict_t * check, qboolean perish)
{
    int team;
    int status;

    status = 0;
    for (team = 0; team < MAX_TEAMS; team++)
        if (level.num_alive[team]) {
            if (!check) /* no special entity given, so check them all */
                status |= G_CheckVisTeamAll(team, perish, NULL);
            else
                status |= G_CheckVisTeam(team, check, perish, NULL);
        }

    return status;
}

void G_ClearVisFlags (int team)
{
    edict_t *ent = NULL;
    int mask;

    mask = ~G_TeamToVisMask(team);
    while ((ent = G_EdictsGetNextInUse(ent)))
        ent->visflags &= mask;
}