p_pspr.c

The source code of Doom legacy for windows

        psp->sy = WEAPONBOTTOM;

        // don't bring weapon back up
        return;
    }

    // The old weapon has been lowered off the screen,
    // so change the weapon and start raising it
    if (!player->health)
    {
        // Player is dead, so keep the weapon off screen.
        P_SetPsprite (player,  ps_weapon, S_NULL);
        return;
    }

    player->readyweapon = player->pendingweapon;

    P_BringUpWeapon (player);
}


//
// A_Raise
//
void A_Raise( player_t*     player,
              pspdef_t*     psp )
{
    psp->sy -= RAISESPEED;

    if (psp->sy > WEAPONTOP )
        return;

    psp->sy = WEAPONTOP;

    // The weapon has been raised all the way,
    //  so change to the ready state.
    P_SetPsprite (player, ps_weapon, 
                  player->weaponinfo[player->readyweapon].readystate);
}



//
// A_GunFlash
//
void
A_GunFlash
( player_t*     player,
  pspdef_t*     psp )
{
    P_SetMobjState (player->mo, S_PLAY_ATK2);
    P_SetPsprite (player,ps_flash,
                  player->weaponinfo[player->readyweapon].flashstate);
}



//
// WEAPON ATTACKS
//


//
// A_Punch
//
void
A_Punch
( player_t*     player,
  pspdef_t*     psp )
{
    angle_t     angle;
    int         damage;
    int         slope;

    damage = (P_Random ()%10+1)<<1;

    if (player->powers[pw_strength])
        damage *= 10;

    angle = player->mo->angle;
    angle += (P_Random()<<18); // WARNING: don't put this in one line 
    angle -= (P_Random()<<18); // else this expretion is ambiguous (evaluation order not diffined)

    slope = P_AimLineAttack (player->mo, angle, MELEERANGE);
    P_LineAttack (player->mo, angle, MELEERANGE, slope, damage);

    // turn to face target
    if (linetarget)
    {
#ifdef HW3SOUND
        S_StartAttackSound(player->mo, sfx_punch);
#else
        S_StartSound (player->mo, sfx_punch);
#endif
        player->mo->angle = R_PointToAngle2 (player->mo->x,
                                             player->mo->y,
                                             linetarget->x,
                                             linetarget->y);
    }
}


//
// A_Saw
//
void
A_Saw
( player_t*     player,
  pspdef_t*     psp )
{
    angle_t     angle;
    int         damage;
    int         slope;

    damage = 2*(P_Random ()%10+1);
    angle = player->mo->angle;
    angle += (P_Random()<<18); // WARNING: don't put this in one line 
    angle -= (P_Random()<<18); // else this expretion is ambiguous (evaluation order not diffined)

    // use meleerange + 1 se the puff doesn't skip the flash
    slope = P_AimLineAttack (player->mo, angle, MELEERANGE+1);
    P_LineAttack (player->mo, angle, MELEERANGE+1, slope, damage);

    if (!linetarget)
    {
#ifdef HW3SOUND
        S_StartAttackSound(player->mo, sfx_sawful);
#else
        S_StartSound (player->mo, sfx_sawful);
#endif
        return;
    }
#ifdef HW3SOUND
    S_StartAttackSound(player->mo, sfx_sawhit);
#else
    S_StartSound (player->mo, sfx_sawhit);
#endif

    // turn to face target
    angle = R_PointToAngle2 (player->mo->x, player->mo->y,
                             linetarget->x, linetarget->y);
    if (angle - player->mo->angle > ANG180)
    {
        if (angle - player->mo->angle < -ANG90/20)
            player->mo->angle = angle + ANG90/21;
        else
            player->mo->angle -= ANG90/20;
    }
    else
    {
        if (angle - player->mo->angle > ANG90/20)
            player->mo->angle = angle - ANG90/21;
        else
            player->mo->angle += ANG90/20;
    }
    player->mo->flags |= MF_JUSTATTACKED;
}



//
// A_FireMissile : rocket launcher fires a rocket
//
void A_FireMissile ( player_t*     player,
                     pspdef_t*     psp )
{
    player->ammo[player->weaponinfo[player->readyweapon].ammo] -= player->weaponinfo[player->readyweapon].ammopershoot;
    //added:16-02-98: added player arg3
    P_SpawnPlayerMissile (player->mo, MT_ROCKET);
}


//
// A_FireBFG
//
void A_FireBFG ( player_t*     player,
                 pspdef_t*     psp )
{
    player->ammo[player->weaponinfo[player->readyweapon].ammo] -= player->weaponinfo[player->readyweapon].ammopershoot;
    //added:16-02-98:added player arg3
    P_SpawnPlayerMissile (player->mo, MT_BFG);
}



//
// A_FirePlasma
//
void A_FirePlasma ( player_t*     player,
                    pspdef_t*     psp )
{
    player->ammo[player->weaponinfo[player->readyweapon].ammo] -= player->weaponinfo[player->readyweapon].ammopershoot;

    P_SetPsprite (player,
                  ps_flash,
                  player->weaponinfo[player->readyweapon].flashstate+(P_Random ()&1) );

    //added:16-02-98: added player arg3
    P_SpawnPlayerMissile (player->mo, MT_PLASMA);
}



//
// P_BulletSlope
// Sets a slope so a near miss is at aproximately
// the height of the intended target
//
fixed_t         bulletslope;

//added:16-02-98: Fab comments: autoaim for the bullet-type weapons
void P_BulletSlope (mobj_t* mo)
{
    angle_t     an;

    //added:18-02-98: if AUTOAIM, try to aim at something
    if(!mo->player->autoaim_toggle || !cv_allowautoaim.value || demoversion<=111)
        goto notagetfound;

    // see which target is to be aimed at
    an = mo->angle;
    bulletslope = P_AimLineAttack (mo, an, 16*64*FRACUNIT);

    if (!linetarget)
    {
        an += 1<<26;
        bulletslope = P_AimLineAttack (mo, an, 16*64*FRACUNIT);
        if (!linetarget)
        {
            an -= 2<<26;
            bulletslope = P_AimLineAttack (mo, an, 16*64*FRACUNIT);
        }
        if(!linetarget)
        {
notagetfound:
            if(demoversion>=128)
                bulletslope = AIMINGTOSLOPE(mo->player->aiming);
            else
                bulletslope = (mo->player->aiming<<FRACBITS)/160;
        }
    }
}


//
// P_GunShot
//
//added:16-02-98: used only for player (pistol,shotgun,chaingun)
//                supershotgun use p_lineattack directely
void P_GunShot ( mobj_t*       mo,
                 boolean       accurate )
{
    angle_t     angle;
    int         damage;

    damage = 5*(P_Random ()%3+1);
    angle = mo->angle;

    if (!accurate)
    {
        angle += (P_Random()<<18); // WARNING: don't put this in one line 
        angle -= (P_Random()<<18); // else this expretion is ambiguous (evaluation order not diffined)
    }

    P_LineAttack (mo, angle, MISSILERANGE, bulletslope, damage);
}


//
// A_FirePistol
//
void A_FirePistol ( player_t*     player,
                    pspdef_t*     psp )
{
#ifdef HW3SOUND
    S_StartAttackSound(player->mo, sfx_pistol);
#else
    S_StartSound (player->mo, sfx_pistol);
#endif

    P_SetMobjState (player->mo, S_PLAY_ATK2);
    player->ammo[player->weaponinfo[player->readyweapon].ammo]--;

    P_SetPsprite (player,
                  ps_flash,
                  player->weaponinfo[player->readyweapon].flashstate);

    P_BulletSlope (player->mo);
    P_GunShot (player->mo, !player->refire);
}


//
// A_FireShotgun
//
void A_FireShotgun ( player_t*     player,
                     pspdef_t*     psp )
{
    int         i;

#ifdef HW3SOUND
    S_StartAttackSound(player->mo, sfx_shotgn);
#else
    S_StartSound (player->mo, sfx_shotgn);
#endif
    P_SetMobjState (player->mo, S_PLAY_ATK2);

    player->ammo[player->weaponinfo[player->readyweapon].ammo]--;
    P_SetPsprite (player,
                  ps_flash,
                  player->weaponinfo[player->readyweapon].flashstate);

    P_BulletSlope (player->mo);
    for (i=0 ; i<7 ; i++)
        P_GunShot (player->mo, false);
}



//
// A_FireShotgun2 (SuperShotgun)
//
void A_FireShotgun2 ( player_t*     player,
                      pspdef_t*     psp )
{
    int         i;
    angle_t     angle;
    int         damage;

#ifdef HW3SOUND
    S_StartAttackSound(player->mo, sfx_dshtgn);
#else
    S_StartSound (player->mo, sfx_dshtgn);
#endif
    P_SetMobjState (player->mo, S_PLAY_ATK2);

    player->ammo[player->weaponinfo[player->readyweapon].ammo]-=2;

    P_SetPsprite (player,
                  ps_flash,
                  player->weaponinfo[player->readyweapon].flashstate);

    P_BulletSlope (player->mo);

    for (i=0 ; i<20 ; i++)
    {
        int slope = P_Random();
        slope -= P_Random();
        slope <<=5;
        slope += bulletslope;
        damage = 5*(P_Random ()%3+1);
        angle = player->mo->angle;
        angle += (P_Random()<<19);
        angle -= (P_Random()<<19);
        P_LineAttack (player->mo,
                      angle,
                      MISSILERANGE,
                      slope, damage);
    }
}


//
// A_FireCGun
//
void A_FireCGun ( player_t*     player,
                  pspdef_t*     psp )
{
#ifdef HW3SOUND
    S_StartAttackSound(player->mo, sfx_pistol);
#else
    S_StartSound (player->mo, sfx_pistol);
#endif

    if (!player->ammo[player->weaponinfo[player->readyweapon].ammo])
        return;

    P_SetMobjState (player->mo, S_PLAY_ATK2);
    player->ammo[player->weaponinfo[player->readyweapon].ammo]--;

    P_SetPsprite (player,
                  ps_flash,
                  player->weaponinfo[player->readyweapon].flashstate
                  + psp->state
                  - &states[S_CHAIN1] );

    P_BulletSlope (player->mo);
    P_GunShot (player->mo, !player->refire);
}



//
// Flash light when fire gun
//
void A_Light0 (player_t *player, pspdef_t *psp)
{
    player->extralight = 0;
}

void A_Light1 (player_t *player, pspdef_t *psp)
{
    player->extralight = 1;
}

void A_Light2 (player_t *player, pspdef_t *psp)
{
    player->extralight = 2;
}


//
// A_BFGSpray
// Spawn a BFG explosion on every monster in view
//
void A_BFGSpray (mobj_t* mo)
{
    int                 i;
    int                 j;
    int                 damage;
    angle_t             an;

    // offset angles from its attack angle
    for (i=0 ; i<40 ; i++)
    {
        an = mo->angle - ANG90/2 + ANG90/40*i;

        // mo->target is the originator (player)
        //  of the missile
        P_AimLineAttack (mo->target, an, 16*64*FRACUNIT);

        if (!linetarget)
            continue;

        P_SpawnMobj (linetarget->x,
                     linetarget->y,
                     linetarget->z + (linetarget->height>>2),
                     MT_EXTRABFG);

        damage = 0;
        for (j=0;j<15;j++)
            damage += (P_Random()&7) + 1;

        P_DamageMobj (linetarget, mo->target,mo->target, damage);
    }
}


//
// A_BFGsound
//
void
A_BFGsound
( player_t*     player,
  pspdef_t*     psp )
{
#ifdef HW3SOUND
    S_StartAttackSound(player->mo, sfx_bfg);
#else
    S_StartSound (player->mo, sfx_bfg);
#endif
}



//
// P_SetupPsprites
// Called at start of level for each player.
//
void P_SetupPsprites (player_t* player)
{
    int i;

    // remove all psprites
    for (i=0 ; i<NUMPSPRITES ; i++)
        player->psprites[i].state = NULL;

    // spawn the gun
    player->pendingweapon = player->readyweapon;
    P_BringUpWeapon (player);
}




//
// P_MovePsprites
// Called every tic by player thinking routine.
//
void P_MovePsprites (player_t* player)
{
    int         i;
    pspdef_t*   psp;
    state_t*    state;

    psp = &player->psprites[0];
    for (i=0 ; i<NUMPSPRITES ; i++, psp++)
    {
        // a null state means not active
        if ( (state = psp->state) )
        {
            // drop tic count and possibly change state

            // a -1 tic count never changes
            if (psp->tics != -1)
            {
                psp->tics--;
                if (!psp->tics)
                    P_SetPsprite (player, i, psp->state->nextstate);
            }
        }
    }

    player->psprites[ps_flash].sx = player->psprites[ps_weapon].sx;
    player->psprites[ps_flash].sy = player->psprites[ps_weapon].sy;
}


#include "p_hpspr.c"