cp_ufo.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 "cp_campaign.h"
#include "cp_map.h"
#include "cp_ufo.h"
#include "cp_aircraft.h"
#include "cp_mapfightequip.h"

static const float MAX_DETECTING_RANGE = 25.0f; 
aircraft_t* UFO_GetByIDX (const int idx)
{
    assert(idx >= 0 && idx < MAX_UFOONGEOSCAPE);
    return &ccs.ufos[idx];
}

const technology_t* UFO_GetTechnologyFromType (const ufoType_t type)
{
    const char *id = Com_UFOTypeToShortName(type);
    const technology_t *tech = RS_GetTechByProvided(id);
    return tech;
}

const aircraft_t* UFO_GetByType (const ufoType_t type)
{
    int i;

    for (i = 0; i < ccs.numAircraftTemplates; i++) {
        aircraft_t *ufo = &ccs.aircraftTemplates[i];
        if (ufo->ufotype == type)
            return ufo;
    }

    Com_Error(ERR_DROP, "No ufo with type %i found", type);
}

qboolean UFO_ShouldAppearOnGeoscape (const ufoType_t type)
{
    const aircraft_t *ufo = UFO_GetByType(type);

    return ufo->ufoInterestOnGeoscape <= ccs.overallInterest;
}

const char* UFO_TypeToName (ufoType_t type)
{
    const technology_t *tech = UFO_GetTechnologyFromType(type);
    if (tech)
        return _(tech->name);
    Com_Error(ERR_DROP, "UFO_TypeToName(): Unknown UFO type %i\n", type);
}
const char* UFO_AircraftToIDOnGeoscape (const aircraft_t *ufocraft)
{
    const technology_t *tech = ufocraft->tech;

    assert(tech);

    if (ufocraft->detectionIdx)
        return va("%s #%i", (RS_IsResearched_ptr(tech)) ? _(ufocraft->name) : _("UFO"), ufocraft->detectionIdx);
    return (RS_IsResearched_ptr(tech)) ? _(ufocraft->name) : _("UFO");
}

const char* UFO_MissionResultToString (void)
{
    const char *ufoName = Com_UFOTypeToShortName(ccs.missionResults.ufotype);
    const aircraft_t *aircraft = AIR_GetAircraft(ufoName);
    const char *geoscapeName = UFO_AircraftToIDOnGeoscape(aircraft);
    if (ccs.missionResults.crashsite)
        return va(_("\nSecured crashed %s (%.0f%%)\n"), geoscapeName, ccs.missionResults.ufoCondition * 100);
    else
        return va(_("\nSecured landed %s\n"), geoscapeName);
}

void UFO_SetRandomDest (aircraft_t* ufocraft)
{
    vec2_t pos;

    CP_GetRandomPosOnGeoscape(pos, qfalse);

    UFO_SendToDestination(ufocraft, pos);
}

void UFO_SetRandomDestAround (aircraft_t* ufocraft, vec2_t pos)
{
    vec2_t dest;
    const float spread = 2.0f;
    float rand1, rand2;

    gaussrand(&rand1, &rand2);
    rand1 *= spread;
    rand2 *= spread;

    Vector2Set(dest, pos[0] + rand1, pos[1] + rand2);

    UFO_SendToDestination(ufocraft, dest);
}

static void UFO_SetRandomPos (aircraft_t* ufocraft)
{
    vec2_t pos;

    CP_GetRandomPosOnGeoscape(pos, qfalse);

    Vector2Copy(pos, ufocraft->pos);
}

static int UFO_IsTargetOfBase (const aircraft_t const *ufo, const base_t const *base)
{
    int i;

    for (i = 0; i < base->numBatteries; i++) {
        if (base->batteries[i].target == ufo)
            return UFO_IS_TARGET_OF_MISSILE;
    }

    for (i = 0; i < base->numLasers; i++) {
        if (base->lasers[i].target == ufo)
            return UFO_IS_TARGET_OF_LASER;
    }

    return UFO_IS_NO_TARGET;
}

static int UFO_IsTargetOfInstallation (const aircraft_t const *ufo, const installation_t const *installation)
{
    int i;

    for (i = 0; i < installation->numBatteries; i++) {
        if (installation->batteries[i].target == ufo)
            return UFO_IS_TARGET_OF_MISSILE;
    }

    return UFO_IS_NO_TARGET;
}

static void UFO_UpdateAlienInterestForOneBase (const aircraft_t const *ufo, base_t *base)
{
    float probability;
    float distance;
    const float decreasingDistance = 10.0f; 
    const float decreasingFactor = 5.0f;

    /* ufo can't find base if it's too far */
    distance = GetDistanceOnGlobe(ufo->pos, base->pos);
    if (distance > MAX_DETECTING_RANGE)
        return;

    /* UFO has an increased probability to find a base if it is firing at it */
    switch (UFO_IsTargetOfBase(ufo, base)) {
    case UFO_IS_TARGET_OF_MISSILE:
        probability = 0.01f;
        break;
    case UFO_IS_TARGET_OF_LASER:
        probability = 0.001f;
        break;
    default:
        probability = 0.0001f;
        break;
    }

    /* decrease probability if the ufo is far from base */
    if (distance > decreasingDistance)
        probability /= decreasingFactor;

    /* probability must depend on DETECTION_INTERVAL (in case we change the value) */
    probability *= DETECTION_INTERVAL;

    base->alienInterest += probability;
}

static void UFO_UpdateAlienInterestForOneInstallation (const aircraft_t const *ufo, installation_t *installation)
{
    float probability;
    float distance;
    const float decreasingDistance = 10.0f; 
    const float decreasingFactor = 5.0f;

    /* ufo can't find base if it's too far */
    distance = GetDistanceOnGlobe(ufo->pos, installation->pos);
    if (distance > MAX_DETECTING_RANGE)
        return;

    /* UFO has an increased probability to find a base if it is firing at it */
    switch (UFO_IsTargetOfInstallation(ufo, installation)) {
    case UFO_IS_TARGET_OF_MISSILE:
        probability = 0.01f;
        break;
    case UFO_IS_TARGET_OF_LASER:
        probability = 0.001f;
        break;
    default:
        probability = 0.0001f;
        break;
    }

    /* decrease probability if the ufo is far from base */
    if (distance > decreasingDistance)
        probability /= decreasingFactor;

    /* probability must depend on DETECTION_INTERVAL (in case we change the value) */
    probability *= DETECTION_INTERVAL;

    installation->alienInterest += probability;
}

void UFO_UpdateAlienInterestForAllBasesAndInstallations (void)
{
    int ufoIdx;

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

        /* landed UFO can't detect any phalanx base or installation */
        if (ufo->landed)
            continue;

        for (idx = 0; idx < MAX_BASES; idx++) {
            base_t *base = B_GetFoundedBaseByIDX(idx);
            if (!base)
                continue;
            UFO_UpdateAlienInterestForOneBase(ufo, base);
        }

        for (idx = 0; idx < MAX_INSTALLATIONS; idx++) {
            installation_t *installation = INS_GetFoundedInstallationByIDX(idx);
            if (!installation)
                continue;
            UFO_UpdateAlienInterestForOneInstallation(ufo, installation);
        }
    }
}

static void UFO_SearchAircraftTarget (aircraft_t *ufo)
{
    int baseIdx;
    aircraft_t* phalanxAircraft;
    float distance = 999999.;

    /* UFO never try to attack a PHALANX aircraft except if they came on earth in that aim */
    if (ufo->mission->stage != STAGE_INTERCEPT) {
        /* Check if UFO is defending itself */
        if (ufo->aircraftTarget)
            UFO_CheckShootBack(ufo, ufo->aircraftTarget);
        return;
    }

    /* check if the ufo is already attacking an aircraft */
    if (ufo->aircraftTarget) {
        /* check if the target disappeared from geoscape (fled in a base) */
        if (AIR_IsAircraftOnGeoscape(ufo->aircraftTarget))
            AIRFIGHT_ExecuteActions(ufo, ufo->aircraftTarget);
        else
            ufo->aircraftTarget = NULL;
        return;
    }

    ufo->status = AIR_TRANSIT;
    for (baseIdx = 0; baseIdx < MAX_BASES; baseIdx++) {
        const base_t *base = B_GetFoundedBaseByIDX(baseIdx);

        if (!base)
            continue;

        /* check if the ufo can attack an aircraft */
        phalanxAircraft = NULL;
        while ((phalanxAircraft = AIR_GetNextFromBase(base, phalanxAircraft)) != NULL) {
            /* check that aircraft is flying */
            if (AIR_IsAircraftOnGeoscape(phalanxAircraft)) {
                /* get the distance from ufo to aircraft */
                const float dist = GetDistanceOnGlobe(ufo->pos, phalanxAircraft->pos);
                /* check out of reach */
                if (dist > MAX_DETECTING_RANGE)
                    continue;
                /* choose the nearest target */
                if (dist < distance) {
                    distance = dist;
                    if (UFO_SendPursuingAircraft(ufo, phalanxAircraft) && UFO_IsUFOSeenOnGeoscape(ufo)) {
                        /* stop time and notify */
                        MSO_CheckAddNewMessage(NT_UFO_ATTACKING, _("Notice"), va(_("A UFO is flying toward %s"), phalanxAircraft->name), qfalse,
                                MSG_STANDARD, NULL);
                    }
                }
            }
        }
    }
}

qboolean UFO_SendPursuingAircraft (aircraft_t* ufo, aircraft_t* aircraft)
{
    int slotIdx;
    vec2_t dest;

    assert(ufo);
    assert(aircraft);

    /* check whether the ufo can shoot the aircraft - if not, don't try it even */
    slotIdx = AIRFIGHT_ChooseWeapon(ufo->weapons, ufo->maxWeapons, ufo->pos, aircraft->pos);
    if (slotIdx == AIRFIGHT_WEAPON_CAN_NEVER_SHOOT) {
        /* no ammo left: stop attack */
        ufo->status = AIR_TRANSIT;
        return qfalse;
    }

    AIR_GetDestinationWhilePursuing(ufo, aircraft, &dest);
    MAP_MapCalcLine(ufo->pos, dest, &ufo->route);
    ufo->status = AIR_UFO;
    ufo->time = 0;
    ufo->point = 0;
    ufo->aircraftTarget = aircraft;

    return qtrue;
}

void UFO_SendToDestination (aircraft_t* ufo, vec2_t dest)
{
    assert(ufo);

    MAP_MapCalcLine(ufo->pos, dest, &ufo->route);
    ufo->status = AIR_TRANSIT;
    ufo->time = 0;
    ufo->point = 0;
}

void UFO_CheckShootBack (aircraft_t *ufo, aircraft_t* phalanxAircraft)
{
    /* check if the ufo is already attacking an aircraft */
    if (ufo->aircraftTarget) {
        /* check if the target flee in a base */
        if (AIR_IsAircraftOnGeoscape(ufo->aircraftTarget))
            AIRFIGHT_ExecuteActions(ufo, ufo->aircraftTarget);
        else {
            ufo->aircraftTarget = NULL;
            CP_UFOProceedMission(ufo);
        }
    } else {
        /* check that aircraft is flying */
        if (AIR_IsAircraftOnGeoscape(phalanxAircraft))
            UFO_SendPursuingAircraft(ufo, phalanxAircraft);
    }
}

void UFO_CampaignRunUFOs (int deltaTime)
{
    int ufoIdx, k;

    assert(deltaTime >= 0);

    /* deltaTime may be 0 if a UFO has been detection occurred */
    if (!deltaTime)
        return;

    /* now the ufos are flying around, too - cycle backward - ufo might be destroyed */
    for (ufoIdx = ccs.numUFOs - 1; ufoIdx >= 0; ufoIdx--) {
        aircraft_t *ufo = UFO_GetByIDX(ufoIdx);
        /* don't run a landed ufo */
        if (ufo->landed)
            continue;

        /* Every UFO on geoscape should have a mission assigned */
        assert(ufo->mission);

        /* reached target and not following a phalanx aircraft? then we need a new destination */
        if (AIR_AircraftMakeMove(deltaTime, ufo) && ufo->status != AIR_UFO) {
            float *end;
            end = ufo->route.point[ufo->route.numPoints - 1];
            Vector2Copy(end, ufo->pos);
            MAP_CheckPositionBoundaries(ufo->pos);
            if (ufo->mission->stage == STAGE_INTERCEPT && ufo->mission->data) {
                /* Attacking an installation: fly over this installation */
                UFO_SetRandomDestAround(ufo, ufo->mission->pos);
            } else
                UFO_SetRandomDest(ufo);
            if (CP_CheckNextStageDestination(ufo))
                /* UFO has been removed from game */
                continue;
            /* UFO was destroyed (maybe because the mission was removed) */
            if (ufoIdx == ccs.numUFOs)
                continue;
        }

        /* is there a PHALANX aircraft to shoot at ? */
        UFO_SearchAircraftTarget(ufo);

        /* antimatter tanks */
        if (ufo->fuel <= 0)
            ufo->fuel = ufo->stats[AIR_STATS_FUELSIZE];

        /* Update delay to launch next projectile */
        for (k = 0; k < ufo->maxWeapons; k++) {
            aircraftSlot_t *slot = &ufo->weapons[k];
            if (slot->delayNextShot > 0)
                slot->delayNextShot -= deltaTime;
        }
    }
}

#ifdef DEBUG

static void UFO_DestroyUFOs_f (void)
{
    aircraft_t* ufo;

    for (ufo = ccs.ufos; ufo < ccs.ufos + ccs.numUFOs; ufo++) {
        AIRFIGHT_ActionsAfterAirfight(NULL, ufo, qtrue);
    }
}

static void UFO_ListOnGeoscape_f (void)
{
    aircraft_t* ufo;
    int k;

    Com_Printf("There are %i UFOs in game\n", ccs.numUFOs);
    for (ufo = ccs.ufos; ufo < ccs.ufos + ccs.numUFOs; ufo++) {
        Com_Printf("..%s (%s) - status: %i - pos: %.0f:%0.f\n", ufo->name, ufo->id, ufo->status, ufo->pos[0], ufo->pos[1]);
        Com_Printf("...route length: %i (current: %i), time: %i, distance: %.2f, speed: %i\n",
                ufo->route.numPoints, ufo->point, ufo->time, ufo->route.distance, ufo->stats[AIR_STATS_SPEED]);
        Com_Printf("...linked to mission '%s'\n", ufo->mission ? ufo->mission->id : "no mission");
        Com_Printf("... UFO is %s and %s\n", ufo->landed ? "landed" : "flying", ufo->detected ? "detected" : "undetected");
        Com_Printf("... damage: %i\n", ufo->damage);
        Com_Printf("...%i weapon slots: ", ufo->maxWeapons);
        for (k = 0; k < ufo->maxWeapons; k++) {
            aircraftSlot_t const* const w = &ufo->weapons[k];
            if (w->item) {
                char const* const state = w->ammo && w->ammoLeft > 0 ?
                "(loaded)" : "(unloaded)";
                Com_Printf("%s %s / ", w->item->id, state);
            } else
            Com_Printf("empty / ");
        }
        Com_Printf("\n");
    }
}
#endif

aircraft_t *UFO_AddToGeoscape (ufoType_t ufoType, vec2_t destination, mission_t *mission)
{
    int newUFONum;
    aircraft_t *ufo;

    if (ufoType == UFO_MAX) {
        Com_Printf("UFO_AddToGeoscape: ufotype does not exist\n");
        return NULL;
    }

    /* check max amount */
    if (ccs.numUFOs >= MAX_UFOONGEOSCAPE) {
        Com_DPrintf(DEBUG_CLIENT, "UFO_AddToGeoscape: Too many UFOs on geoscape\n");
        return NULL;
    }

    for (newUFONum = 0; newUFONum < ccs.numAircraftTemplates; newUFONum++) {
        const aircraft_t *tpl = &ccs.aircraftTemplates[newUFONum];
        if (tpl->type == AIRCRAFT_UFO && ufoType == tpl->ufotype && !tpl->notOnGeoscape)
            break;
    }

    if (newUFONum == ccs.numAircraftTemplates) {
        Com_DPrintf(DEBUG_CLIENT, "Could not add ufo type %i to geoscape\n", ufoType);
        return NULL;
    }

    /* Create ufo */
    ufo = UFO_GetByIDX(ccs.numUFOs);
    *ufo = ccs.aircraftTemplates[newUFONum];
    Com_DPrintf(DEBUG_CLIENT, "New UFO on geoscape: '%s' (ccs.numUFOs: %i, newUFONum: %i)\n", ufo->id, ccs.numUFOs, newUFONum);
    ufo->idx = ccs.numUFOs++;

    /* Update Stats of UFO */
    AII_UpdateAircraftStats(ufo);
    /* Give it HP */
    ufo->damage = ufo->stats[AIR_STATS_DAMAGE];
    /* Check for 0 damage which cause invulerable UFOs */
    assert(ufo->damage);

    /* Every ufo on geoscape needs a mission assigned */
    assert(mission);

    /* Initialise ufo data */
    UFO_SetRandomPos(ufo);
    AII_ReloadAircraftWeapons(ufo); /* Load its weapons */
    ufo->landed = qfalse;
    ufo->detected = qfalse; /* Not visible in radars (just for now) */
    ufo->mission = mission;
    if (destination)
        UFO_SendToDestination(ufo, destination);
    else
        UFO_SetRandomDest(ufo); /* Random destination */

    return ufo;
}

void UFO_RemoveFromGeoscape (aircraft_t* ufo)
{
    /* Remove ufo from ufos list */
    const ptrdiff_t num = (ptrdiff_t) (ufo - ccs.ufos);

    Com_DPrintf(DEBUG_CLIENT, "Remove ufo from geoscape: '%s'\n", ufo->id);

    REMOVE_ELEM_ADJUST_IDX(ccs.ufos, num, ccs.numUFOs);
}

#ifdef DEBUG

static void UFO_RemoveFromGeoscape_f (void)
{
    if (ccs.numUFOs > 0)
    UFO_RemoveFromGeoscape(ccs.ufos);
}
#endif

void UFO_DetectNewUFO (aircraft_t *ufocraft)
{
    if (ufocraft->detected)
        return;

    /* Make this UFO detected */
    ufocraft->detected = qtrue;
    if (!ufocraft->detectionIdx) {
        ufocraft->detectionIdx = ++ccs.campaignStats.ufosDetected;
    }
    ufocraft->lastSpotted = ccs.date;

    /* If this is the first UFO on geoscape, activate radar */
    if (!MAP_IsRadarOverlayActivated())
        MAP_SetOverlay("radar");

    MAP_UpdateGeoscapeDock();
}

qboolean UFO_CampaignCheckEvents (void)
{
    qboolean newDetection;
    int baseIdx, installationIdx;
    aircraft_t *ufo, *aircraft;

    newDetection = qfalse;

    /* For each ufo in geoscape */
    for (ufo = ccs.ufos + ccs.numUFOs - 1; ufo >= ccs.ufos; ufo--) {
        char detectedBy[MAX_VAR] = "";
        float minDistance = -1;
        /* detected tells us whether or not a UFO is detected NOW, whereas ufo->detected tells
         * us whether or not the UFO was detected PREVIOUSLY. */
        qboolean detected = qfalse;

        /* don't update UFO status id UFO is landed or crashed */
        if (ufo->landed)
            continue;

        /* note: We can't exit these loops as soon as we found the UFO detected
         * RADAR_CheckUFOSensored registers the UFO in every radars' detection list
         * which detect it */
        for (baseIdx = 0; baseIdx < ccs.numBases; baseIdx++) {
            base_t *base = B_GetFoundedBaseByIDX(baseIdx);
            if (!base)
                continue;
            if (!B_GetBuildingStatus(base, B_POWER))
                continue;

            /* maybe the ufo is already detected, don't reset it */
            if (RADAR_CheckUFOSensored(&base->radar, base->pos, ufo, detected | ufo->detected)) {
                const int distance = GetDistanceOnGlobe(base->pos, ufo->pos);
                detected = qtrue;
                if (minDistance < 0 || minDistance > distance) {
                    minDistance = distance;
                    Q_strncpyz(detectedBy, base->name, sizeof(detectedBy));
                }
            }

            /* Check if UFO is detected by an aircraft */
            aircraft = NULL;
            while ((aircraft = AIR_GetNextFromBase(base, aircraft)) != NULL) {
                if (!AIR_IsAircraftOnGeoscape(aircraft))
                    continue;
                /* maybe the ufo is already detected, don't reset it */
                if (RADAR_CheckUFOSensored(&aircraft->radar, aircraft->pos, ufo, detected | ufo->detected)) {
                    const int distance = GetDistanceOnGlobe(aircraft->pos, ufo->pos);
                    detected = qtrue;
                    if (minDistance < 0 || minDistance > distance) {
                        minDistance = distance;
                        Q_strncpyz(detectedBy, aircraft->name, sizeof(detectedBy));
                    }
                }
            }
        }

        for (installationIdx = 0; installationIdx < ccs.numInstallations; installationIdx++) {
            installation_t *installation = INS_GetFoundedInstallationByIDX(installationIdx);
            if (!installation)
                continue;

            /* maybe the ufo is already detected, don't reset it */
            if (RADAR_CheckUFOSensored(&installation->radar, installation->pos, ufo, detected | ufo->detected)) {
                const int distance = GetDistanceOnGlobe(installation->pos, ufo->pos);
                detected = qtrue;
                if (minDistance < 0 || minDistance > distance) {
                    minDistance = distance;
                    Q_strncpyz(detectedBy, installation->name, sizeof(detectedBy));
                }
            }
        }

        /* Check if ufo appears or disappears on radar */
        if (detected != ufo->detected) {
            if (detected) {
                /* if UFO is aiming a PHALANX aircraft, warn player */
                if (ufo->aircraftTarget) {
                    /* stop time and notify */
                    MSO_CheckAddNewMessage(NT_UFO_ATTACKING, _("Notice"), va(_("A UFO is flying toward %s"), ufo->aircraftTarget->name), qfalse,
                            MSG_STANDARD, NULL);
                } else {
                    MSO_CheckAddNewMessage(NT_UFO_SPOTTED, _("Notice"), va(_("Our radar detected a new UFO near %s"), detectedBy), qfalse,
                            MSG_UFOSPOTTED, NULL);
                }
                newDetection = qtrue;
                UFO_DetectNewUFO(ufo);
            } else if (!detected) {
                MSO_CheckAddNewMessage(NT_UFO_SIGNAL_LOST, _("Notice"), _("Our radar has lost the tracking on a UFO"), qfalse, MSG_UFOSPOTTED, NULL);
                /* Make this UFO undetected */
                ufo->detected = qfalse;
                /* Notify that ufo disappeared */
                AIR_AircraftsUFODisappear(ufo);
                MAP_NotifyUFODisappear(ufo);

                /* Deactivate Radar overlay */
                RADAR_DeactivateRadarOverlay();
            }
        }
    }
    return newDetection;
}

void UFO_NotifyPhalanxAircraftRemoved (const aircraft_t * const aircraft)
{
    int ufoIdx;

    assert(aircraft);

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

        if (ufo->aircraftTarget == aircraft)
            ufo->aircraftTarget = NULL;
    }
}

qboolean UFO_IsUFOSeenOnGeoscape (const aircraft_t const *ufo)
{
#ifdef DEBUG
    if (ufo->notOnGeoscape)
    Com_Error(ERR_DROP, "UFO_IsUFOSeenOnGeoscape: ufo %s can't be used on geoscape", ufo->id);
#endif
    return (!ufo->landed && ufo->detected);
}

void UFO_InitStartup (void)
{
#ifdef DEBUG
    Cmd_AddCommand("debug_destroyufos", UFO_DestroyUFOs_f, "Destroys all UFOs on the geoscape");
    Cmd_AddCommand("debug_listufo", UFO_ListOnGeoscape_f, "Print UFO information to game console");
    Cmd_AddCommand("removeufo", UFO_RemoveFromGeoscape_f, "Remove a UFO from geoscape");
    Cvar_Get("debug_showufos", "0", CVAR_DEVELOPER, "Show all UFOs on geoscape");
#endif
}