g_vis.cpp

Go to the documentation of this file.

/*
Copyright (C) 2002-2020 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"
#include "g_actor.h"
#include "g_client.h"
#include "g_edicts.h"
#include "g_health.h"
#include "g_inventory.h"
#include "g_utils.h"
#include "g_vis.h"

bool G_FrustumVis (const Edict* from, const vec3_t point)
{
    if (G_IsActiveCamera(from)) {
        /* it's a 360 degree camera */
        if (from->camera.rotate)
            return true;
    }
    return FrustumVis(from->origin, from->dir, point);
}

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

bool G_SmokeVis (const vec3_t from, const Edict* check)
{
    const float distance = VectorDist(check->origin, from);
    /* units that are very close are visible in the smoke */
    if (distance > UNIT_SIZE * 1.5f) {
        Edict* e = nullptr;

        while ((e = G_EdictsGetNextInUse(e))) {
            if (G_IsSmoke(e)) {
                if (RayIntersectAABB(from, check->absBox.mins, e->absBox)
                 || RayIntersectAABB(from, check->absBox.maxs, e->absBox)) {
                    return true;
                }
            }
        }
    }
    return false;
}

float G_ActorVis (const Edict* ent, const Edict* check, bool full)
{
    vec3_t eyeEnt;
    G_ActorGetEyeVector(ent, eyeEnt);
    if (G_SmokeVis(eyeEnt, check))
        return ACTOR_VIS_0;

    vec3_t test, dir;
    float delta;
    /* 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] = eyeEnt[1] - check->origin[1];
    dir[1] = check->origin[0] - eyeEnt[0];
    dir[2] = 0;
    VectorNormalizeFast(dir);
    VectorMA(test, -7, dir, test);

    /* do 3 tests */
    int n = 0;
    for (int i = 0; i < 3; i++) {
        if (!G_LineVis(eyeEnt, 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;
    }
}

int G_VisCheckDist (const Edict* const ent)
{
    if (G_IsActiveCamera(ent))
        return MAX_SPOT_DIST_CAMERA;

    if (G_IsActor(ent))
        return MAX_SPOT_DIST * G_ActorGetInjuryPenalty(ent, MODIFIER_SIGHT);

    return MAX_SPOT_DIST;
}

bool G_Vis (const int team, const Edict* from, const Edict* check, const vischeckflags_t flags)
{
    /* if any of them isn't in use, then they're not visible */
    if (!from->inuse || !check->inuse)
        return false;

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

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

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

    /* inverse team rules */
    if (team < 0 && from->getTeam() == -team)
        return false;

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

    if (!G_IsVisibleOnBattlefield(check))
        return false;

    /* view distance check */
    const int spotDist = G_VisCheckDist(from);
    if (VectorDistSqr(from->origin, check->origin) > spotDist * spotDist)
        return false;

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

    /* line trace check */
    switch (check->type) {
    case ET_ACTOR:
    case ET_ACTOR2x2:
        return G_ActorVis(from, check, false) > ACTOR_VIS_0;
    case ET_ITEM:
    case ET_CAMERA:
    case ET_PARTICLE: {
        /* get viewers eye height */
        vec3_t eye;
        G_ActorGetEyeVector(from, eye);
        return !G_LineVis(eye, check->origin);
    }
    default:
        return false;
    }
}

int G_TestVis (const int team, Edict* check, const vischeckflags_t flags)
{
    /* store old flag */
    const int old = G_IsVisibleForTeam(check, team) ? VS_CHANGE : 0;

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

    if (!(flags & VT_PERISHCHK) && old)
        return VS_YES;

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

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

static bool G_VisShouldStop (const Edict* ent)
{
    return G_IsLivingActor(ent) && !G_IsCivilian(ent);
}

static int G_DoTestVis (const int team, Edict* check, const vischeckflags_t visFlags, playermask_t playerMask, const Edict* ent)
{
    int status = 0;
    const int vis = G_TestVis(team, check, visFlags);

    /* visibility has changed ... */
    if (vis & VS_CHANGE) {
        /* swap the vis mask for the given team */
        const bool appear = (vis & VS_YES) == VS_YES;
        if (playerMask == 0) {
            G_VisFlagsSwap(*check, G_TeamToVisMask(team));
        } else {
            G_AppearPerishEvent(playerMask, appear, *check, ent);
        }

        /* ... to visible */
        if (vis & VS_YES) {
            status |= VIS_APPEAR;
            if (G_VisShouldStop(check))
                status |= VIS_STOP;
        } else {
            status |= VIS_PERISH;
        }
    } else if (vis == 0 && (visFlags & VT_NEW)) {
        if (G_IsActor(check)) {
            G_EventActorAdd(playerMask, *check);
        }
    }
    return status;
}

void G_CheckVisPlayer (Player& player, const vischeckflags_t visFlags)
{
    Edict* ent = nullptr;

    /* check visibility */
    while ((ent = G_EdictsGetNextInUse(ent))) {
        /* check if he's visible */
        G_DoTestVis(player.getTeam(), ent, visFlags, G_PlayerToPM(player), nullptr);
    }
}

static int G_CheckVisTeam (const int team, Edict* check, const vischeckflags_t visFlags, const Edict* ent)
{
    int status = 0;

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

    return status;
}

int G_CheckVisTeamAll (const int team, const vischeckflags_t visFlags, const Edict* ent)
{
    Edict* chk = nullptr;
    int status = 0;

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

void G_VisMakeEverythingVisible (void)
{
    Edict* ent = nullptr;
    while ((ent = G_EdictsGetNextInUse(ent))) {
        const int playerMask = G_VisToPM(ent->visflags);
        G_AppearPerishEvent(~playerMask, true, *ent, nullptr);
        if (G_IsActor(ent))
            G_SendInventory(~G_TeamToPM(ent->getTeam()), *ent);
    }
}

void G_CheckVis (Edict* check, const vischeckflags_t visFlags)
{
    for (int team = 0; team < MAX_TEAMS; team++)
        if (level.num_alive[team]) {
            if (!check) /* no special entity given, so check them all */
                G_CheckVisTeamAll(team, visFlags, nullptr);
            else
                G_CheckVisTeam(team, check, visFlags, nullptr);
        }
}

void G_VisFlagsClear (int team)
{
    Edict* ent = nullptr;
    const teammask_t teamMask = ~G_TeamToVisMask(team);
    while ((ent = G_EdictsGetNextInUse(ent))) {
        ent->visflags &= teamMask;
    }
}

void G_VisFlagsAdd (Edict& ent, teammask_t teamMask)
{
    ent.visflags |= teamMask;
}

void G_VisFlagsReset (Edict& ent)
{
    ent.visflags = 0;
}

void G_VisFlagsSwap (Edict& ent, teammask_t teamMask)
{
    ent.visflags ^= teamMask;
}