CGDoom/cgdoom/p_pspr.c

// 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.
//
//-----------------------------------------------------------------------------

//static const char 

#include "doomdef.h"
#include "d_event.h"


#include "m_random.h"
#include "p_local.h"
//#include "s_sound.h"

// State.
#include "doomstat.h"

// Data.
//#include "sounds.h"

#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		


void A_PSetState(int act, player_t* playr, pspdef_t* pspr );

//
// 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 = NULL;
      break;	
    }

    state = (state_t*)&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)
    {
      //state->action(player, psp);
      A_PSetState(state->action, player, psp );
      if (!psp->state)
        break;
    }

    stnum = psp->state->nextstate;

  } while (!psp->tics);
  // an initial state of 0 could cycle through
}



//
// P_CalcSwing
//	
fixed_t		swingx;
fixed_t		swingy;

void P_CalcSwing (player_t*	player)
{
  fixed_t	swing;
  int		angle;

  // OPTIMIZE: tablify this.
  // A LUT would allow for different modes,
  //  and add flexibility.

  swing = player->bob;

  angle = (FINEANGLES/70*leveltime)&FINEMASK;
  swingx = FixedMul ( swing, finesine[angle]);

  angle = (FINEANGLES/70*leveltime+FINEANGLES/2)&FINEMASK;
  swingy = -FixedMul ( swingx, finesine[angle]);
}



//
// 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;

  newstate = (statenum_t)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.
//
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,(statenum_t)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, (statenum_t)S_PLAY_ATK1);
  newstate = (statenum_t)weaponinfo[player->readyweapon].atkstate;
  P_SetPsprite (player, ps_weapon, newstate);
  P_NoiseAlert (player->mo, player->mo);
}



//
// P_DropWeapon
// Player died, so put the weapon away.
//
void P_DropWeapon (player_t* player)
{
  P_SetPsprite (player,ps_weapon,(statenum_t)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, (statenum_t)S_PLAY);
  }

  // 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 = (statenum_t)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 )
{

  psp= 0; //Shuts up GCC
  // 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 )
{
  psp= 0; //Shuts up GCC
  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 = (statenum_t)weaponinfo[player->readyweapon].readystate;

  P_SetPsprite (player, ps_weapon, newstate);
}



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



//
// WEAPON ATTACKS
//


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

  psp= 0; //Shuts up GCC
  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)
  {
    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;

  psp= 0; //Shuts up GCC
  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)
    return;

  // turn to face target
  angle = R_PointToAngle2 (player->mo->x, player->mo->y,
    linetarget->x, linetarget->y);
  if (angle - player->mo->angle > ANG180)
  {
    if ((signed)(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 )
{
  psp= 0; //Shuts up GCC
  player->ammo[weaponinfo[player->readyweapon].ammo]--;
  P_SpawnPlayerMissile (player->mo, MT_ROCKET);
}


//
// A_FireBFG
//
void A_FireBFG ( player_t* player, pspdef_t* psp )
{
  psp= 0; //Shuts up GCC
  player->ammo[weaponinfo[player->readyweapon].ammo] -= BFGCELLS;
  P_SpawnPlayerMissile (player->mo, MT_BFG);
}



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

  P_SetPsprite (player,ps_flash,(statenum_t)(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
//
fixed_t		bulletslope;


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, 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 )
{
  psp= 0; //Shuts up GCC
  P_SetMobjState (player->mo, (statenum_t)S_PLAY_ATK2);
  player->ammo[weaponinfo[player->readyweapon].ammo]--;

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

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


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

  psp= 0; //Shuts up GCC
  P_SetMobjState (player->mo, (statenum_t)S_PLAY_ATK2);

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

  P_SetPsprite (player,ps_flash,(statenum_t)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;

  psp= 0; //Shuts up GCC
  P_SetMobjState (player->mo, (statenum_t)S_PLAY_ATK2);

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

  P_SetPsprite (player,ps_flash,(statenum_t)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 )
{
  if (!player->ammo[weaponinfo[player->readyweapon].ammo])
    return;

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

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

  P_BulletSlope (player->mo);

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



//
// ?
//
void A_Light0 (player_t *player)
{
  player->extralight = 0;
}

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

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


//
// A_BFGsound
//
void A_BFGsound ( player_t* player)
{
  //No sound!
  player= 0; //Shut up, GCC
}

void A_OpenShotgun2 ( player_t* player, pspdef_t* psp )
{
  player= 0; //Shut up, GCC
  psp= 0;
}

void A_LoadShotgun2 ( player_t* player, pspdef_t* psp )
{
  player= 0; //Shut up, GCC
  psp= 0;
}

//void A_ReFire ( player_t* player, pspdef_t* psp )

void A_CloseShotgun2 ( player_t* player, pspdef_t* psp )
{
  player= 0; //Shut up, GCC
  psp= 0;
  //A_ReFire(player,psp);
}


//
// 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) != NULL)	
    {
      // 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, (statenum_t)psp->state->nextstate);
      }
    }
  }

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


void A_PSetState(int act, player_t* playr, pspdef_t* pspr )
{
  switch (act)
  {
  case TA_Light0:A_Light0(playr);break;
  case TA_WeaponReady:A_WeaponReady(playr, pspr);break;
  case TA_Lower:A_Lower(playr, pspr);break;
  case TA_Raise:A_Raise(playr, pspr);break;
  case TA_Punch:A_Punch(playr, pspr);break;
  case TA_ReFire:A_ReFire(playr, pspr);break;
  case TA_FirePistol:A_FirePistol(playr, pspr);break;
  case TA_Light1:A_Light1(playr);break;
  case TA_FireShotgun:A_FireShotgun(playr, pspr);break;
  case TA_Light2:A_Light2(playr);break;
  case TA_FireShotgun2:A_FireShotgun2(playr, pspr);break;
  case TA_CheckReload:A_CheckReload(playr, pspr);break;
  case TA_OpenShotgun2:A_OpenShotgun2(playr, pspr);break;
  case TA_LoadShotgun2:A_LoadShotgun2(playr, pspr);break;
  case TA_CloseShotgun2:A_CloseShotgun2(playr, pspr);break;
  case TA_FireCGun:A_FireCGun(playr, pspr);break;
  case TA_GunFlash:A_GunFlash(playr, pspr);break;
  case TA_FireMissile:A_FireMissile(playr, pspr);break;
  case TA_Saw:A_Saw(playr, pspr);break;
  case TA_FirePlasma:A_FirePlasma(playr, pspr);break;
  case TA_BFGsound:A_BFGsound(playr);break;
  case TA_FireBFG:A_FireBFG(playr, pspr);break;
  default:
    break;
  }
}