cp_radar.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 "../cl_shared.h"
#include "../cl_renderer.h" /* R_Color */
#include "../renderer/r_image.h"
#include "../renderer/r_draw.h" /* R_DrawLineStrip */
#include "../ui/ui_nodes.h"
#include "cp_campaign.h"
#include "cp_overlay.h"
#include "cp_map.h"
#include "cp_ufo.h"

qboolean radarOverlayWasSet;

/* Define base radar range (can be modified by level of the radar) */
const float RADAR_BASERANGE = 24.0f;
const float RADAR_BASETRACKINGRANGE = 34.0f;
const float RADAR_AIRCRAFTRANGE = 10.0f;
const float RADAR_AIRCRAFTTRACKINGRANGE = 14.0f;
const float RADAR_INSTALLATIONLEVEL = 1.0f;
static const float RADAR_UPGRADE_MULTIPLIER = 0.4f;

void RADAR_UpdateStaticRadarCoverage (void)
{
    int baseIdx, installationIdx;

    /* Initialise radar range (will be filled below) */
    CP_InitializeRadarOverlay(qtrue);

    /* Add base radar coverage */
    for (baseIdx = 0; baseIdx < MAX_BASES; baseIdx++) {
        const base_t const *base = B_GetFoundedBaseByIDX(baseIdx);
        if (base && base->radar.range) {
            CP_AddRadarCoverage(base->pos, base->radar.range, base->radar.trackingRange, qtrue);
        }
    }

    /* Add installation coverage */
    for (installationIdx = 0; installationIdx < MAX_INSTALLATIONS; installationIdx++) {
        const installation_t const *installation = INS_GetFoundedInstallationByIDX(installationIdx);
        if (installation && installation->founded &&
            installation->installationStatus == INSTALLATION_WORKING && installation->radar.range) {
            CP_AddRadarCoverage(installation->pos, installation->radar.range, installation->radar.trackingRange, qtrue);
        }
    }

    /* Smooth and bind radar overlay without aircraft (in case no aircraft is on geoscape:
     * RADAR_UpdateWholeRadarOverlay won't be called) */
    CP_InitializeRadarOverlay(qfalse);
    CP_UploadRadarCoverage();
}

static inline void RADAR_DrawCoverage (const radar_t* radar, const vec2_t pos)
{
    CP_AddRadarCoverage(pos, radar->range, radar->trackingRange, qfalse);
}

void RADAR_UpdateWholeRadarOverlay (void)
{
    int baseIdx;

    /* Copy Base and installation radar overlay*/
    CP_InitializeRadarOverlay(qfalse);

    /* Add aircraft radar coverage */
    for (baseIdx = 0; baseIdx < MAX_BASES; baseIdx++) {
        base_t *base = B_GetFoundedBaseByIDX(baseIdx);
        aircraft_t *aircraft;

        aircraft = NULL;
        while ((aircraft = AIR_GetNextFromBase(base, aircraft)) != NULL) {
            if (AIR_IsAircraftOnGeoscape(aircraft))
                RADAR_DrawCoverage(&aircraft->radar, aircraft->pos);
        }
    }

    CP_UploadRadarCoverage();
}

static void RADAR_DrawLineCoverage (const uiNode_t* node, const radar_t* radar, const vec2_t pos)
{
    const vec4_t color = {1., 1., 1., .4};
    MAP_MapDrawEquidistantPoints(node, pos, radar->range, color);
    MAP_MapDrawEquidistantPoints(node, pos, radar->trackingRange, color);
}

void RADAR_DrawInMap (const uiNode_t *node, const radar_t *radar, const vec2_t pos)
{
    int x, y;
    const vec4_t color = {1., 1., 1., .3};
    qboolean display;

    /* Show radar range zones */
    RADAR_DrawLineCoverage(node, radar, pos);

    /* everything below is drawn only if there is at least one detected UFO */
    if (!radar->numUFOs)
        return;

    /* Set color */
    R_Color(color);

    /* Draw lines from radar to ufos sensored */
    display = MAP_AllMapToScreen(node, pos, &x, &y, NULL);
    if (display) {
        int i;
        screenPoint_t pts[2];

        pts[0].x = x;
        pts[0].y = y;

        for (i = 0; i < radar->numUFOs; i++) {
            const aircraft_t *ufo = radar->ufos[i];
            if (UFO_IsUFOSeenOnGeoscape(ufo) && MAP_AllMapToScreen(node, ufo->pos, &x, &y, NULL)) {
                pts[1].x = x;
                pts[1].y = y;
                R_DrawLineStrip(2, (int*)pts);
            }
        }
    }

    R_Color(NULL);
}

void RADAR_DeactivateRadarOverlay (void)
{
    int idx;

    /* never deactivate radar if player wants it to be always turned on */
    if (radarOverlayWasSet)
        return;

    for (idx = 0; idx < MAX_BASES; idx++) {
        base_t *base = B_GetFoundedBaseByIDX(idx);
        aircraft_t *aircraft;
        if (!base)
            continue;

        if (base->radar.numUFOs)
            return;

        aircraft = NULL;
        while ((aircraft = AIR_GetNextFromBase(base, aircraft)) != NULL)
            if (aircraft->radar.numUFOs)
                return;
    }

    for (idx = 0; idx < MAX_INSTALLATIONS; idx++) {
        const installation_t const *installation = INS_GetFoundedInstallationByIDX(idx);
        if (!installation)
            continue;

        if (installation->radar.numUFOs)
            return;
    }

    if (MAP_IsRadarOverlayActivated())
        MAP_SetOverlay("radar");
}

static qboolean RADAR_IsUFOSensored (const radar_t* radar, const aircraft_t* ufo)
{
    int i;

    for (i = 0; i < radar->numUFOs; i++)
        if (radar->ufos[i] == ufo)
            return qtrue;

    return qfalse;
}

static qboolean RADAR_AddUFO (radar_t* radar, const aircraft_t* ufo)
{
#ifdef DEBUG
    if (RADAR_IsUFOSensored(radar, ufo)) {
        Com_Printf("RADAR_AddUFO: Aircraft already in radar range\n");
        return qfalse;
    }
#endif

    if (radar->numUFOs >= MAX_UFOONGEOSCAPE)
        return qfalse;

    radar->ufos[radar->numUFOs] = ufo;
    radar->numUFOs++;

    return qtrue;
}

static void RADAR_RemoveUFO (radar_t* radar, const aircraft_t* ufo)
{
    int i;

    assert(radar->numUFOs < MAX_UFOONGEOSCAPE && radar->numUFOs > 0);

    for (i = 0; i < radar->numUFOs; i++)
        if (radar->ufos[i] == ufo)
            break;

    if (i == radar->numUFOs)
        return;

    REMOVE_ELEM(radar->ufos, i, radar->numUFOs);

    RADAR_DeactivateRadarOverlay();
}

static void RADAR_NotifyUFORemovedFromOneRadar (radar_t* radar, const aircraft_t* ufo, qboolean destroyed)
{
    int i;

    for (i = 0; i < radar->numUFOs; i++)
        if (radar->ufos[i] == ufo) {
            radar->numUFOs--;
            radar->ufos[i] = radar->ufos[radar->numUFOs];
            i--;    /* Allow the moved value to be checked */
        } else if (destroyed && (radar->ufos[i] > ufo))
            radar->ufos[i]--;

    RADAR_DeactivateRadarOverlay();
}

void RADAR_NotifyUFORemoved (const aircraft_t* ufo, qboolean destroyed)
{
    int baseIdx;
    int installationIdx;

    for (baseIdx = 0; baseIdx < MAX_BASES; baseIdx++) {
        base_t *base = B_GetFoundedBaseByIDX(baseIdx);
        aircraft_t *aircraft;
        if (!base)
            continue;

        RADAR_NotifyUFORemovedFromOneRadar(&base->radar, ufo, destroyed);

        aircraft = NULL;
        while ((aircraft = AIR_GetNextFromBase(base, aircraft)) != NULL)
            RADAR_NotifyUFORemovedFromOneRadar(&aircraft->radar, ufo, destroyed);
    }

    for (installationIdx = 0; installationIdx < MAX_INSTALLATIONS; installationIdx++) {
        installation_t *installation = INS_GetFoundedInstallationByIDX(installationIdx);
        if (installation && installation->founded && installation->installationStatus == INSTALLATION_WORKING) {
            RADAR_NotifyUFORemovedFromOneRadar(&installation->radar, ufo, destroyed);
        }
    }
}

void RADAR_Initialise (radar_t *radar, float range, float trackingRange, float level, qboolean updateSourceRadarMap)
{
    const int oldrange = radar->range;

    if (!level) {
        radar->range = 0.0f;
        radar->trackingRange = 0.0f;
    } else {
        radar->range = range * (1 + (level - 1) * RADAR_UPGRADE_MULTIPLIER);
        radar->trackingRange = trackingRange * (1 + (level - 1) * RADAR_UPGRADE_MULTIPLIER);
    }

    assert(radar->numUFOs >= 0);

    if (updateSourceRadarMap && !equal(radar->range, oldrange)) {
        RADAR_UpdateStaticRadarCoverage();
        RADAR_UpdateWholeRadarOverlay();
    }
}

void RADAR_InitialiseUFOs (radar_t *radar)
{
    radar->numUFOs = 0;
    memset(radar->ufos, 0, sizeof(radar->ufos));
}

void RADAR_UpdateBaseRadarCoverage_f (void)
{
    int baseIdx;
    base_t *base;
    float level;

    if (Cmd_Argc() < 2) {
        Com_Printf("Usage: %s <baseIdx> <buildingType>\n", Cmd_Argv(0));
        return;
    }

    baseIdx = atoi(Cmd_Argv(1));

    if (baseIdx < 0 || baseIdx >= MAX_BASES) {
        Com_Printf("RADAR_UpdateBaseRadarCoverage_f: %i is outside bounds\n", baseIdx);
        return;
    }

    base = B_GetFoundedBaseByIDX(baseIdx);

    if (!base)
        return;

    level = B_GetMaxBuildingLevel(base, B_RADAR);
    RADAR_Initialise(&base->radar, RADAR_BASERANGE, RADAR_BASETRACKINGRANGE, level, qtrue);
    CP_UpdateMissionVisibleOnGeoscape();
}

void RADAR_UpdateInstallationRadarCoverage (installation_t *installation, const float radarRange, const float trackingRadarRange)
{
    /* Sanity check */
    if (!installation || !installation->installationTemplate)
        Com_Error(ERR_DROP, "RADAR_UpdateInstallationRadarCoverage: No installation or no template!\n");

    /* Do nothing if installation not founded */
    if (!installation->founded)
        return;
    /* Do nothing if installation not finished */
    if (installation->installationStatus != INSTALLATION_WORKING)
        return;
    /* Do nothing if this isn't a RadarTower */
    if (installation->installationTemplate->radarRange <= 0
     || installation->installationTemplate->trackingRange <= 0)
        return;

    RADAR_Initialise(&installation->radar, radarRange, trackingRadarRange, RADAR_INSTALLATIONLEVEL, qtrue);
    CP_UpdateMissionVisibleOnGeoscape();
}

void RADAR_AddDetectedUFOToEveryRadar (const aircraft_t const *ufo)
{
    int idx;

    for (idx = 0; idx < MAX_BASES; idx++) {
        base_t *base = B_GetFoundedBaseByIDX(idx);
        aircraft_t *aircraft;

        if (!base)
            continue;

        if (!RADAR_IsUFOSensored(&base->radar, ufo)) {
            const float dist = GetDistanceOnGlobe(ufo->pos, base->pos); /* Distance from radar to UFO */
            if (dist <= base->radar.trackingRange)
                RADAR_AddUFO(&base->radar, ufo);
        }

        aircraft = NULL;
        while ((aircraft = AIR_GetNextFromBase(base, aircraft)) != NULL) {
            if (!AIR_IsAircraftOnGeoscape(aircraft))
                continue;

            if (!RADAR_IsUFOSensored(&aircraft->radar, ufo)) {
                const float dist = GetDistanceOnGlobe(ufo->pos, aircraft->pos); /* Distance from radar to UFO */
                if (dist <= aircraft->radar.trackingRange)
                    RADAR_AddUFO(&aircraft->radar, ufo);
            }
        }
    }

    for (idx = 0; idx < MAX_INSTALLATIONS; idx++) {
        installation_t *installation = INS_GetFoundedInstallationByIDX(idx);

        if (!installation)
            continue;

        /* No need to check installations without radar */
        if (!installation->radar.trackingRange)
            continue;

        if (!RADAR_IsUFOSensored(&installation->radar, ufo)) {
            const float dist = GetDistanceOnGlobe(ufo->pos, installation->pos); /* Distance from radar to UFO */
            if (dist <= ufo->radar.trackingRange)
                RADAR_AddUFO(&installation->radar, ufo);
        }
    }
}

qboolean RADAR_CheckRadarSensored (const vec2_t pos)
{
    int idx;

    for (idx = 0; idx < MAX_BASES; idx++) {
        const base_t const *base = B_GetFoundedBaseByIDX(idx);
        float dist;
        if (!base)
            continue;

        dist = GetDistanceOnGlobe(pos, base->pos);      /* Distance from base to position */
        if (dist <= base->radar.range)
            return qtrue;
    }

    for (idx = 0; idx < MAX_INSTALLATIONS; idx++) {
        const installation_t const *installation = INS_GetFoundedInstallationByIDX(idx);
        float dist;
        if (!installation)
            continue;

        dist = GetDistanceOnGlobe(pos, installation->pos);      /* Distance from base to position */
        if (dist <= installation->radar.range)
            return qtrue;
    }

    return qfalse;
}

qboolean RADAR_CheckUFOSensored (radar_t *radar, const vec2_t posRadar,
    const aircraft_t *ufo, qboolean detected)
{
    const float ufoDetectionProbability = 0.000125f * DETECTION_INTERVAL;

    int dist;
    qboolean ufoIsSensored;

    /* indice of ufo in radar list */
    ufoIsSensored = RADAR_IsUFOSensored(radar, ufo);
    /* Distance from radar to ufo */
    dist = GetDistanceOnGlobe(posRadar, ufo->pos);

    if ((detected ? radar->trackingRange : radar->range) > dist) {
        if (detected) {
            if (!ufoIsSensored) {
                /* UFO was not sensored by this radar, but by another one
                 * (it just entered this radar zone) */
                RADAR_AddUFO(radar, ufo);
            }
            return qtrue;
        } else {
            /* UFO is sensored by no radar, so it shouldn't be sensored
             * by this radar */
            assert(ufoIsSensored == qfalse);
            /* Check if UFO is detected */
            if (frand() <= ufoDetectionProbability) {
                RADAR_AddDetectedUFOToEveryRadar(ufo);
                return qtrue;
            }
            return qfalse;
        }
    }

    /* UFO is not in this sensor range any more (but maybe
     * in the range of another radar) */
    if (ufoIsSensored)
        RADAR_RemoveUFO(radar, ufo);

    return qfalse;
}

void RADAR_SetRadarAfterLoading (void)
{
    int ufoIdx;

    for (ufoIdx = 0; ufoIdx < ccs.numUFOs; ufoIdx++) {
        const aircraft_t const *ufo = UFO_GetByIDX(ufoIdx);

        if (!ufo->detected)
            continue;

        RADAR_AddDetectedUFOToEveryRadar(ufo);
    }

    MAP_UpdateGeoscapeDock();
}