cp_alienbase.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_alienbase.h"
#include "cp_map.h"
#include "cp_missions.h"
#include "save/save_alienbase.h"

#define MAPDEF_ALIENBASE "alienbase"
#define ALIENBASE_DISCOVERED_TECH "rs_alien_base_discovered_event"

void AB_SetAlienBasePosition (vec2_t pos)
{
    int counter;
    vec2_t randomPos;
    float minDistance = 0.0f;           
    const int maxLoopPosition = 6;      
    counter = 0;
    while (counter < maxLoopPosition) {
        float distance = 0.0f;
        alienBase_t* base = NULL;

        /* Get a random position */
        CP_GetRandomPosOnGeoscape(randomPos, qtrue);

        /* Alien base must not be too close from phalanx base */
        if (MAP_PositionCloseToBase(randomPos))
            continue;

        /* If this is the first alien base, there's no further condition: select this pos and quit */
        if (AB_Exists()) {
            Vector2Copy(randomPos, pos);
            return;
        }

        /* Calculate minimim distance between THIS position (pos) and all alien bases */
        while ((base = AB_GetNext(base)) != NULL) {
            const float currentDistance = GetDistanceOnGlobe(base->pos, randomPos);
            if (distance < currentDistance) {
                distance = currentDistance;
            }
        }

        /* If this position is farther than previous ones, select it */
        if (minDistance < distance) {
            Vector2Copy(randomPos, pos);
            minDistance = distance;
        }

        counter++;
    }
    if (counter == maxLoopPosition)
        Vector2Copy(randomPos, pos);
}

alienBase_t* AB_BuildBase (const vec2_t pos)
{
    alienBase_t base;
    const float initialStealthValue = 50.0f;                
    memset(&base, 0, sizeof(base));
    Vector2Copy(pos, base.pos);
    base.stealth = initialStealthValue;
    base.idx = ccs.campaignStats.alienBasesBuilt++;

    return (alienBase_t*)(LIST_Add(&ccs.alienBases, (void*)&base, sizeof(base)))->data;
}

void AB_DestroyBase (alienBase_t *base)
{
    assert(base);

    LIST_Remove(&ccs.alienBases, (void*)base);

    /* Alien loose all their interest in supply if there's no base to send the supply */
    if (!AB_Exists())
        ccs.interest[INTERESTCATEGORY_SUPPLY] = 0;
}

alienBase_t* AB_GetNext (alienBase_t *lastBase)
{
    return (alienBase_t*)LIST_GetNext(ccs.alienBases, lastBase);
}

alienBase_t* AB_GetByIDX (int baseIDX)
{
    alienBase_t* base = NULL;

    while ((base = AB_GetNext(base)) != NULL) {
        if (base->idx == baseIDX)
            return base;
    }
    return NULL;
}

void CP_SpawnAlienBaseMission (alienBase_t *alienBase)
{
    mission_t *mission;

    mission = CP_CreateNewMission(INTERESTCATEGORY_ALIENBASE, qtrue);
    if (!mission) {
        Com_Printf("CP_SpawnAlienBaseMission: Could not add mission, abort\n");
        return;
    }

    mission->stage = STAGE_BASE_DISCOVERED;
    mission->data = (void *) alienBase;

    mission->mapDef = Com_GetMapDefinitionByID(MAPDEF_ALIENBASE);
    if (!mission->mapDef)
        Com_Error(ERR_FATAL, "Could not find mapdef "MAPDEF_ALIENBASE);

    Vector2Copy(alienBase->pos, mission->pos);
    mission->posAssigned = qtrue;

    Com_sprintf(mission->location, sizeof(mission->location), _("Alien base"));

    /* Alien base stay until it's destroyed */
    CP_MissionDisableTimeLimit(mission);
    /* mission appear on geoscape, player can go there */
    CP_MissionAddToGeoscape(mission, qfalse);

    if (!RS_MarkStoryLineEventResearched(ALIENBASE_DISCOVERED_TECH))
        Com_DPrintf(DEBUG_CLIENT, ALIENBASE_DISCOVERED_TECH" is not marked as researched\n");
    else
        Cmd_ExecuteString("addeventmail alien_base_discovered");
}

static void AB_UpdateStealthForOneBase (const aircraft_t const *aircraft, alienBase_t *base)
{
    float distance;
    float probability = 0.0001f;            
    const float radarratio = 0.4f;          
    const float decreasingFactor = 5.0f;    
    /* base is already discovered */
    if (base->stealth < 0)
        return;

    /* aircraft can't find base if it's too far */
    distance = GetDistanceOnGlobe(aircraft->pos, base->pos);
    if (distance > aircraft->radar.range)
        return;

    /* the bigger the base, the higher the probability to find it */
    probability *= base->supply;

    /* decrease probability if the base is far from aircraft */
    if (distance > aircraft->radar.range * radarratio)
        probability /= decreasingFactor;

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

    base->stealth -= probability;

    /* base discovered ? */
    if (base->stealth < 0) {
        base->stealth = -10.0f;     /* just to avoid rounding errors */
        CP_SpawnAlienBaseMission(base);
    }
}

void AB_UpdateStealthForAllBase (void)
{
    int baseIdx;

    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) {
            alienBase_t* alienBase = NULL;

            /* Only aircraft on geoscape can detect alien bases */
            if (!AIR_IsAircraftOnGeoscape(aircraft))
                continue;

            while ((alienBase = AB_GetNext(alienBase)) != NULL)
                AB_UpdateStealthForOneBase(aircraft, alienBase);
        }
    }
}

void AB_BaseSearchedByNations (void)
{
    const int daysPerWeek = 7;              
    float probability = 1.0f;               
    const float xviLevel = 20.0f;           
    alienBase_t* base = NULL;

    /* Stealth is updated only once a week */
    if (ccs.date.day % daysPerWeek)
        return;

    while ((base = AB_GetNext(base)) != NULL) {
        const nation_t *nation = MAP_GetNation(base->pos);

        /* If nation is a lot infected, it won't help in finding base (government infected) */
        if (nation && nation->stats[0].xviInfection)
            probability /= 1.0f + nation->stats[0].xviInfection / xviLevel;

        /* the bigger the base, the higher the probability to find it */
        probability *= base->supply;

        base->stealth -= probability;
    }
}

qboolean AB_CheckSupplyMissionPossible (void)
{
    return AB_Exists();
}

alienBase_t* AB_ChooseBaseToSupply (void)
{
    const int baseIDX = rand() % AB_GetAlienBaseNumber();
    return AB_GetByIDX(baseIDX);
}

void AB_SupplyBase (alienBase_t *base, qboolean decreaseStealth)
{
    const float decreasedStealthValue = 5.0f;               
    assert(base);

    base->supply++;
    if (decreaseStealth && base->stealth >= 0.0f)
        base->stealth -= decreasedStealthValue;
}

int AB_GetAlienBaseNumber (void)
{
    return LIST_Count(ccs.alienBases);
}

#ifdef DEBUG

static void AB_AlienBaseDiscovered_f (void)
{
    alienBase_t* base = NULL;

    while ((base = AB_GetNext(base)) != NULL) {
        base->stealth = -10.0f;
        CP_SpawnAlienBaseMission(base);
    }
}

static void AB_AlienBaseList_f (void)
{
    alienBase_t* base = NULL;

    while ((base = AB_GetNext(base)) != NULL) {
        Com_Printf("Alien Base: %i\n", base->idx);
        Com_Printf("...pos: (%f, %f)\n", base->pos[0], base->pos[1]);
        Com_Printf("...supply: %i\n", base->supply);
        if (base->stealth < 0)
            Com_Printf("...base discovered\n");
        else
            Com_Printf("...stealth: %f\n", base->stealth);
    }
}
#endif

void AB_InitStartup (void)
{
#ifdef DEBUG
    Cmd_AddCommand("debug_listalienbase", AB_AlienBaseList_f, "Print Alien Bases information to game console");
    Cmd_AddCommand("debug_alienbasevisible", AB_AlienBaseDiscovered_f, "Set all alien bases to discovered");
#endif
}

qboolean AB_LoadXML (mxml_node_t *p)
{
    int i; 
    mxml_node_t *n, *s;

    n = mxml_GetNode(p, SAVE_ALIENBASE_ALIENBASES);
    if (!n)
        return qfalse;

    for (i = 0, s = mxml_GetNode(n, SAVE_ALIENBASE_BASE); s; i++, s = mxml_GetNextNode(s, n, SAVE_ALIENBASE_BASE)) {
        alienBase_t base;

        base.idx = mxml_GetInt(s, SAVE_ALIENBASE_IDX, -1);
        /* fallback code for compatibility */
        if (base.idx == -1) {
            Com_Printf("No IDX defined for Alienbase %d. This must be an old save.\n", i);
            base.idx = i;
        }
        if (!mxml_GetPos2(s, SAVE_ALIENBASE_POS, base.pos)) {
            Com_Printf("Position is invalid for Alienbase (idx %d)\n", base.idx);
            return qfalse;
        }
        base.supply = mxml_GetInt(s, SAVE_ALIENBASE_SUPPLY, 0);
        base.stealth = mxml_GetFloat(s, SAVE_ALIENBASE_STEALTH, 0.0);
        LIST_Add(&ccs.alienBases, (void*)&base, sizeof(base));
    }

    return qtrue;
}

qboolean AB_SaveXML (mxml_node_t *p)
{
    mxml_node_t *n = mxml_AddNode(p, SAVE_ALIENBASE_ALIENBASES);
    alienBase_t* base = NULL;

    while ((base = AB_GetNext(base)) != NULL) {
        mxml_node_t *s = mxml_AddNode(n, SAVE_ALIENBASE_BASE);
        mxml_AddInt(s, SAVE_ALIENBASE_IDX, base->idx);
        mxml_AddPos2(s, SAVE_ALIENBASE_POS, base->pos);
        mxml_AddIntValue(s, SAVE_ALIENBASE_SUPPLY, base->supply);
        mxml_AddFloatValue(s, SAVE_ALIENBASE_STEALTH, base->stealth);
    }

    return qtrue;
}