cl_hud_callbacks.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 "../client.h"
#include "cl_hud_callbacks.h"
#include "cl_hud.h"
#include "cl_actor.h"

invList_t* HUD_GetLeftHandWeapon (le_t *actor, containerIndex_t *container)
{
    invList_t *invList = LEFT(actor);

    if (!invList) {
        invList = RIGHT(actor);
        if (invList == NULL || !invList->item.t->holdTwoHanded)
            invList = NULL;
        else if (container != NULL)
            *container = csi.idRight;
    }

    return invList;
}

const fireDef_t *HUD_GetFireDefinitionForHand (const le_t * actor, const actorHands_t hand)
{
    const invList_t *invlistWeapon;

    if (!actor)
        return NULL;

    invlistWeapon = ACTOR_GET_INV(actor, hand);
    if (!invlistWeapon || !invlistWeapon->item.t)
        return NULL;

    return FIRESH_FiredefForWeapon(&invlistWeapon->item);
}

static qboolean HUD_CheckShooting (const le_t* le, invList_t *weapon)
{
    if (!le)
        return qfalse;

    /* No item in hand. */
    if (!weapon || !weapon->item.t) {
        HUD_DisplayMessage(_("No item in hand.\n"));
        return qfalse;
    }

    /* Cannot shoot because of lack of ammo. */
    if (weapon->item.a <= 0 && weapon->item.t->reload) {
        HUD_DisplayMessage(_("Can't perform action:\nout of ammo.\n"));
        return qfalse;
    }
    /* Cannot shoot because weapon is fireTwoHanded, yet both hands handle items. */
    if (weapon->item.t->fireTwoHanded && LEFT(le)) {
        HUD_DisplayMessage(_("This weapon cannot be fired\none handed.\n"));
        return qfalse;
    }

    return qtrue;
}

static void HUD_FireWeapon_f (void)
{
    actorHands_t hand;
    fireDefIndex_t firemode;
    const objDef_t *ammo;
    const fireDef_t *fd;

    if (Cmd_Argc() < 3) { /* no argument given */
        Com_Printf("Usage: %s <l|r> <firemode number>\n", Cmd_Argv(0));
        return;
    }

    if (!selActor)
        return;

    hand = ACTOR_GET_HAND_INDEX(Cmd_Argv(1)[0]);
    firemode = atoi(Cmd_Argv(2));
    if (firemode >= MAX_FIREDEFS_PER_WEAPON || firemode < 0)
        return;

    fd = HUD_GetFireDefinitionForHand(selActor, hand);
    if (fd == NULL)
        return;

    ammo = fd->obj;

    /* Let's check if shooting is possible. */
    if (!HUD_CheckShooting(selActor, ACTOR_GET_INV(selActor, hand)))
        return;

    if (ammo->fd[fd->weapFdsIdx][firemode].time <= CL_ActorUsableTUs(selActor)) {
        /* Actually start aiming. This is done by changing the current mode of display. */
        if (hand == ACTOR_HAND_RIGHT)
            CL_ActorSetMode(selActor, M_FIRE_R);
        else
            CL_ActorSetMode(selActor, M_FIRE_L);
        /* Store firemode. */
        selActor->currentSelectedFiremode = firemode;
        HUD_HideFiremodes();
    } else {
        /* Cannot shoot because of not enough TUs - every other
         * case should be checked previously in this function. */
        HUD_DisplayMessage(_("Can't perform action:\nnot enough TUs.\n"));
    }
}

static void HUD_ToggleCrouchReservation_f (void)
{
    if (!CL_ActorCheckAction(selActor))
        return;

    if (CL_ActorReservedTUs(selActor, RES_CROUCH) >= TU_CROUCH) {
        /* Reset reserved TUs to 0 */
        CL_ActorReserveTUs(selActor, RES_CROUCH, 0);
    } else {
        /* Reserve the exact amount for crouching/standing up (if we have enough to do so). */
        CL_ActorReserveTUs(selActor, RES_CROUCH, TU_CROUCH);
    }
}

static void HUD_ToggleReaction_f (void)
{
    int state = 0;

    if (!CL_ActorCheckAction(selActor))
        return;

    if (!(selActor->state & STATE_REACTION))
        state = STATE_REACTION_ONCE;
    else if (selActor->state & STATE_REACTION_ONCE)
        state = STATE_REACTION_MANY;
    else if (selActor->state & STATE_REACTION_MANY)
        state = ~STATE_REACTION;

    /* Send request to update actor's reaction state to the server. */
    MSG_Write_PA(PA_STATE, selActor->entnum, state);
}

int HUD_CalcReloadTime (const le_t *le, const objDef_t *weapon, containerIndex_t toContainer)
{
    containerIndex_t container;
    invList_t *ic;

    if (toContainer == NONE)
        return -1;

    assert(le);
    assert(weapon);

    container = CL_ActorGetContainerForReload(&ic, &le->i, weapon);
    if (container == NONE)
        return -1;

    /* total TU cost is the sum of 3 numbers:
     * TU for weapon reload + TU to get ammo out + TU to put ammo in hands */
    return TU_GET_RELOAD(container, toContainer, weapon);
}

static qboolean HUD_CheckReload (const le_t* le, const invList_t *weapon, containerIndex_t container)
{
    int tus;

    if (!le)
        return qfalse;

    /* No item in hand. */
    if (!weapon || !weapon->item.t) {
        HUD_DisplayMessage(_("No item in hand.\n"));
        return qfalse;
    }

    /* Cannot reload because this item is not reloadable. */
    if (!weapon->item.t->reload) {
        HUD_DisplayMessage(_("Can't perform action:\nthis item is not reloadable.\n"));
        return qfalse;
    }

    tus = HUD_CalcReloadTime(le, weapon->item.t, container);
    /* Cannot reload because of no ammo in inventory. */
    if (tus == -1) {
        HUD_DisplayMessage(_("Can't perform action:\nammo not available.\n"));
        return qfalse;
    }
    /* Cannot reload because of not enough TUs. */
    if (le->TU < tus) {
        HUD_DisplayMessage(_("Can't perform action:\nnot enough TUs.\n"));
        return qfalse;
    }

    return qtrue;
}

static void HUD_ReloadLeft_f (void)
{
    containerIndex_t container = csi.idLeft;
    if (!HUD_CheckReload(selActor, HUD_GetLeftHandWeapon(selActor, &container), container))
        return;
    CL_ActorReload(selActor, container);
}

static void HUD_ReloadRight_f (void)
{
    if (!selActor || !HUD_CheckReload(selActor, RIGHT(selActor), csi.idRight))
        return;
    CL_ActorReload(selActor, csi.idRight);
}

void HUD_InitCallbacks (void)
{
    Cmd_AddCommand("hud_reloadleft", HUD_ReloadLeft_f, _("Reload the weapon in the soldiers left hand"));
    Cmd_AddCommand("hud_reloadright", HUD_ReloadRight_f, _("Reload the weapon in the soldiers right hand"));
    Cmd_AddCommand("hud_togglecrouchreserve", HUD_ToggleCrouchReservation_f, _("Toggle reservation for crouching."));
    Cmd_AddCommand("hud_togglereaction", HUD_ToggleReaction_f, _("Toggle reaction fire"));
    Cmd_AddCommand("hud_fireweapon", HUD_FireWeapon_f, "Start aiming the weapon.");
}