cp_mission_baseattack.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 "../../ui/ui_main.h"
#include "../../ui/ui_popup.h"
#include "../cp_campaign.h"
#include "../cp_map.h"
#include "../cp_ufo.h"
#include "../cp_missions.h"
#include "../cp_time.h"
#include "../cp_alien_interest.h"

static aircraft_t baseAttackFakeAircraft;

void CP_BaseAttackMissionIsSuccess (mission_t *mission)
{
    CL_ChangeIndividualInterest(0.3f, INTERESTCATEGORY_RECON);
    CL_ChangeIndividualInterest(0.1f, INTERESTCATEGORY_HARVEST);
    CL_ChangeIndividualInterest(-0.5f, INTERESTCATEGORY_TERROR_ATTACK);
    CL_ChangeIndividualInterest(-0.5f, INTERESTCATEGORY_INTERCEPT);

    CP_MissionRemove(mission);
}

void CP_BaseAttackMissionIsFailure (mission_t *mission)
{
    base_t *base;

    base = (base_t *)mission->data;

    if (base)
        base->baseStatus = BASE_WORKING;
    ccs.mapAction = MA_NONE;

    /* we really don't want to use the fake aircraft anywhere */
    if (base)
        base->aircraftCurrent = AIR_GetNextFromBase(base, NULL);
    ccs.missionAircraft = NULL;

    CL_ChangeIndividualInterest(0.05f, INTERESTCATEGORY_BUILDING);
    CL_ChangeIndividualInterest(0.1f, INTERESTCATEGORY_BASE_ATTACK);

    /* reset ccs.selectedMission */
    MAP_NotifyMissionRemoved(mission);

    CP_MissionRemove(mission);
}

void CP_BaseAttackMissionOnSpawn (void)
{
    /* Prevent multiple bases from being attacked. by resetting interest. */
    CL_ChangeIndividualInterest(-1.0f, INTERESTCATEGORY_BASE_ATTACK);
}

void CP_BaseAttackMissionLeave (mission_t *mission)
{
    mission->stage = STAGE_RETURN_TO_ORBIT;

    if (mission->ufo) {
        CP_MissionDisableTimeLimit(mission);
        UFO_SetRandomDest(mission->ufo);
        /* Display UFO on geoscape if it is detected */
        mission->ufo->landed = qfalse;
    } else {
        /* Go to next stage on next frame */
        mission->finalDate = ccs.date;
    }
}

void CP_BaseAttackMissionDestroyBase (mission_t *mission)
{
    base_t *base;

    base = (base_t *)mission->data;
    assert(base);
    /* Base attack is over, alien won */
    Com_sprintf(cp_messageBuffer, sizeof(cp_messageBuffer), _("Your base: %s has been destroyed! All employees killed and all equipment destroyed."), base->name);
    MS_AddNewMessage(_("Notice"), cp_messageBuffer, qfalse, MSG_STANDARD, NULL);
    B_Destroy(base);
    CL_GameTimeStop();

    /* we really don't want to use the fake aircraft anywhere */
    ccs.missionAircraft = NULL;

    /* HACK This hack is only needed until base will be really destroyed
     * we must recalculate items in storage because of the items we collected on battlefield */
    B_UpdateStorageCap(base);
    base->aircraftCurrent = NULL;
    base->baseStatus = BASE_WORKING;
}

void CP_BaseAttackStartMission (mission_t *mission)
{
    base_t *base = (base_t *)mission->data;
    linkedList_t *hiredSoldiersInBase = NULL, *pos;

    assert(base);

    mission->stage = STAGE_BASE_ATTACK;

    CP_MissionDisableTimeLimit(mission);

    if (mission->ufo) {
        /* ufo becomes invisible on geoscape, but don't remove it from ufo global array (may reappear)*/
        CP_UFORemoveFromGeoscape(mission, qfalse);
    }

    /* we always need at least one command centre in the base - because the
     * phalanx soldiers have their starting positions here.
     * There should also always be an entrance - the aliens start there
     * but we don't need to check that as entrance can't be destroyed */
    if (!B_GetNumberOfBuildingsInBaseByBuildingType(base, B_COMMAND)) {
        Com_DPrintf(DEBUG_CLIENT, "CP_BaseAttackStartMission: Base '%s' has no Command Center: it can't defend itself. Destroy base.\n", base->name);
        CP_BaseAttackMissionDestroyBase(mission);
        return;
    }

    base->baseStatus = BASE_UNDER_ATTACK;
    ccs.campaignStats.basesAttacked++;

#if 0

    if (base->onAttack[0] != '\0')
        /* execute next frame */
        Cbuf_AddText(va("%s %i", base->onAttack, base->id));
#endif

    MAP_SelectMission(mission);
    ccs.selectedMission->active = qtrue;
    ccs.mapAction = MA_BASEATTACK;
    Com_DPrintf(DEBUG_CLIENT, "Base attack: %s at %.0f:%.0f\n", ccs.selectedMission->id, ccs.selectedMission->pos[0], ccs.selectedMission->pos[1]);

    E_GetHiredEmployees(base, EMPL_SOLDIER, &hiredSoldiersInBase);

    /* Fill the fake aircraft */
    memset(&baseAttackFakeAircraft, 0, sizeof(baseAttackFakeAircraft));
    baseAttackFakeAircraft.homebase = base;
    /* needed for transfer of alien corpses */
    VectorCopy(base->pos, baseAttackFakeAircraft.pos);
#if 0

    /* needed to spawn soldiers on map */
    baseAttackFakeAircraft.maxTeamSize = LIST_Count(hiredSoldiersInBase);
#else
    baseAttackFakeAircraft.maxTeamSize = MAX_ACTIVETEAM;
#endif

    if (!hiredSoldiersInBase) {
        Com_DPrintf(DEBUG_CLIENT, "CP_BaseAttackStartMission: Base '%s' has no soldiers: it can't defend itself. Destroy base.\n", base->name);
        CP_BaseAttackMissionDestroyBase(mission);
        return;
    }

    for (pos = hiredSoldiersInBase; pos != NULL; pos = pos->next) {
        if (E_IsAwayFromBase((employee_t *)pos->data))
            continue;
        AIR_AddToAircraftTeam(&baseAttackFakeAircraft, (employee_t *)pos->data);
    }
    if (AIR_GetTeamSize(&baseAttackFakeAircraft) == 0) {
        Com_DPrintf(DEBUG_CLIENT, "CP_BaseAttackStartMission: Base '%s' has no soldiers at home: it can't defend itself. Destroy base.\n", base->name);
        CP_BaseAttackMissionDestroyBase(mission);
        return;
    }
#if 0

    /* all soldiers in the base should get used */
    baseAttackFakeAircraft.maxTeamSize = AIR_GetTeamSize(&baseAttackFakeAircraft);
#endif

    LIST_Delete(&hiredSoldiersInBase);
    base->aircraftCurrent = &baseAttackFakeAircraft;
    ccs.missionAircraft = &baseAttackFakeAircraft;
    ccs.interceptAircraft = &baseAttackFakeAircraft;    /* needed for updating soldier stats sa CL_UpdateCharacterStats*/
    B_SetCurrentSelectedBase(base);                     /* needed for equipment menu */

    Com_sprintf(popupText, sizeof(popupText), _("Base '%s' is under attack! What to do ?"), base->name);
    UI_RegisterText(TEXT_POPUP, popupText);

    CL_GameTimeStop();
    UI_PushWindow("popup_baseattack", NULL);
}


void CP_CheckBaseAttacks_f (void)
{
    linkedList_t *missionlist = ccs.missions;
    base_t *base = NULL;

    if (Cmd_Argc() == 2) {
        const int baseIDX = atoi(Cmd_Argv(1));
        if (baseIDX >= 0 && baseIDX < MAX_BASES)
            base = B_GetFoundedBaseByIDX(baseIDX);
        else
            Com_Printf("CP_CheckBaseAttacks_f: Invalid base index: %i\n", baseIDX);
    }

    while (missionlist) {
        mission_t *mission = (mission_t*) missionlist->data;

        if (mission->category == INTERESTCATEGORY_BASE_ATTACK && mission->stage == STAGE_BASE_ATTACK) {
            if (base && ((base_t*) mission->data != base))
                continue;
            CP_BaseAttackStartMission(mission);
        }
        missionlist = missionlist->next;
    }
}

static base_t *CP_BaseAttackChooseBase (void)
{
    float randomNumber;
    float sum = 0.0f;
    int baseIdx;
    base_t *base = NULL;

    /* Choose randomly a base depending on alienInterest values for those bases */
    for (baseIdx = 0; baseIdx < ccs.numBases; baseIdx++) {
        base = B_GetFoundedBaseByIDX(baseIdx);
        if (!base)
            continue;
        sum += base->alienInterest;
    }
    randomNumber = frand() * sum;
    for (baseIdx = 0; baseIdx < ccs.numBases; baseIdx++) {
        base = B_GetFoundedBaseByIDX(baseIdx);
        if (!base)
            continue;
        randomNumber -= base->alienInterest;
        if (randomNumber < 0)
            break;
    }

    /* Make sure we have a base */
    assert(base && (randomNumber < 0));

    /* base is already under attack */
    if (base->baseStatus == BASE_UNDER_ATTACK)
        return NULL;
    /* base not (yet) working */
    if (!B_GetBuildingStatus(base, B_COMMAND))
        return NULL;

    return base;
}

static void CP_BaseAttackGoToBase (mission_t *mission)
{
    base_t *base;

    mission->stage = STAGE_MISSION_GOTO;

    base = CP_BaseAttackChooseBase();
    if (!base) {
        Com_Printf("CP_BaseAttackGoToBase: no base found\n");
        CP_MissionRemove(mission);
        return;
    }
    mission->data = (void *)base;

    mission->mapDef = Com_GetMapDefinitionByID("baseattack");
    if (!mission->mapDef) {
        CP_MissionRemove(mission);
        Com_Error(ERR_DROP, "Could not find mapdef baseattack");
        return;
    }

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

    Com_sprintf(mission->location, sizeof(mission->location), "%s", base->name);

    if (mission->ufo) {
        CP_MissionDisableTimeLimit(mission);
        UFO_SendToDestination(mission->ufo, mission->pos);
    } else {
        /* Go to next stage on next frame */
        mission->finalDate = ccs.date;
    }
}

int CP_BaseAttackMissionAvailableUFOs (const mission_t const *mission, ufoType_t *ufoTypes)
{
    int num = 0;
    ufoTypes[num++] = UFO_FIGHTER;
    if (UFO_ShouldAppearOnGeoscape(UFO_BOMBER))
        ufoTypes[num++] = UFO_BOMBER;

    return num;
}

void CP_BaseAttackMissionNextStage (mission_t *mission)
{
    switch (mission->stage) {
    case STAGE_NOT_ACTIVE:
        /* Create mission */
        CP_MissionBegin(mission);
        break;
    case STAGE_COME_FROM_ORBIT:
        /* Choose a base to attack and go to this base */
        CP_BaseAttackGoToBase(mission);
        break;
    case STAGE_MISSION_GOTO:
        /* just arrived on base location: attack it */
        CP_BaseAttackStartMission(mission);
        break;
    case STAGE_BASE_ATTACK:
        /* Leave earth */
        CP_BaseAttackMissionDestroyBase(mission);
        break;
    case STAGE_RETURN_TO_ORBIT:
        /* mission is over, remove mission */
        CP_BaseAttackMissionIsSuccess(mission);
        break;
    default:
        Com_Printf("CP_BaseAttackMissionNextStage: Unknown stage: %i, removing mission.\n", mission->stage);
        CP_MissionRemove(mission);
        break;
    }
}