Update makefile

apps/zigdoom/src/puredoom/p_pspr.c

@@ -0,0 +1,778 @@
+// Emacs style mode select   -*- C++ -*- 
+//-----------------------------------------------------------------------------
+//
+// $Id:$
+//
+// Copyright (C) 1993-1996 by id Software, Inc.
+//
+// This source is available for distribution and/or modification
+// only under the terms of the DOOM Source Code License as
+// published by id Software. All rights reserved.
+//
+// The source is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
+// for more details.
+//
+// $Log:$
+//
+// DESCRIPTION:
+//        Weapon sprite animation, weapon objects.
+//        Action functions for weapons.
+//
+//-----------------------------------------------------------------------------
+
+
+#include "doom_config.h"
+
+#include "doomdef.h"
+#include "d_event.h"
+#include "m_random.h"
+#include "p_local.h"
+#include "s_sound.h"
+#include "doomstat.h" // State.
+#include "sounds.h" // Data.
+#include "p_pspr.h"
+
+
+#define LOWERSPEED (FRACUNIT*6)
+#define RAISESPEED (FRACUNIT*6)
+
+#define WEAPONBOTTOM (128*FRACUNIT)
+#define WEAPONTOP (32*FRACUNIT)
+
+// plasma cells for a bfg attack
+#define BFGCELLS 40     
+
+
+fixed_t swingx;
+fixed_t swingy;
+fixed_t bulletslope;
+
+
+//
+// P_SetPsprite
+//
+void P_SetPsprite(player_t* player, int position, statenum_t stnum)
+{
+    pspdef_t* psp;
+    state_t* state;
+
+    psp = &player->psprites[position];
+
+    do
+    {
+        if (!stnum)
+        {
+            // object removed itself
+            psp->state = 0;
+            break;
+        }
+
+        state = &states[stnum];
+        psp->state = state;
+        psp->tics = state->tics;        // could be 0
+
+        if (state->misc1)
+        {
+            // coordinate set
+            psp->sx = state->misc1 << FRACBITS;
+            psp->sy = state->misc2 << FRACBITS;
+        }
+
+        // Call action routine.
+        // Modified handling.
+        if (state->action.acp2)
+        {
+            state->action.acp2(player, psp);
+            if (!psp->state)
+                break;
+        }
+
+        stnum = psp->state->nextstate;
+
+    } while (!psp->tics);
+    // an initial state of 0 could cycle through
+}
+
+
+//
+// P_BringUpWeapon
+// Starts bringing the pending weapon up
+// from the bottom of the screen.
+// Uses player
+//
+void P_BringUpWeapon(player_t* player)
+{
+    statenum_t newstate;
+
+    if (player->pendingweapon == wp_nochange)
+        player->pendingweapon = player->readyweapon;
+
+    if (player->pendingweapon == wp_chainsaw)
+        S_StartSound(player->mo, sfx_sawup);
+
+    newstate = weaponinfo[player->pendingweapon].upstate;
+
+    player->pendingweapon = wp_nochange;
+    player->psprites[ps_weapon].sy = WEAPONBOTTOM;
+
+    P_SetPsprite(player, ps_weapon, newstate);
+}
+
+
+//
+// P_CheckAmmo
+// Returns true if there is enough ammo to shoot.
+// If not, selects the next weapon to use.
+//
+doom_boolean P_CheckAmmo(player_t* player)
+{
+    ammotype_t ammo;
+    int count;
+
+    ammo = weaponinfo[player->readyweapon].ammo;
+
+    // Minimal amount for one shot varies.
+    if (player->readyweapon == wp_bfg)
+        count = BFGCELLS;
+    else if (player->readyweapon == wp_supershotgun)
+        count = 2;        // Double barrel.
+    else
+        count = 1;        // Regular.
+
+    // Some do not need ammunition anyway.
+    // Return if current ammunition sufficient.
+    if (ammo == am_noammo || player->ammo[ammo] >= count)
+        return true;
+
+    // Out of ammo, pick a weapon to change to.
+    // Preferences are set here.
+    do
+    {
+        if (player->weaponowned[wp_plasma]
+            && player->ammo[am_cell]
+            && (gamemode != shareware))
+        {
+            player->pendingweapon = wp_plasma;
+        }
+        else if (player->weaponowned[wp_supershotgun]
+                 && player->ammo[am_shell] > 2
+                 && (gamemode == commercial))
+        {
+            player->pendingweapon = wp_supershotgun;
+        }
+        else if (player->weaponowned[wp_chaingun]
+                 && player->ammo[am_clip])
+        {
+            player->pendingweapon = wp_chaingun;
+        }
+        else if (player->weaponowned[wp_shotgun]
+                 && player->ammo[am_shell])
+        {
+            player->pendingweapon = wp_shotgun;
+        }
+        else if (player->ammo[am_clip])
+        {
+            player->pendingweapon = wp_pistol;
+        }
+        else if (player->weaponowned[wp_chainsaw])
+        {
+            player->pendingweapon = wp_chainsaw;
+        }
+        else if (player->weaponowned[wp_missile]
+                 && player->ammo[am_misl])
+        {
+            player->pendingweapon = wp_missile;
+        }
+        else if (player->weaponowned[wp_bfg]
+                 && player->ammo[am_cell] > 40
+                 && (gamemode != shareware))
+        {
+            player->pendingweapon = wp_bfg;
+        }
+        else
+        {
+            // If everything fails.
+            player->pendingweapon = wp_fist;
+        }
+
+    } while (player->pendingweapon == wp_nochange);
+
+    // Now set appropriate weapon overlay.
+    P_SetPsprite(player,
+                 ps_weapon,
+                 weaponinfo[player->readyweapon].downstate);
+
+    return false;
+}
+
+
+//
+// P_FireWeapon.
+//
+void P_FireWeapon(player_t* player)
+{
+    statenum_t newstate;
+
+    if (!P_CheckAmmo(player))
+        return;
+
+    P_SetMobjState(player->mo, S_PLAY_ATK1);
+    newstate = weaponinfo[player->readyweapon].atkstate;
+    P_SetPsprite(player, ps_weapon, newstate);
+    P_NoiseAlert(player->mo, player->mo);
+
+    // [pd] Stop gun bobbing when shooting
+    pspdef_t* psp;
+    psp = &player->psprites[ps_weapon];
+    psp->sx = FRACUNIT;
+    psp->sy = WEAPONTOP;
+}
+
+
+//
+// P_DropWeapon
+// Player died, so put the weapon away.
+//
+void P_DropWeapon(player_t* player)
+{
+    P_SetPsprite(player,
+                 ps_weapon,
+                 weaponinfo[player->readyweapon].downstate);
+}
+
+
+//
+// A_WeaponReady
+// The player can fire the weapon
+// or change to another weapon at this time.
+// Follows after getting weapon up,
+// or after previous attack/fire sequence.
+//
+void A_WeaponReady(player_t* player, pspdef_t* psp)
+{
+    statenum_t newstate;
+    int angle;
+
+    // get out of attack state
+    if (player->mo->state == &states[S_PLAY_ATK1]
+        || player->mo->state == &states[S_PLAY_ATK2])
+    {
+        P_SetMobjState(player->mo, S_PLAY);
+    }
+
+    if (player->readyweapon == wp_chainsaw
+        && psp->state == &states[S_SAW])
+    {
+        S_StartSound(player->mo, sfx_sawidl);
+    }
+
+    // check for change
+    //  if player is dead, put the weapon away
+    if (player->pendingweapon != wp_nochange || !player->health)
+    {
+        // change weapon
+        //  (pending weapon should allready be validated)
+        newstate = weaponinfo[player->readyweapon].downstate;
+        P_SetPsprite(player, ps_weapon, newstate);
+        return;
+    }
+
+    // check for fire
+    //  the missile launcher and bfg do not auto fire
+    if (player->cmd.buttons & BT_ATTACK)
+    {
+        if (!player->attackdown
+            || (player->readyweapon != wp_missile
+                && player->readyweapon != wp_bfg))
+        {
+            player->attackdown = true;
+            P_FireWeapon(player);
+            return;
+        }
+    }
+    else
+        player->attackdown = false;
+
+    // bob the weapon based on movement speed
+    angle = (128 * leveltime) & FINEMASK;
+    psp->sx = FRACUNIT + FixedMul(player->bob, finecosine[angle]);
+    angle &= FINEANGLES / 2 - 1;
+    psp->sy = WEAPONTOP + FixedMul(player->bob, finesine[angle]);
+}
+
+
+//
+// A_ReFire
+// The player can re-fire the weapon
+// without lowering it entirely.
+//
+void A_ReFire(player_t* player, pspdef_t* psp)
+{
+    // check for fire
+    //  (if a weaponchange is pending, let it go through instead)
+    if ((player->cmd.buttons & BT_ATTACK)
+        && player->pendingweapon == wp_nochange
+        && player->health)
+    {
+        player->refire++;
+        P_FireWeapon(player);
+    }
+    else
+    {
+        player->refire = 0;
+        P_CheckAmmo(player);
+    }
+}
+
+
+void A_CheckReload(player_t* player, pspdef_t* psp)
+{
+    P_CheckAmmo(player);
+}
+
+
+//
+// A_Lower
+// Lowers current weapon,
+//  and changes weapon at bottom.
+//
+void A_Lower(player_t* player, pspdef_t* psp)
+{
+    psp->sy += LOWERSPEED;
+
+    // Is already down.
+    if (psp->sy < WEAPONBOTTOM)
+        return;
+
+    // Player is dead.
+    if (player->playerstate == PST_DEAD)
+    {
+        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)
+{
+    statenum_t newstate;
+
+    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.
+    newstate = weaponinfo[player->readyweapon].readystate;
+
+    P_SetPsprite(player, ps_weapon, newstate);
+}
+
+
+//
+// A_GunFlash
+//
+void A_GunFlash(player_t* player, pspdef_t* psp)
+{
+    P_SetMobjState(player->mo, S_PLAY_ATK2);
+    P_SetPsprite(player, ps_flash, 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() - P_Random()) << 18;
+    slope = P_AimLineAttack(player->mo, angle, MELEERANGE);
+    P_LineAttack(player->mo, angle, MELEERANGE, slope, damage);
+
+    // turn to face target
+    if (linetarget)
+    {
+        S_StartSound(player->mo, sfx_punch);
+        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() - P_Random()) << 18;
+
+    // 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)
+    {
+        S_StartSound(player->mo, sfx_sawful);
+        return;
+    }
+    S_StartSound(player->mo, sfx_sawhit);
+
+    // 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
+//
+void A_FireMissile(player_t* player, pspdef_t* psp)
+{
+    player->ammo[weaponinfo[player->readyweapon].ammo]--;
+    P_SpawnPlayerMissile(player->mo, MT_ROCKET);
+}
+
+
+//
+// A_FireBFG
+//
+void A_FireBFG(player_t* player, pspdef_t* psp)
+{
+    player->ammo[weaponinfo[player->readyweapon].ammo] -= BFGCELLS;
+    P_SpawnPlayerMissile(player->mo, MT_BFG);
+}
+
+
+//
+// A_FirePlasma
+//
+void A_FirePlasma(player_t* player, pspdef_t* psp)
+{
+    player->ammo[weaponinfo[player->readyweapon].ammo]--;
+
+    P_SetPsprite(player,
+                 ps_flash,
+                 weaponinfo[player->readyweapon].flashstate + (P_Random() & 1));
+
+    P_SpawnPlayerMissile(player->mo, MT_PLASMA);
+}
+
+
+//
+// P_BulletSlope
+// Sets a slope so a near miss is at aproximately
+// the height of the intended target
+//
+void P_BulletSlope(mobj_t* mo)
+{
+    angle_t an;
+
+    // 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);
+        }
+    }
+}
+
+
+//
+// P_GunShot
+//
+void P_GunShot(mobj_t* mo, doom_boolean accurate)
+{
+    angle_t angle;
+    int damage;
+
+    damage = 5 * (P_Random() % 3 + 1);
+    angle = mo->angle;
+
+    if (!accurate)
+        angle += (P_Random() - P_Random()) << 18;
+
+    P_LineAttack(mo, angle, MISSILERANGE, bulletslope, damage);
+}
+
+
+//
+// A_FirePistol
+//
+void A_FirePistol(player_t* player, pspdef_t* psp)
+{
+    S_StartSound(player->mo, sfx_pistol);
+
+    P_SetMobjState(player->mo, S_PLAY_ATK2);
+    player->ammo[weaponinfo[player->readyweapon].ammo]--;
+
+    P_SetPsprite(player,
+                 ps_flash,
+                 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;
+
+    S_StartSound(player->mo, sfx_shotgn);
+    P_SetMobjState(player->mo, S_PLAY_ATK2);
+
+    player->ammo[weaponinfo[player->readyweapon].ammo]--;
+
+    P_SetPsprite(player,
+                 ps_flash,
+                 weaponinfo[player->readyweapon].flashstate);
+
+    P_BulletSlope(player->mo);
+
+    for (i = 0; i < 7; i++)
+        P_GunShot(player->mo, false);
+}
+
+
+//
+// A_FireShotgun2
+//
+void A_FireShotgun2(player_t* player, pspdef_t* psp)
+{
+    int i;
+    angle_t angle;
+    int damage;
+
+
+    S_StartSound(player->mo, sfx_dshtgn);
+    P_SetMobjState(player->mo, S_PLAY_ATK2);
+
+    player->ammo[weaponinfo[player->readyweapon].ammo] -= 2;
+
+    P_SetPsprite(player,
+                 ps_flash,
+                 weaponinfo[player->readyweapon].flashstate);
+
+    P_BulletSlope(player->mo);
+
+    for (i = 0; i < 20; i++)
+    {
+        damage = 5 * (P_Random() % 3 + 1);
+        angle = player->mo->angle;
+        angle += (P_Random() - P_Random()) << 19;
+        P_LineAttack(player->mo,
+                     angle,
+                     MISSILERANGE,
+                     bulletslope + ((P_Random() - P_Random()) << 5), damage);
+    }
+}
+
+
+//
+// A_FireCGun
+//
+void A_FireCGun(player_t* player, pspdef_t* psp)
+{
+    S_StartSound(player->mo, sfx_pistol);
+
+    if (!player->ammo[weaponinfo[player->readyweapon].ammo])
+        return;
+
+    P_SetMobjState(player->mo, S_PLAY_ATK2);
+    player->ammo[weaponinfo[player->readyweapon].ammo]--;
+
+    P_SetPsprite(player,
+                 ps_flash,
+                 weaponinfo[player->readyweapon].flashstate
+                 + psp->state
+                 - &states[S_CHAIN1]);
+
+    P_BulletSlope(player->mo);
+
+    P_GunShot(player->mo, !player->refire);
+}
+
+
+//
+// ?
+//
+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)
+{
+    S_StartSound(player->mo, sfx_bfg);
+}
+
+
+//
+// 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 = 0;
+
+    // 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;
+}