doom3-bfg/doomclassic/doom/p_mobj.cpp

/*
===========================================================================

Doom 3 BFG Edition GPL Source Code
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.

This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").

Doom 3 BFG Edition Source Code 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 3 of the License, or
(at your option) any later version.

Doom 3 BFG Edition Source Code 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 Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#include "Precompiled.h"
#include "globaldata.h"

#include "i_system.h"
#include "z_zone.h"
#include "m_random.h"

#include "doomdef.h"
#include "p_local.h"
#include "sounds.h"

#include "st_stuff.h"
#include "hu_stuff.h"

#include "s_sound.h"

#include "doomstat.h"

extern bool globalNetworking;

void G_PlayerReborn( int player );
void P_SpawnMapThing( mapthing_t*	mthing );


//
// P_SetMobjState
// Returns true if the mobj is still present.
//

qboolean
P_SetMobjState
( mobj_t*	mobj,
  statenum_t	state )
{
	const state_t*	st;

	do
	{
		if( state == S_NULL )
		{
			mobj->state = ( const state_t* ) S_NULL;
			P_RemoveMobj( mobj );
			return false;
		}

		st = &::g->states[state];
		mobj->state = st;
		mobj->tics = st->tics;
		mobj->sprite = st->sprite;
		mobj->frame = st->frame;

		// Modified handling.
		// Call action functions when the state is set
		if( st->action )
		{
			st->action( mobj, NULL );
		}

		state = st->nextstate;
	}
	while( !mobj->tics );

	return true;
}


//
// P_ExplodeMissile
//
void P_ExplodeMissile( mobj_t* mo )
{
	mo->momx = mo->momy = mo->momz = 0;

	P_SetMobjState( mo, ( statenum_t )mobjinfo[mo->type].deathstate );

	mo->tics -= P_Random() & 3;

	if( mo->tics < 1 )
	{
		mo->tics = 1;
	}

	mo->flags &= ~MF_MISSILE;

	if( mo->info->deathsound )
	{
		S_StartSound( mo, mo->info->deathsound );
	}
}


//
// P_XYMovement
//

void P_XYMovement( mobj_t* mo )
{
	fixed_t 	ptryx;
	fixed_t	ptryy;
	player_t*	player;
	fixed_t	xmove;
	fixed_t	ymove;

	if( !mo->momx && !mo->momy )
	{
		if( mo->flags & MF_SKULLFLY )
		{
			// the skull slammed into something
			mo->flags &= ~MF_SKULLFLY;
			mo->momx = mo->momy = mo->momz = 0;

			P_SetMobjState( mo, ( statenum_t )mo->info->spawnstate );
		}
		return;
	}

	player = mo->player;

	if( mo->momx > MAXMOVE )
	{
		mo->momx = MAXMOVE;
	}
	else if( mo->momx < -MAXMOVE )
	{
		mo->momx = -MAXMOVE;
	}

	if( mo->momy > MAXMOVE )
	{
		mo->momy = MAXMOVE;
	}
	else if( mo->momy < -MAXMOVE )
	{
		mo->momy = -MAXMOVE;
	}

	xmove = mo->momx;
	ymove = mo->momy;

	do
	{
		if( xmove > MAXMOVE / 2 || ymove > MAXMOVE / 2 )
		{
			ptryx = mo->x + xmove / 2;
			ptryy = mo->y + ymove / 2;
			xmove >>= 1;
			ymove >>= 1;
		}
		else
		{
			ptryx = mo->x + xmove;
			ptryy = mo->y + ymove;
			xmove = ymove = 0;
		}

		if( !P_TryMove( mo, ptryx, ptryy ) )
		{
			// blocked move
			if( mo->player )
			{
				// try to slide along it
				P_SlideMove( mo );
			}
			else if( mo->flags & MF_MISSILE )
			{
				// explode a missile
				if( ::g->ceilingline &&
						::g->ceilingline->backsector &&
						::g->ceilingline->backsector->ceilingpic == ::g->skyflatnum )
				{
					// Hack to prevent missiles exploding
					// against the sky.
					// Does not handle sky floors.
					P_RemoveMobj( mo );
					return;
				}
				P_ExplodeMissile( mo );
			}
			else
			{
				mo->momx = mo->momy = 0;
			}
		}
	}
	while( xmove || ymove );

	// slow down
	if( player && player->cheats & CF_NOMOMENTUM )
	{
		// debug option for no sliding at all
		mo->momx = mo->momy = 0;
		return;
	}

	if( mo->flags & ( MF_MISSILE | MF_SKULLFLY ) )
	{
		return;    // no friction for missiles ever
	}

	if( mo->z > mo->floorz )
	{
		return;    // no friction when airborne
	}

	if( mo->flags & MF_CORPSE )
	{
		// do not stop sliding
		//  if halfway off a step with some momentum
		if( mo->momx > FRACUNIT / 4
				|| mo->momx < -FRACUNIT / 4
				|| mo->momy > FRACUNIT / 4
				|| mo->momy < -FRACUNIT / 4 )
		{
			if( mo->floorz != mo->subsector->sector->floorheight )
			{
				return;
			}
		}
	}

	if( mo->momx > -STOPSPEED
			&& mo->momx < STOPSPEED
			&& mo->momy > -STOPSPEED
			&& mo->momy < STOPSPEED
			&& ( !player
				 || ( player->cmd.forwardmove == 0
					  && player->cmd.sidemove == 0 ) ) )
	{
		// if in a walking frame, stop moving
		if( player && ( unsigned )( ( player->mo->state - ::g->states ) - S_PLAY_RUN1 ) < 4 )
		{
			P_SetMobjState( player->mo, S_PLAY );
		}

		mo->momx = 0;
		mo->momy = 0;
	}
	else
	{
		mo->momx = FixedMul( mo->momx, FRICTION );
		mo->momy = FixedMul( mo->momy, FRICTION );
	}
}

//
// P_ZMovement
//
void P_ZMovement( mobj_t* mo )
{
	fixed_t	dist;
	fixed_t	delta;

	// check for smooth step up
	if( mo->player && mo->z < mo->floorz )
	{
		mo->player->viewheight -= mo->floorz - mo->z;

		mo->player->deltaviewheight
			= ( VIEWHEIGHT - mo->player->viewheight ) >> 3;
	}

	// adjust height
	mo->z += mo->momz;

	if( mo->flags & MF_FLOAT
			&& mo->target )
	{
		// float down towards target if too close
		if( !( mo->flags & MF_SKULLFLY )
				&& !( mo->flags & MF_INFLOAT ) )
		{
			dist = P_AproxDistance( mo->x - mo->target->x,
									mo->y - mo->target->y );

			delta = ( mo->target->z + ( mo->height >> 1 ) ) - mo->z;

			if( delta < 0 && dist < -( delta * 3 ) )
			{
				mo->z -= FLOATSPEED;
			}
			else if( delta > 0 && dist < ( delta * 3 ) )
			{
				mo->z += FLOATSPEED;
			}
		}

	}

	// clip movement
	if( mo->z <= mo->floorz )
	{
		// hit the floor

		// Note (id):
		//  somebody left this after the setting momz to 0,
		//  kinda useless there.
		if( mo->flags & MF_SKULLFLY )
		{
			// the skull slammed into something
			mo->momz = -mo->momz;
		}

		if( mo->momz < 0 )
		{
			if( mo->player
					&& mo->momz < -GRAVITY * 8 )
			{
				// Squat down.
				// Decrease ::g->viewheight for a moment
				// after hitting the ground (hard),
				// and utter appropriate sound.
				mo->player->deltaviewheight = mo->momz >> 3;
				if( globalNetworking || ( mo->player == &::g->players[::g->consoleplayer] ) )
				{
					S_StartSound( mo, sfx_oof );
				}
			}
			mo->momz = 0;
		}
		mo->z = mo->floorz;

		if( ( mo->flags & MF_MISSILE )
				&& !( mo->flags & MF_NOCLIP ) )
		{
			P_ExplodeMissile( mo );
			return;
		}
	}
	else if( !( mo->flags & MF_NOGRAVITY ) )
	{
		if( mo->momz == 0 )
		{
			mo->momz = -GRAVITY * 2;
		}
		else
		{
			mo->momz -= GRAVITY;
		}
	}

	if( mo->z + mo->height > mo->ceilingz )
	{
		// hit the ceiling
		if( mo->momz > 0 )
		{
			mo->momz = 0;
		}
		{
			mo->z = mo->ceilingz - mo->height;
		}

		if( mo->flags & MF_SKULLFLY )
		{
			// the skull slammed into something
			mo->momz = -mo->momz;
		}

		if( ( mo->flags & MF_MISSILE )
				&& !( mo->flags & MF_NOCLIP ) )
		{
			P_ExplodeMissile( mo );
			return;
		}
	}
}



//
// P_NightmareRespawn
//
void
P_NightmareRespawn( mobj_t* mobj )
{
	fixed_t		x;
	fixed_t		y;
	fixed_t		z;
	subsector_t*	ss;
	mobj_t*		mo;
	mapthing_t*		mthing;

	x = mobj->spawnpoint.x << FRACBITS;
	y = mobj->spawnpoint.y << FRACBITS;

	// somthing is occupying it's position?
	if( !P_CheckPosition( mobj, x, y ) )
	{
		return;    // no respwan
	}

	// spawn a teleport fog at old spot
	// because of removal of the body?
	mo = P_SpawnMobj( mobj->x,
					  mobj->y,
					  mobj->subsector->sector->floorheight , MT_TFOG );
	// initiate teleport sound
	S_StartSound( mo, sfx_telept );

	// spawn a teleport fog at the new spot
	ss = R_PointInSubsector( x, y );

	mo = P_SpawnMobj( x, y, ss->sector->floorheight , MT_TFOG );

	S_StartSound( mo, sfx_telept );

	// spawn the new monster
	mthing = &mobj->spawnpoint;

	// spawn it
	if( mobj->info->flags & MF_SPAWNCEILING )
	{
		z = ONCEILINGZ;
	}
	else
	{
		z = ONFLOORZ;
	}

	// inherit attributes from deceased one
	mo = P_SpawnMobj( x, y, z, mobj->type );
	mo->spawnpoint = mobj->spawnpoint;
	mo->angle = ANG45 * ( mthing->angle / 45 );

	if( mthing->options & MTF_AMBUSH )
	{
		mo->flags |= MF_AMBUSH;
	}

	mo->reactiontime = 18;

	// remove the old monster,
	P_RemoveMobj( mobj );
}


//
// P_MobjThinker
//
void P_MobjThinker( mobj_t* mobj )
{
	// momentum movement
	if( mobj->momx
			|| mobj->momy
			|| ( mobj->flags & MF_SKULLFLY ) )
	{
		P_XYMovement( mobj );

		// FIXME: decent NOP/NULL/Nil function pointer please.
		if( mobj->thinker.function.acv == ( actionf_v )( -1 ) )
		{
			return;    // mobj was removed
		}
	}
	if( ( mobj->z != mobj->floorz )
			|| mobj->momz )
	{
		P_ZMovement( mobj );

		// FIXME: decent NOP/NULL/Nil function pointer please.
		if( mobj->thinker.function.acv == ( actionf_v )( -1 ) )
		{
			return;    // mobj was removed
		}
	}


	// cycle through states,
	// calling action functions at transitions
	if( mobj->tics != -1 )
	{
		mobj->tics--;

		// you can cycle through multiple states in a tic
		if( !mobj->tics )
			if( !P_SetMobjState( mobj, mobj->state->nextstate ) )
			{
				return;    // freed itself
			}
	}
	else
	{
		// check for nightmare respawn
		if( !( mobj->flags & MF_COUNTKILL ) )
		{
			return;
		}

		if( !::g->respawnmonsters )
		{
			return;
		}

		mobj->movecount++;

		if( mobj->movecount < 12 * TICRATE )
		{
			return;
		}

		if( ::g->leveltime & 31 )
		{
			return;
		}

		if( P_Random() > 4 )
		{
			return;
		}

		P_NightmareRespawn( mobj );
	}

}


//
// P_SpawnMobj
//
mobj_t*
P_SpawnMobj
( fixed_t	x,
  fixed_t	y,
  fixed_t	z,
  mobjtype_t	type )
{
	mobj_t*	mobj;
	const state_t*	st;
	const mobjinfo_t*	info;

	mobj = ( mobj_t* )DoomLib::Z_Malloc( sizeof( *mobj ), PU_LEVEL, NULL );
	memset( mobj, 0, sizeof( *mobj ) );
	info = &mobjinfo[type];

	mobj->type = type;
	mobj->info = info;
	mobj->x = x;
	mobj->y = y;
	mobj->radius = info->radius;
	mobj->height = info->height;
	mobj->flags = info->flags;
	mobj->health = info->spawnhealth;

	if( ::g->gameskill != sk_nightmare )
	{
		mobj->reactiontime = info->reactiontime;
	}

	mobj->lastlook = P_Random() % MAXPLAYERS;
	// do not set the state with P_SetMobjState,
	// because action routines can not be called yet
	st = &::g->states[info->spawnstate];

	mobj->state = st;
	mobj->tics = st->tics;
	mobj->sprite = st->sprite;
	mobj->frame = st->frame;

	// set subsector and/or block links
	P_SetThingPosition( mobj );

	mobj->floorz = mobj->subsector->sector->floorheight;
	mobj->ceilingz = mobj->subsector->sector->ceilingheight;

	if( z == ONFLOORZ )
	{
		mobj->z = mobj->floorz;
	}
	else if( z == ONCEILINGZ )
	{
		mobj->z = mobj->ceilingz - mobj->info->height;
	}
	else
	{
		mobj->z = z;
	}

	mobj->thinker.function.acp1 = ( actionf_p1 )P_MobjThinker;

	P_AddThinker( &mobj->thinker );

	return mobj;
}


//
// P_RemoveMobj
//


void P_RemoveMobj( mobj_t* mobj )
{
	if( ( mobj->flags & MF_SPECIAL )
			&& !( mobj->flags & MF_DROPPED )
			&& ( mobj->type != MT_INV )
			&& ( mobj->type != MT_INS ) )
	{
		::g->itemrespawnque[::g->iquehead] = mobj->spawnpoint;
		::g->itemrespawntime[::g->iquehead] = ::g->leveltime;
		::g->iquehead = ( ::g->iquehead + 1 ) & ( ITEMQUESIZE - 1 );

		// lose one off the end?
		if( ::g->iquehead == ::g->iquetail )
		{
			::g->iquetail = ( ::g->iquetail + 1 ) & ( ITEMQUESIZE - 1 );
		}
	}

	// unlink from sector and block lists
	P_UnsetThingPosition( mobj );

	// stop any playing sound
	//S_StopSound (mobj);

	// free block
	P_RemoveThinker( ( thinker_t* )mobj );
}




//
// P_RespawnSpecials
//
void P_RespawnSpecials( void )
{
	fixed_t		x;
	fixed_t		y;
	fixed_t		z;

	subsector_t*	ss;
	mobj_t*		mo;
	mapthing_t*		mthing;

	int			i;

	// only respawn items in ::g->deathmatch
	if( ::g->deathmatch != 2 )
	{
		return;    //
	}

	// nothing left to respawn?
	if( ::g->iquehead == ::g->iquetail )
	{
		return;
	}

	// wait at least 30 seconds
	if( ::g->leveltime - ::g->itemrespawntime[::g->iquetail] < 30 * TICRATE )
	{
		return;
	}

	mthing = &::g->itemrespawnque[::g->iquetail];

	x = mthing->x << FRACBITS;
	y = mthing->y << FRACBITS;

	// spawn a teleport fog at the new spot
	ss = R_PointInSubsector( x, y );
	mo = P_SpawnMobj( x, y, ss->sector->floorheight , MT_IFOG );
	S_StartSound( mo, sfx_itmbk );

	// find which type to spawn
	for( i = 0 ; i < NUMMOBJTYPES ; i++ )
	{
		if( mthing->type == mobjinfo[i].doomednum )
		{
			break;
		}
	}

	// spawn it
	if( mobjinfo[i].flags & MF_SPAWNCEILING )
	{
		z = ONCEILINGZ;
	}
	else
	{
		z = ONFLOORZ;
	}

	mo = ( mobj_t* )P_SpawnMobj( x, y, z, ( mobjtype_t )i );
	mo->spawnpoint = *mthing;
	mo->angle = ANG45 * ( mthing->angle / 45 );

	// pull it from the que
	::g->iquetail = ( ::g->iquetail + 1 ) & ( ITEMQUESIZE - 1 );
}




//
// P_SpawnPlayer
// Called when a player is spawned on the level.
// Most of the player structure stays unchanged
//  between levels.
//
void P_SpawnPlayer( mapthing_t* mthing )
{
	player_t*		p;
	fixed_t		x;
	fixed_t		y;
	fixed_t		z;

	mobj_t*		mobj;

	int			i;

	// not playing?
	if( !::g->playeringame[mthing->type - 1] )
	{
		return;
	}

	p = &::g->players[mthing->type - 1];

	if( p->playerstate == PST_REBORN )
	{
		G_PlayerReborn( mthing->type - 1 );
	}

	x 		= mthing->x << FRACBITS;
	y 		= mthing->y << FRACBITS;
	z		= ONFLOORZ;
	mobj	= P_SpawnMobj( x, y, z, MT_PLAYER );

	// set color translations for player ::g->sprites
	if( mthing->type > 1 )
	{
		mobj->flags |= ( mthing->type - 1 ) << MF_TRANSSHIFT;
	}

	mobj->angle	= ANG45 * ( mthing->angle / 45 );
	mobj->player = p;
	mobj->health = p->health;

	p->mo = mobj;
	p->playerstate = PST_LIVE;
	p->refire = 0;
	p->message = NULL;
	p->damagecount = 0;
	p->bonuscount = 0;
	p->extralight = 0;
	p->fixedcolormap = 0;
	p->viewheight = VIEWHEIGHT;

	// setup gun psprite
	P_SetupPsprites( p );

	// give all cards in death match mode
	if( ::g->deathmatch )
		for( i = 0 ; i < NUMCARDS ; i++ )
		{
			p->cards[i] = true;
		}

	if( mthing->type - 1 == ::g->consoleplayer )
	{
		// wake up the status bar
		ST_Start();
		// wake up the heads up text
		HU_Start();
	}

	// Give him everything is Give All is on.
	if( p->cheats & CF_GIVEALL )
	{
		p->armorpoints = 200;
		p->armortype = 2;

		int i;
		for( i = 0; i < NUMWEAPONS; i++ )
		{
			p->weaponowned[i] = true;
		}

		for( i = 0; i < NUMAMMO; i++ )
		{
			p->ammo[i] =  p->maxammo[i];
		}

		for( i = 0; i < NUMCARDS; i++ )
		{
			p->cards[i] = true;
		}
	}

}


//
// P_SpawnMapThing
// The fields of the mapthing should
// already be in host byte order.
//
void P_SpawnMapThing( mapthing_t* mthing )
{
	int			i;
	int			bit;
	mobj_t*		mobj;
	fixed_t		x;
	fixed_t		y;
	fixed_t		z;

	// count ::g->deathmatch start positions
	if( mthing->type == 11 )
	{
		if( ::g->deathmatch_p < &::g->deathmatchstarts[10] )
		{
			memcpy( ::g->deathmatch_p, mthing, sizeof( *mthing ) );
			::g->deathmatch_p++;
		}
		return;
	}

	// check for ::g->players specially
	if( mthing->type <= 4 )
	{
		// save spots for respawning in network games
		::g->playerstarts[mthing->type - 1] = *mthing;
		if( !::g->deathmatch )
		{
			P_SpawnPlayer( mthing );
		}

		return;
	}

	// check for apropriate skill level
	if( !::g->netgame && ( mthing->options & 16 ) )
	{
		return;
	}

	if( ::g->gameskill == sk_baby )
	{
		bit = 1;
	}
	else if( ::g->gameskill == sk_nightmare )
	{
		bit = 4;
	}
	else
	{
		bit = 1 << ( ::g->gameskill - 1 );
	}

	if( !( mthing->options & bit ) )
	{
		return;
	}

	// find which type to spawn
	for( i = 0 ; i < NUMMOBJTYPES ; i++ )
		if( mthing->type == mobjinfo[i].doomednum )
		{
			break;
		}

	if( i == NUMMOBJTYPES )
	{
		//printf( "P_SpawnMapThing: Unknown type %i at (%i, %i)", mthing->type, mthing->x, mthing->y);
		return;
		//I_Error ("P_SpawnMapThing: Unknown type %i at (%i, %i)",
		//mthing->type,
		//mthing->x, mthing->y);
	}

	// don't spawn keycards and ::g->players in ::g->deathmatch
	if( ::g->deathmatch && mobjinfo[i].flags & MF_NOTDMATCH )
	{
		return;
	}

	// don't spawn any monsters if -::g->nomonsters
	if( ::g->nomonsters
			&& ( i == MT_SKULL
				 || ( mobjinfo[i].flags & MF_COUNTKILL ) ) )
	{
		return;
	}

	// spawn it
	x = mthing->x << FRACBITS;
	y = mthing->y << FRACBITS;

	if( mobjinfo[i].flags & MF_SPAWNCEILING )
	{
		z = ONCEILINGZ;
	}
	else
	{
		z = ONFLOORZ;
	}

	mobj = ( mobj_t* )P_SpawnMobj( x, y, z, ( mobjtype_t )i );
	mobj->spawnpoint = *mthing;

	if( mobj->tics > 0 )
	{
		mobj->tics = 1 + ( P_Random() % mobj->tics );
	}
	if( mobj->flags & MF_COUNTKILL )
	{
		::g->totalkills++;
	}
	if( mobj->flags & MF_COUNTITEM )
	{
		::g->totalitems++;
	}

	mobj->angle = ANG45 * ( mthing->angle / 45 );
	if( mthing->options & MTF_AMBUSH )
	{
		mobj->flags |= MF_AMBUSH;
	}
}



//
// GAME SPAWN FUNCTIONS
//


//
// P_SpawnPuff
//

void
P_SpawnPuff
( fixed_t	x,
  fixed_t	y,
  fixed_t	z )
{
	mobj_t*	th;

	z += ( ( P_Random() - P_Random() ) << 10 );

	th = P_SpawnMobj( x, y, z, MT_PUFF );
	th->momz = FRACUNIT;
	th->tics -= P_Random() & 3;

	if( th->tics < 1 )
	{
		th->tics = 1;
	}

	// don't make punches spark on the wall
	if( ::g->attackrange == MELEERANGE )
	{

		P_SetMobjState( th, S_PUFF3 );

	}
}



//
// P_SpawnBlood
//
void
P_SpawnBlood
( fixed_t	x,
  fixed_t	y,
  fixed_t	z,
  int		damage )
{
	mobj_t*	th;

	z += ( ( P_Random() - P_Random() ) << 10 );
	th = P_SpawnMobj( x, y, z, MT_BLOOD );
	th->momz = FRACUNIT * 2;
	th->tics -= P_Random() & 3;

	if( th->tics < 1 )
	{
		th->tics = 1;
	}

	if( damage <= 12 && damage >= 9 )
	{
		P_SetMobjState( th, S_BLOOD2 );
	}
	else if( damage < 9 )
	{
		P_SetMobjState( th, S_BLOOD3 );
	}
}



//
// P_CheckMissileSpawn
// Moves the missile forward a bit
//  and possibly explodes it right there.
//
void P_CheckMissileSpawn( mobj_t* th )
{
	th->tics -= P_Random() & 3;
	if( th->tics < 1 )
	{
		th->tics = 1;
	}

	// move a little forward so an angle can
	// be computed if it immediately explodes
	th->x += ( th->momx >> 1 );
	th->y += ( th->momy >> 1 );
	th->z += ( th->momz >> 1 );

	if( !P_TryMove( th, th->x, th->y ) )
	{
		P_ExplodeMissile( th );
	}
}


//
// P_SpawnMissile
//
mobj_t*
P_SpawnMissile
( mobj_t*	source,
  mobj_t*	dest,
  mobjtype_t	type )
{
	mobj_t*	th;
	angle_t	an;
	int		dist;

	th = P_SpawnMobj( source->x,
					  source->y,
					  source->z + 4 * 8 * FRACUNIT, type );

	if( th->info->seesound )
	{
		S_StartSound( th, th->info->seesound );
	}

	th->target = source;	// where it came from
	an = R_PointToAngle2( source->x, source->y, dest->x, dest->y );

	// fuzzy player
	if( dest->flags & MF_SHADOW )
	{
		an += ( P_Random() - P_Random() ) << 20;
	}

	th->angle = an;
	an >>= ANGLETOFINESHIFT;
	th->momx = FixedMul( th->info->speed, finecosine[an] );
	th->momy = FixedMul( th->info->speed, finesine[an] );

	dist = P_AproxDistance( dest->x - source->x, dest->y - source->y );
	dist = dist / th->info->speed;

	if( dist < 1 )
	{
		dist = 1;
	}

	th->momz = ( dest->z - source->z ) / dist;
	P_CheckMissileSpawn( th );

	return th;
}


//
// P_SpawnPlayerMissile
// Tries to aim at a nearby monster
//
void
P_SpawnPlayerMissile
( mobj_t*	source,
  mobjtype_t	type )
{
	mobj_t*	th;
	angle_t	an;

	fixed_t	x;
	fixed_t	y;
	fixed_t	z;
	fixed_t	slope;

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

	if( !::g->linetarget )
	{
		an += 1 << 26;
		slope = P_AimLineAttack( source, an, 16 * 64 * FRACUNIT );

		if( !::g->linetarget )
		{
			an -= 2 << 26;
			slope = P_AimLineAttack( source, an, 16 * 64 * FRACUNIT );
		}

		if( !::g->linetarget )
		{
			an = source->angle;
			slope = 0;
		}
	}

	x = source->x;
	y = source->y;
	z = source->z + 4 * 8 * FRACUNIT;

	th = P_SpawnMobj( x, y, z, type );

	if( th->info->seesound && ( source->player == &::g->players[::g->consoleplayer] ) )
	{
		S_StartSound( th, th->info->seesound );
	}

	th->target = source;
	th->angle = an;
	th->momx = FixedMul( th->info->speed,
						 finecosine[an >> ANGLETOFINESHIFT] );
	th->momy = FixedMul( th->info->speed,
						 finesine[an >> ANGLETOFINESHIFT] );
	th->momz = FixedMul( th->info->speed, slope );

	P_CheckMissileSpawn( th );
}