cp_airfight.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_mapfightequip.h"
#include "cp_map.h"
#include "cp_ufo.h"
#include "cp_missions.h"
#include "save/save_airfight.h"

static qboolean AIRFIGHT_RemoveProjectile (aircraftProjectile_t *projectile)
{
    const ptrdiff_t num = (ptrdiff_t)(projectile - ccs.projectiles);
    REMOVE_ELEM_ADJUST_IDX(ccs.projectiles, num, ccs.numProjectiles);
    return qtrue;
}

static qboolean AIRFIGHT_AddProjectile (const base_t* attackingBase, const installation_t* attackingInstallation, aircraft_t *attacker, aircraft_t *target, aircraftSlot_t *weaponSlot)
{
    aircraftProjectile_t *projectile;

    if (ccs.numProjectiles >= MAX_PROJECTILESONGEOSCAPE) {
        Com_DPrintf(DEBUG_CLIENT, "Too many projectiles on map\n");
        return qfalse;
    }

    projectile = &ccs.projectiles[ccs.numProjectiles];

    if (!weaponSlot->ammo) {
        Com_Printf("AIRFIGHT_AddProjectile: Error - no ammo assigned\n");
        return qfalse;
    }

    assert(weaponSlot->item);

    projectile->aircraftItem = weaponSlot->ammo;
    if (attackingBase) {
        projectile->attackingAircraft = NULL;
        VectorSet(projectile->pos[0], attackingBase->pos[0], attackingBase->pos[1], 0);
        VectorSet(projectile->attackerPos, attackingBase->pos[0], attackingBase->pos[1], 0);
    } else if (attackingInstallation) {
        projectile->attackingAircraft = NULL;
        VectorSet(projectile->pos[0], attackingInstallation->pos[0], attackingInstallation->pos[1], 0);
        VectorSet(projectile->attackerPos, attackingInstallation->pos[0], attackingInstallation->pos[1], 0);
    } else {
        assert(attacker);
        projectile->attackingAircraft = attacker;
        VectorSet(projectile->pos[0], attacker->pos[0], attacker->pos[1], 0);
        /* attacker may move, use attackingAircraft->pos */
        VectorSet(projectile->attackerPos, 0, 0, 0);
    }

    projectile->numProjectiles++;

    assert(target);
    projectile->aimedAircraft = target;
    VectorSet(projectile->idleTarget, 0, 0, 0);

    projectile->time = 0;
    projectile->angle = 0.0f;

    projectile->bullets = (weaponSlot->item->craftitem.bullets) ? qtrue : qfalse;
    projectile->beam = (weaponSlot->item->craftitem.beam) ? qtrue : qfalse;

    weaponSlot->ammoLeft--;
    if (weaponSlot->ammoLeft <= 0)
        AII_ReloadWeapon(weaponSlot);

    ccs.numProjectiles++;

    return qtrue;
}

#ifdef DEBUG

static void AIRFIGHT_ProjectileList_f (void)
{
    int i;

    for (i = 0; i < ccs.numProjectiles; i++) {
        Com_Printf("%i. (idx: %i)\n", i, ccs.projectiles[i].idx);
        Com_Printf("... type '%s'\n", ccs.projectiles[i].aircraftItem->id);
        if (ccs.projectiles[i].attackingAircraft)
            Com_Printf("... shooting aircraft '%s'\n", ccs.projectiles[i].attackingAircraft->id);
        else
            Com_Printf("... base is shooting, or shooting aircraft is destroyed\n");
        if (ccs.projectiles[i].aimedAircraft)
            Com_Printf("... aiming aircraft '%s'\n", ccs.projectiles[i].aimedAircraft->id);
        else
            Com_Printf("... aiming iddle target at (%.02f, %.02f)\n",
                ccs.projectiles[i].idleTarget[0], ccs.projectiles[i].idleTarget[1]);
    }
}
#endif

static void AIRFIGHT_MissTarget (aircraftProjectile_t *projectile, qboolean returnToBase)
{
    vec3_t newTarget;
    float distance;
    float offset;

    assert(projectile);

    if (projectile->aimedAircraft) {
        VectorCopy(projectile->aimedAircraft->pos, newTarget);
        projectile->aimedAircraft = NULL;
    } else {
        VectorCopy(projectile->idleTarget, newTarget);
    }

    /* get the distance between the projectile and target */
    distance = GetDistanceOnGlobe(projectile->pos[0], newTarget);

    /* Work out how much the projectile should miss the target by.  We dont want it too close
     * or too far from the original target.
     * * 1/3 distance between target and projectile * random (range -0.5 to 0.5)
     * * Then make sure the value is at least greater than 0.1 or less than -0.1 so that
     *   the projectile doesn't land too close to the target. */
    offset = (distance / 3) * (frand() - 0.5f);

    if (abs(offset) < 0.1f)
        offset = 0.1f;

    newTarget[0] = newTarget[0] + offset;
    newTarget[1] = newTarget[1] + offset;

    VectorCopy(newTarget, projectile->idleTarget);

    if (returnToBase && projectile->attackingAircraft) {
        if (projectile->attackingAircraft->homebase) {
            assert(!AIR_IsUFO(projectile->attackingAircraft));
            AIR_AircraftReturnToBase(projectile->attackingAircraft);
        }
    }
}

int AIRFIGHT_CheckWeapon (const aircraftSlot_t *slot, float distance)
{
    assert(slot);

    /* check if there is a functional weapon in this slot */
    if (!slot->item || slot->installationTime != 0)
        return AIRFIGHT_WEAPON_CAN_NEVER_SHOOT;

    /* check if there is still ammo in this weapon */
    if (!slot->ammo || (slot->ammoLeft <= 0))
        return AIRFIGHT_WEAPON_CAN_NEVER_SHOOT;

    /* check if the target is within range of this weapon */
    if (distance > slot->ammo->craftitem.stats[AIR_STATS_WRANGE])
        return AIRFIGHT_WEAPON_CAN_NOT_SHOOT_AT_THE_MOMENT;

    /* check if weapon is reloaded */
    if (slot->delayNextShot > 0)
        return AIRFIGHT_WEAPON_CAN_NOT_SHOOT_AT_THE_MOMENT;

    return AIRFIGHT_WEAPON_CAN_SHOOT;
}

int AIRFIGHT_ChooseWeapon (const aircraftSlot_t const *slot, int maxSlot, const vec3_t pos, const vec3_t targetPos)
{
    int slotIdx = AIRFIGHT_WEAPON_CAN_NEVER_SHOOT;
    int i, weaponStatus;
    float distance0 = 99999.9f;
    const float distance = GetDistanceOnGlobe(pos, targetPos);

    /* We choose the usable weapon with the smallest range */
    for (i = 0; i < maxSlot; i++) {
        assert(slot);
        weaponStatus = AIRFIGHT_CheckWeapon(slot + i, distance);

        /* set slotIdx to AIRFIGHT_WEAPON_CAN_NOT_SHOOT_AT_THE_MOMENT if needed */
        /* this will only happen if weapon_state is AIRFIGHT_WEAPON_CAN_NOT_SHOOT_AT_THE_MOMENT
         * and no weapon has been found that can shoot. */
        if (weaponStatus > slotIdx)
            slotIdx = AIRFIGHT_WEAPON_CAN_NOT_SHOOT_AT_THE_MOMENT;

        /* select this weapon if this is the one with the shortest range */
        if (weaponStatus >= AIRFIGHT_WEAPON_CAN_SHOOT && distance < distance0) {
            slotIdx = i;
            distance0 = distance;
        }
    }
    return slotIdx;
}

static float AIRFIGHT_ProbabilityToHit (const aircraft_t *shooter, const aircraft_t *target, const aircraftSlot_t *slot)
{
    float probability = 0.0f;

    if (!slot->item) {
        Com_Printf("AIRFIGHT_ProbabilityToHit: no weapon assigned to attacking aircraft\n");
        return probability;
    }

    if (!slot->ammo) {
        Com_Printf("AIRFIGHT_ProbabilityToHit: no ammo in weapon of attacking aircraft\n");
        return probability;
    }

    /* Take Base probability from the ammo of the attacking aircraft */
    probability = slot->ammo->craftitem.stats[AIR_STATS_ACCURACY];
    Com_DPrintf(DEBUG_CLIENT, "AIRFIGHT_ProbabilityToHit: Base probablity: %f\n", probability);

    /* Modify this probability by items of the attacking aircraft (stats is in percent) */
    if (shooter)
        probability *= shooter->stats[AIR_STATS_ACCURACY] / 100.0f;

    /* Modify this probability by items of the aimed aircraft (stats is in percent) */
    if (target)
        probability /= target->stats[AIR_STATS_ECM] / 100.0f;

    Com_DPrintf(DEBUG_CLIENT, "AIRFIGHT_ProbabilityToHit: Probability to hit: %f\n", probability);
    return probability;
}

void AIRFIGHT_ExecuteActions (aircraft_t* shooter, aircraft_t* target)
{
    int slotIdx;

    /* some asserts */
    assert(shooter);
    assert(target);

    /* Check if the attacking aircraft can shoot */
    slotIdx = AIRFIGHT_ChooseWeapon(shooter->weapons, shooter->maxWeapons, shooter->pos, target->pos);

    /* if weapon found that can shoot */
    if (slotIdx >= AIRFIGHT_WEAPON_CAN_SHOOT) {
        const objDef_t *ammo = shooter->weapons[slotIdx].ammo;

        /* shoot */
        if (AIRFIGHT_AddProjectile(NULL, NULL, shooter, target, &(shooter->weapons[slotIdx]))) {
            /* will we miss the target ? */
            const float probability = frand();
            shooter->weapons[slotIdx].delayNextShot = ammo->craftitem.weaponDelay;
            if (probability > AIRFIGHT_ProbabilityToHit(shooter, target, shooter->weapons + slotIdx))
                AIRFIGHT_MissTarget(&ccs.projectiles[ccs.numProjectiles - 1], qfalse);

            if (shooter->type != AIRCRAFT_UFO) {
                /* Maybe UFO is going to shoot back ? */
                UFO_CheckShootBack(target, shooter);
            } else {
                /* an undetected UFO within radar range and firing should become detected */
                if (!shooter->detected && RADAR_CheckRadarSensored(shooter->pos)) {
                    /* stop time and notify */
                    MSO_CheckAddNewMessage(NT_UFO_ATTACKING,_("Notice"), va(_("A UFO is shooting at %s"), target->name), qfalse, MSG_STANDARD, NULL);
                    RADAR_AddDetectedUFOToEveryRadar(shooter);
                    UFO_DetectNewUFO(shooter);
                }
            }
        }
    } else if (slotIdx == AIRFIGHT_WEAPON_CAN_NOT_SHOOT_AT_THE_MOMENT) {
        /* no ammo to fire atm (too far or reloading), pursue target */
        if (shooter->type == AIRCRAFT_UFO) {
            UFO_SendPursuingAircraft(shooter, target);
        } else
            AIR_SendAircraftPursuingUFO(shooter, target);
    } else {
        /* no ammo left, or no weapon, proceed with mission */
        if (shooter->type == AIRCRAFT_UFO) {
            shooter->aircraftTarget = NULL;     /* reset target */
            CP_UFOProceedMission(shooter);
        } else {
            MS_AddNewMessage(_("Notice"), _("Our aircraft has no more ammo left - returning to home base now."), qfalse, MSG_STANDARD, NULL);
            AIR_AircraftReturnToBase(shooter);
        }
    }
}

static void AIRFIGHT_RemoveProjectileAimingAircraft (const aircraft_t * aircraft)
{
    aircraftProjectile_t *projectile;
    int idx = 0;

    if (!aircraft)
        return;

    for (projectile = ccs.projectiles; idx < ccs.numProjectiles; projectile++, idx++) {
        if (projectile->aimedAircraft == aircraft)
            AIRFIGHT_MissTarget(projectile, qtrue);
    }
}

static void AIRFIGHT_UpdateProjectileForDestroyedAircraft (const aircraft_t * aircraft)
{
    aircraftProjectile_t *projectile;
    int idx;

    for (idx = 0, projectile = ccs.projectiles; idx < ccs.numProjectiles; projectile++, idx++) {
        const aircraft_t *attacker = projectile->attackingAircraft;

        if (attacker == aircraft)
            projectile->attackingAircraft = NULL;
    }
}

void AIRFIGHT_ActionsAfterAirfight (aircraft_t *shooter, aircraft_t* aircraft, qboolean phalanxWon)
{
    if (phalanxWon) {
        byte *color;

        assert(aircraft);

        /* change destination of other projectiles aiming aircraft */
        AIRFIGHT_RemoveProjectileAimingAircraft(aircraft);
        /* now update the projectile for the destroyed aircraft, too */
        AIRFIGHT_UpdateProjectileForDestroyedAircraft(aircraft);

        /* don't remove ufo from global array: the mission is not over yet
         * UFO are removed from game only at the end of the mission
         * (in case we need to know what item to collect e.g.) */

        /* get the color value of the map at the crash position */
        color = MAP_GetColor(aircraft->pos, MAPTYPE_TERRAIN);
        /* if this color value is not the value for water ...
         * and we hit the probability to spawn a crashsite mission */
        if (!MapIsWater(color)) {
            CP_SpawnCrashSiteMission(aircraft);
        } else {
            Com_DPrintf(DEBUG_CLIENT, "AIRFIGHT_ActionsAfterAirfight: zone: %s (%i:%i:%i)\n", MAP_GetTerrainType(color), color[0], color[1], color[2]);
            MS_AddNewMessage(_("Interception"), _("UFO interception successful -- UFO lost to sea."), qfalse, MSG_STANDARD, NULL);
            CP_MissionIsOverByUFO(aircraft);
        }
    } else {
        /* change destination of other projectiles aiming aircraft */
        AIRFIGHT_RemoveProjectileAimingAircraft(aircraft);

        /* and now update the projectile pointers (there still might be some in the air
         * of the current destroyed aircraft) - this is needed not send the aircraft
         * back to base as soon as the projectiles will hit their target */
        AIRFIGHT_UpdateProjectileForDestroyedAircraft(aircraft);

        /* notify UFOs that a phalanx aircraft has been destroyed */
        UFO_NotifyPhalanxAircraftRemoved(aircraft);

        if (!MapIsWater(MAP_GetColor(aircraft->pos, MAPTYPE_TERRAIN)))
            CP_SpawnRescueMission(aircraft, shooter);
        else {
            /* Destroy the aircraft and everything onboard - the aircraft pointer
             * is no longer valid after this point */
            AIR_DestroyAircraft(aircraft);
        }

        /* Make UFO proceed with its mission, if it has not been already destroyed */
        if (shooter)
            CP_UFOProceedMission(shooter);

        MS_AddNewMessage(_("Interception"), _("You've lost the battle"), qfalse, MSG_DEATH, NULL);
    }
}

static qboolean AIRFIGHT_ProjectileReachedTarget (const aircraftProjectile_t *projectile, float movement)
{
    float distance;

    if (!projectile->aimedAircraft)
        /* the target is idle, its position is in idleTarget*/
        distance = GetDistanceOnGlobe(projectile->idleTarget, projectile->pos[0]);
    else {
        /* the target is moving, pointer to the other aircraft is aimedAircraft */
        distance = GetDistanceOnGlobe(projectile->aimedAircraft->pos, projectile->pos[0]);
    }

    /* projectile reaches its target */
    if (distance < movement)
        return qtrue;

    assert(projectile->aircraftItem);

    /* check if the projectile went farther than it's range */
    distance = (float) projectile->time * projectile->aircraftItem->craftitem.weaponSpeed / (float)SECONDS_PER_HOUR;
    if (distance > projectile->aircraftItem->craftitem.stats[AIR_STATS_WRANGE])
        return qtrue;

    return qfalse;
}

static int AIRFIGHT_GetDamage (const objDef_t *od, const aircraft_t* target)
{
    int damage;

    assert(od);

    /* already destroyed - do nothing */
    if (target->damage <= 0)
        return 0;

    /* base damage is given by the ammo */
    damage = od->craftitem.weaponDamage;

    /* reduce damages with shield target */
    damage -= target->stats[AIR_STATS_SHIELD];

    return damage;
}

static void AIRFIGHT_ProjectileHits (aircraftProjectile_t *projectile)
{
    aircraft_t *target;
    int damage = 0;

    assert(projectile);
    target = projectile->aimedAircraft;
    assert(target);

    /* if the aircraft is not on geoscape anymore, do nothing (returned to base) */
    if (AIR_IsAircraftInBase(target))
        return;

    damage = AIRFIGHT_GetDamage(projectile->aircraftItem, target);

    /* apply resulting damages - but only if damage > 0 - because the target might
     * already be destroyed, and we don't want to execute the actions after airfight
     * for every projectile */
    if (damage > 0) {
        assert(target->damage > 0);
        target->damage -= damage;
        if (target->damage <= 0)
            /* Target is destroyed */
            AIRFIGHT_ActionsAfterAirfight(projectile->attackingAircraft, target, target->type == AIRCRAFT_UFO);
    }
}

static void AIRFIGHT_GetNextPointInPathFromVector (const float *movement, const vec2_t originalPoint, const vec3_t orthogonalVector, vec2_t finalPoint)
{
    vec3_t startPoint, finalVectorPoint;

    PolarToVec(originalPoint, startPoint);
    RotatePointAroundVector(finalVectorPoint, orthogonalVector, startPoint, *movement);
    VecToPolar(finalVectorPoint, finalPoint);
}

static void AIRFIGHT_GetNextPointInPath (const float *movement, const vec2_t originalPoint, const vec2_t targetPoint, float *angle, vec2_t finalPoint, vec3_t orthogonalVector)
{
    *angle = MAP_AngleOfPath(originalPoint, targetPoint, NULL, orthogonalVector);
    AIRFIGHT_GetNextPointInPathFromVector(movement, originalPoint, orthogonalVector, finalPoint);
}

void AIRFIGHT_CampaignRunProjectiles (int dt)
{
    int idx;

    /* ccs.numProjectiles is changed in AIRFIGHT_RemoveProjectile */
    for (idx = ccs.numProjectiles - 1; idx >= 0; idx--) {
        aircraftProjectile_t *projectile = &ccs.projectiles[idx];
        const float movement = (float) dt * projectile->aircraftItem->craftitem.weaponSpeed / (float)SECONDS_PER_HOUR;
        projectile->time += dt;
        projectile->hasMoved = qtrue;
        projectile->numInterpolationPoints = 0;

        /* Check if the projectile reached its destination (aircraft or idle point) */
        if (AIRFIGHT_ProjectileReachedTarget(projectile, movement)) {
            /* check if it got the ennemy */
            if (projectile->aimedAircraft)
                AIRFIGHT_ProjectileHits(projectile);

            /* remove the missile from ccs.projectiles[] */
            AIRFIGHT_RemoveProjectile(projectile);
        } else {
            float angle;
            vec3_t ortogonalVector, finalPoint, projectedPoint;

            /* missile is moving towards its target */
            if (projectile->aimedAircraft) {
                AIRFIGHT_GetNextPointInPath(&movement, projectile->pos[0], projectile->aimedAircraft->pos, &angle, finalPoint, ortogonalVector);
                AIRFIGHT_GetNextPointInPath(&movement, finalPoint, projectile->aimedAircraft->pos, &angle, projectedPoint, ortogonalVector);
            } else {
                AIRFIGHT_GetNextPointInPath(&movement, projectile->pos[0], projectile->idleTarget, &angle, finalPoint, ortogonalVector);
                AIRFIGHT_GetNextPointInPath(&movement, finalPoint, projectile->idleTarget, &angle, projectedPoint, ortogonalVector);
            }

            /* update angle of the projectile */
            projectile->angle = angle;
            VectorCopy(finalPoint, projectile->pos[0]);
            VectorCopy(projectedPoint, projectile->projectedPos[0]);
        }
    }
}

static void AIRFIGHT_BaseShoot (const base_t *base, baseWeapon_t *weapons, int maxWeapons)
{
    int i, test;
    float distance;

    for (i = 0; i < maxWeapons; i++) {
        aircraft_t *target = weapons[i].target;
        aircraftSlot_t *slot = &(weapons[i].slot);
        /* if no target, can't shoot */
        if (!target)
            continue;

        /* If the weapon is not ready in base, can't shoot. */
        if (slot->installationTime > 0)
            continue;

        /* if weapon is reloading, can't shoot */
        if (slot->delayNextShot > 0)
            continue;

        /* check that the ufo is still visible */
        if (!UFO_IsUFOSeenOnGeoscape(target)) {
            weapons[i].target = NULL;
            continue;
        }

        /* Check if we can still fire on this target. */
        distance = GetDistanceOnGlobe(base->pos, target->pos);
        test = AIRFIGHT_CheckWeapon(slot, distance);
        /* weapon unable to shoot, reset target */
        if (test == AIRFIGHT_WEAPON_CAN_NEVER_SHOOT) {
            weapons[i].target = NULL;
            continue;
        }
        /* we can't shoot with this weapon atm, wait to see if UFO comes closer */
        else if (test == AIRFIGHT_WEAPON_CAN_NOT_SHOOT_AT_THE_MOMENT)
            continue;
        /* target is too far, wait to see if UFO comes closer */
        else if (distance > slot->ammo->craftitem.stats[AIR_STATS_WRANGE])
            continue;

        /* shoot */
        if (AIRFIGHT_AddProjectile(base, NULL, NULL, target, slot)) {
            slot->delayNextShot = slot->ammo->craftitem.weaponDelay;
            /* will we miss the target ? */
            if (frand() > AIRFIGHT_ProbabilityToHit(NULL, target, slot))
                AIRFIGHT_MissTarget(&ccs.projectiles[ccs.numProjectiles - 1], qfalse);
        }
    }
}

static void AIRFIGHT_InstallationShoot (const installation_t *installation, baseWeapon_t *weapons, int maxWeapons)
{
    int i, test;
    float distance;

    for (i = 0; i < maxWeapons; i++) {
        aircraft_t *target = weapons[i].target;
        aircraftSlot_t *slot = &(weapons[i].slot);
        /* if no target, can't shoot */
        if (!target)
            continue;

        /* If the weapon is not ready in base, can't shoot. */
        if (slot->installationTime > 0)
            continue;

        /* if weapon is reloading, can't shoot */
        if (slot->delayNextShot > 0)
            continue;

        /* check that the ufo is still visible */
        if (!UFO_IsUFOSeenOnGeoscape(target)) {
            weapons[i].target = NULL;
            continue;
        }

        /* Check if we can still fire on this target. */
        distance = GetDistanceOnGlobe(installation->pos, target->pos);
        test = AIRFIGHT_CheckWeapon(slot, distance);
        /* weapon unable to shoot, reset target */
        if (test == AIRFIGHT_WEAPON_CAN_NEVER_SHOOT) {
            weapons[i].target = NULL;
            continue;
        }
        /* we can't shoot with this weapon atm, wait to see if UFO comes closer */
        else if (test == AIRFIGHT_WEAPON_CAN_NOT_SHOOT_AT_THE_MOMENT)
            continue;
        /* target is too far, wait to see if UFO comes closer */
        else if (distance > slot->ammo->craftitem.stats[AIR_STATS_WRANGE])
            continue;

        /* shoot */
        if (AIRFIGHT_AddProjectile(NULL, installation, NULL, target, slot)) {
            slot->delayNextShot = slot->ammo->craftitem.weaponDelay;
            /* will we miss the target ? */
            if (frand() > AIRFIGHT_ProbabilityToHit(NULL, target, slot))
                AIRFIGHT_MissTarget(&ccs.projectiles[ccs.numProjectiles - 1], qfalse);
        }
    }
}

void AIRFIGHT_CampaignRunBaseDefence (int dt)
{
    int baseIdx;
    int installationIdx;

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

        if (base->baseStatus == BASE_UNDER_ATTACK)
            continue;

        for (idx = 0; idx < base->numBatteries; idx++) {
            baseWeapon_t *battery = &base->batteries[idx];
            aircraftSlot_t *slot = &battery->slot;
            if (slot->delayNextShot > 0)
                slot->delayNextShot -= dt;
            if (slot->ammoLeft <= 0)
                AII_ReloadWeapon(slot);
        }

        for (idx = 0; idx < base->numLasers; idx++) {
            baseWeapon_t *battery = &base->lasers[idx];
            aircraftSlot_t *slot = &battery->slot;
            if (slot->delayNextShot > 0)
                slot->delayNextShot -= dt;
            if (slot->ammoLeft <= 0)
                AII_ReloadWeapon(slot);
        }

        if (AII_BaseCanShoot(base)) {
            if (B_GetBuildingStatus(base, B_DEFENCE_MISSILE))
                AIRFIGHT_BaseShoot(base, base->batteries, base->numBatteries);
            if (B_GetBuildingStatus(base, B_DEFENCE_LASER))
                AIRFIGHT_BaseShoot(base, base->lasers, base->numLasers);
        }
    }

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

        if (installation->installationTemplate->maxBatteries <= 0)
            continue;

        for (idx = 0; idx < installation->installationTemplate->maxBatteries; idx++) {
            baseWeapon_t *battery = &installation->batteries[idx];
            aircraftSlot_t *slot = &battery->slot;
            if (slot->delayNextShot > 0)
                slot->delayNextShot -= dt;
            if (slot->ammoLeft <= 0)
                AII_ReloadWeapon(slot);
        }

        if (AII_InstallationCanShoot(installation)) {
            AIRFIGHT_InstallationShoot(installation, installation->batteries, installation->installationTemplate->maxBatteries);
        }
    }
}

qboolean AIRFIGHT_SaveXML (mxml_node_t *parent)
{
    int i;

    for (i = 0; i < ccs.numProjectiles; i++) {
        int j;
        aircraftProjectile_t *projectile = &ccs.projectiles[i];
        mxml_node_t *node = mxml_AddNode(parent, SAVE_AIRFIGHT_PROJECTILE);

        mxml_AddString(node, SAVE_AIRFIGHT_ITEMID, projectile->aircraftItem->id);
        for (j = 0; j < projectile->numProjectiles; j++)
            mxml_AddPos2(node, SAVE_AIRFIGHT_POS, projectile->pos[j]);
        mxml_AddPos3(node, SAVE_AIRFIGHT_IDLETARGET, projectile->idleTarget);

        mxml_AddInt(node, SAVE_AIRFIGHT_TIME, projectile->time);
        mxml_AddFloat(node, SAVE_AIRFIGHT_ANGLE, projectile->angle);
        mxml_AddBoolValue(node, SAVE_AIRFIGHT_BULLET, projectile->bullets);
        mxml_AddBoolValue(node, SAVE_AIRFIGHT_BEAM, projectile->beam);

        if (projectile->attackingAircraft) {
            mxml_node_t *attacking =  mxml_AddNode(node, SAVE_AIRFIGHT_ATTACKINGAIRCRAFT);

            mxml_AddBoolValue(attacking, SAVE_AIRFIGHT_ISUFO, projectile->attackingAircraft->type == AIRCRAFT_UFO);
            if (projectile->attackingAircraft->type == AIRCRAFT_UFO)
                mxml_AddInt(attacking, SAVE_AIRFIGHT_AIRCRAFTIDX, projectile->attackingAircraft - ccs.ufos);
            else
                mxml_AddInt(attacking, SAVE_AIRFIGHT_AIRCRAFTIDX, projectile->attackingAircraft->idx);
        }

        if (projectile->aimedAircraft) {
            mxml_node_t *aimed =  mxml_AddNode(node, SAVE_AIRFIGHT_AIMEDAIRCRAFT);

            mxml_AddBoolValue(aimed, SAVE_AIRFIGHT_ISUFO, projectile->aimedAircraft->type == AIRCRAFT_UFO);
            if (projectile->aimedAircraft->type == AIRCRAFT_UFO)
                mxml_AddInt(aimed, SAVE_AIRFIGHT_AIRCRAFTIDX, projectile->aimedAircraft - ccs.ufos);
            else
                mxml_AddInt(aimed, SAVE_AIRFIGHT_AIRCRAFTIDX, projectile->aimedAircraft->idx);
        }
    }

    return qtrue;
}

qboolean AIRFIGHT_LoadXML (mxml_node_t *parent)
{
    int i;
    mxml_node_t *node;

    for (i = 0, node = mxml_GetNode(parent, SAVE_AIRFIGHT_PROJECTILE); i < MAX_PROJECTILESONGEOSCAPE && node;
            node = mxml_GetNextNode(node, parent, SAVE_AIRFIGHT_PROJECTILE), i++) {
        technology_t *tech = RS_GetTechByProvided(mxml_GetString(node, SAVE_AIRFIGHT_ITEMID));
        int j;
        mxml_node_t *positions;
        mxml_node_t *attackingAircraft;
        mxml_node_t *aimedAircraft;
        aircraftProjectile_t *projectile = &ccs.projectiles[i];

        if (!tech) {
            Com_Printf("AIR_Load: Could not get technology of projectile %i\n", i);
            return qfalse;
        }

        projectile->aircraftItem = INVSH_GetItemByID(tech->provides);

        for (j = 0, positions = mxml_GetPos2(node, SAVE_AIRFIGHT_POS, projectile->pos[0]); j < MAX_MULTIPLE_PROJECTILES && positions;
             j++, positions = mxml_GetNextPos2(positions, node, SAVE_AIRFIGHT_POS, projectile->pos[j]))
            ;
        projectile->numProjectiles = j;
        mxml_GetPos3(node, SAVE_AIRFIGHT_IDLETARGET, projectile->idleTarget);

        projectile->time = mxml_GetInt(node, SAVE_AIRFIGHT_TIME, 0);
        projectile->angle = mxml_GetFloat(node, SAVE_AIRFIGHT_ANGLE, 0.0);
        projectile->bullets = mxml_GetBool(node, SAVE_AIRFIGHT_BULLET, qfalse);
        projectile->beam = mxml_GetBool(node, SAVE_AIRFIGHT_BEAM, qfalse);

        if ((attackingAircraft = mxml_GetNode(node, SAVE_AIRFIGHT_ATTACKINGAIRCRAFT))) {
            if (mxml_GetBool(attackingAircraft, SAVE_AIRFIGHT_ISUFO, qfalse))
                projectile->attackingAircraft = ccs.ufos + mxml_GetInt(attackingAircraft, SAVE_AIRFIGHT_AIRCRAFTIDX, 0);
            else
                projectile->attackingAircraft = AIR_AircraftGetFromIDX(mxml_GetInt(attackingAircraft, SAVE_AIRFIGHT_AIRCRAFTIDX, AIRCRAFT_INVALID));
        } else {
            projectile->attackingAircraft = NULL;
        }
        if ((aimedAircraft = mxml_GetNode(node, SAVE_AIRFIGHT_AIMEDAIRCRAFT))) {
            if (mxml_GetBool(aimedAircraft, SAVE_AIRFIGHT_ISUFO, qfalse))
                projectile->aimedAircraft = ccs.ufos + mxml_GetInt(aimedAircraft, SAVE_AIRFIGHT_AIRCRAFTIDX, 0);
            else
                projectile->aimedAircraft = AIR_AircraftGetFromIDX(mxml_GetInt(aimedAircraft, SAVE_AIRFIGHT_AIRCRAFTIDX, AIRCRAFT_INVALID));
        } else {
            projectile->aimedAircraft = NULL;
        }
    }
    ccs.numProjectiles = i;

    return qtrue;
}

void AIRFIGHT_InitStartup (void)
{
#ifdef DEBUG
    Cmd_AddCommand("debug_listprojectile", AIRFIGHT_ProjectileList_f, "Print Projectiles information to game console");
#endif
}