p_hpspr.c

The source code of Doom legacy for windows

		ripper = P_SpawnMobj(actor->x, actor->y, actor->z, MT_RIPPER);
		angle = i*ANG45;
		ripper->target = actor->target;
		ripper->angle = angle;
		angle >>= ANGLETOFINESHIFT;
		ripper->momx = FixedMul(ripper->info->speed, finecosine[angle]);
		ripper->momy = FixedMul(ripper->info->speed, finesine[angle]);
		P_CheckMissileSpawn(ripper);
	}
}

//----------------------------------------------------------------------------
//
// PROC A_FireCrossbowPL1
//
//----------------------------------------------------------------------------

void A_FireCrossbowPL1(player_t *player, pspdef_t *psp)
{
	mobj_t *pmo;

	pmo = player->mo;
	player->ammo[am_crossbow] -= USE_CBOW_AMMO_1;
	P_SpawnPlayerMissile(pmo, MT_CRBOWFX1);
	P_SPMAngle(pmo, MT_CRBOWFX3, pmo->angle-(ANG45/10));
	P_SPMAngle(pmo, MT_CRBOWFX3, pmo->angle+(ANG45/10));
}

//----------------------------------------------------------------------------
//
// PROC A_FireCrossbowPL2
//
//----------------------------------------------------------------------------

void A_FireCrossbowPL2(player_t *player, pspdef_t *psp)
{
	mobj_t *pmo;

	pmo = player->mo;
	player->ammo[am_crossbow] -=
		cv_deathmatch.value ? USE_CBOW_AMMO_1 : USE_CBOW_AMMO_2;
	P_SpawnPlayerMissile(pmo, MT_CRBOWFX2);
	P_SPMAngle(pmo, MT_CRBOWFX2, pmo->angle-(ANG45/10));
	P_SPMAngle(pmo, MT_CRBOWFX2, pmo->angle+(ANG45/10));
	P_SPMAngle(pmo, MT_CRBOWFX3, pmo->angle-(ANG45/5));
	P_SPMAngle(pmo, MT_CRBOWFX3, pmo->angle+(ANG45/5));
}

//----------------------------------------------------------------------------
//
// PROC A_BoltSpark
//
//----------------------------------------------------------------------------

void A_BoltSpark(mobj_t *bolt)
{
    mobj_t *spark;
    
    if(P_Random() > 50)
    {
        spark = P_SpawnMobj(bolt->x, bolt->y, bolt->z, MT_CRBOWFX4);
        spark->x += P_SignedRandom()<<10;
        spark->y += P_SignedRandom()<<10;
    }
}

//----------------------------------------------------------------------------
//
// PROC A_FireSkullRodPL1
//
//----------------------------------------------------------------------------

void A_FireSkullRodPL1(player_t *player, pspdef_t *psp)
{
	mobj_t *mo;

	if(player->ammo[am_skullrod] < USE_SKRD_AMMO_1)
	{
		return;
	}
	player->ammo[am_skullrod] -= USE_SKRD_AMMO_1;
	mo = P_SpawnPlayerMissile(player->mo, MT_HORNRODFX1);
	// Randomize the first frame
	if(mo && P_Random() > 128)
	{
		P_SetMobjState(mo, S_HRODFX1_2);
	}
}

//----------------------------------------------------------------------------
//
// PROC A_FireSkullRodPL2
//
// The special2 field holds the player number that shot the rain missile.
// The special1 field is used for the seeking routines, then as a counter
// for the sound looping.
//
//----------------------------------------------------------------------------

void A_FireSkullRodPL2(player_t *player, pspdef_t *psp)
{
    mobj_t *MissileMobj;

    player->ammo[am_skullrod] -=
        cv_deathmatch.value ? USE_SKRD_AMMO_1 : USE_SKRD_AMMO_2;
    MissileMobj = P_SpawnPlayerMissile(player->mo, MT_HORNRODFX2);
    // Use MissileMobj instead of the return value from
    // P_SpawnPlayerMissile because we need to give info to the mobj
    // even if it exploded immediately.
    if(netgame)
    { // Multi-player game
        MissileMobj->special2 = player-players;
    }
    else
    { // Always use red missiles in single player games
        MissileMobj->special2 = 2;
    }
    if(linetarget)
    {
        MissileMobj->special1 = (int)linetarget;
    }
    S_StartSound(MissileMobj, sfx_hrnpow);
}

//----------------------------------------------------------------------------
//
// PROC A_SkullRodPL2Seek
//
//----------------------------------------------------------------------------

void A_SkullRodPL2Seek(mobj_t *actor)
{
	P_SeekerMissile(actor, ANGLE_1*10, ANGLE_1*30);
}

//----------------------------------------------------------------------------
//
// PROC A_AddPlayerRain
//
//----------------------------------------------------------------------------

void A_AddPlayerRain(mobj_t *actor)
{
	int playerNum;
	player_t *player;

	playerNum = netgame ? actor->special2 : 0;
	if(!playeringame[playerNum])
	{ // Player left the game
		return;
	}
	player = &players[playerNum];
	if(player->health <= 0)
	{ // Player is dead
		return;
	}
	if(player->rain1 && player->rain2)
	{ // Terminate an active rain
		if(player->rain1->health < player->rain2->health)
		{
			if(player->rain1->health > 16)
			{
				player->rain1->health = 16;
			}
			player->rain1 = NULL;
		}
		else
		{
			if(player->rain2->health > 16)
			{
				player->rain2->health = 16;
			}
			player->rain2 = NULL;
		}
	}
	// Add rain mobj to list
	if(player->rain1)
	{
		player->rain2 = actor;
	}
	else
	{
		player->rain1 = actor;
	}
}

//----------------------------------------------------------------------------
//
// PROC A_SkullRodStorm
//
//----------------------------------------------------------------------------

void A_SkullRodStorm(mobj_t *actor)
{
	fixed_t x;
	fixed_t y;
	mobj_t *mo;
	int playerNum;
	player_t *player;

	if(actor->health-- == 0)
	{
		P_SetMobjState(actor, S_NULL);
		playerNum = netgame ? actor->special2 : 0;
		if(!playeringame[playerNum])
		{ // Player left the game
			return;
		}
		player = &players[playerNum];
		if(player->health <= 0)
		{ // Player is dead
			return;
		}
		if(player->rain1 == actor)
		{
			player->rain1 = NULL;
		}
		else if(player->rain2 == actor)
		{
			player->rain2 = NULL;
		}
		return;
	}
	if(P_Random() < 25)
	{ // Fudge rain frequency
		return;
	}
	x = actor->x+((P_Random()&127)-64)*FRACUNIT;
	y = actor->y+((P_Random()&127)-64)*FRACUNIT;
	mo = P_SpawnMobj(x, y, ONCEILINGZ, MT_RAINPLR1+actor->special2);
	mo->target = actor->target;
	mo->momx = 1; // Force collision detection
	mo->momz = -mo->info->speed;
	mo->special2 = actor->special2; // Transfer player number
	P_CheckMissileSpawn(mo);
	if(!(actor->special1&31))
	{
		S_StartSound(actor, sfx_ramrain);
	}
	actor->special1++;
}

//----------------------------------------------------------------------------
//
// PROC A_RainImpact
//
//----------------------------------------------------------------------------

void A_RainImpact(mobj_t *actor)
{
	if(actor->z > actor->floorz)
	{
		P_SetMobjState(actor, S_RAINAIRXPLR1_1+actor->special2);
	}
	else if(P_Random() < 40)
	{
		P_HitFloor(actor);
	}
}

//----------------------------------------------------------------------------
//
// PROC A_HideInCeiling
//
//----------------------------------------------------------------------------

void A_HideInCeiling(mobj_t *actor)
{
	actor->z = actor->ceilingz+4*FRACUNIT;
}

//----------------------------------------------------------------------------
//
// PROC A_FirePhoenixPL1
//
//----------------------------------------------------------------------------

void A_FirePhoenixPL1(player_t *player, pspdef_t *psp)
{
	angle_t angle;

	player->ammo[am_phoenixrod] -= USE_PHRD_AMMO_1;
	P_SpawnPlayerMissile(player->mo, MT_PHOENIXFX1);
	//P_SpawnPlayerMissile(player->mo, MT_MNTRFX2);
	angle = player->mo->angle+ANG180;
	angle >>= ANGLETOFINESHIFT;
	player->mo->momx += FixedMul(4*FRACUNIT, finecosine[angle]);
	player->mo->momy += FixedMul(4*FRACUNIT, finesine[angle]);
}

//----------------------------------------------------------------------------
//
// PROC A_PhoenixPuff
//
//----------------------------------------------------------------------------

void A_PhoenixPuff(mobj_t *actor)
{
	mobj_t *puff;
	angle_t angle;

	P_SeekerMissile(actor, ANGLE_1*5, ANGLE_1*10);
	puff = P_SpawnMobj(actor->x, actor->y, actor->z, MT_PHOENIXPUFF);
	angle = actor->angle+ANG90;
	angle >>= ANGLETOFINESHIFT;
	puff->momx = FixedMul(FRACUNIT*1.3, finecosine[angle]);
	puff->momy = FixedMul(FRACUNIT*1.3, finesine[angle]);
	puff->momz = 0;
	puff = P_SpawnMobj(actor->x, actor->y, actor->z, MT_PHOENIXPUFF);
	angle = actor->angle-ANG90;
	angle >>= ANGLETOFINESHIFT;
	puff->momx = FixedMul(FRACUNIT*1.3, finecosine[angle]);
	puff->momy = FixedMul(FRACUNIT*1.3, finesine[angle]);
	puff->momz = 0;
}

//----------------------------------------------------------------------------
//
// PROC A_InitPhoenixPL2
//
//----------------------------------------------------------------------------

void A_InitPhoenixPL2(player_t *player, pspdef_t *psp)
{
	player->flamecount = FLAME_THROWER_TICS;
}

//----------------------------------------------------------------------------
//
// PROC A_FirePhoenixPL2
//
// Flame thrower effect.
//
//----------------------------------------------------------------------------

void A_FirePhoenixPL2(player_t *player, pspdef_t *psp)
{
	mobj_t *mo;
	mobj_t *pmo;
	angle_t angle;
	fixed_t x, y, z;
	fixed_t slope;

	if(--player->flamecount == 0)
	{ // Out of flame
		P_SetPsprite(player, ps_weapon, S_PHOENIXATK2_4);
		player->refire = 0;
		return;
	}
	pmo = player->mo;
	angle = pmo->angle;
	x = pmo->x+(P_SignedRandom()<<9);
	y = pmo->y+(P_SignedRandom()<<9);
	z = pmo->z+26*FRACUNIT+((player->aiming)<<FRACBITS)/173;
	if(pmo->flags2&MF2_FEETARECLIPPED)
	{
		z -= FOOTCLIPSIZE;
	}
	slope = AIMINGTOSLOPE(player->aiming);
	mo = P_SpawnMobj(x, y, z, MT_PHOENIXFX2);
	mo->target = pmo;
	mo->angle = angle;
	mo->momx = pmo->momx+FixedMul(mo->info->speed,
		finecosine[angle>>ANGLETOFINESHIFT]);
	mo->momy = pmo->momy+FixedMul(mo->info->speed,
		finesine[angle>>ANGLETOFINESHIFT]);
	mo->momz = FixedMul(mo->info->speed, slope);
	if(!player->refire || !(leveltime%38))
	{
		S_StartSound(player->mo, sfx_phopow);
	}
	P_CheckMissileSpawn(mo);
}

//----------------------------------------------------------------------------
//
// PROC A_ShutdownPhoenixPL2
//
//----------------------------------------------------------------------------

void A_ShutdownPhoenixPL2(player_t *player, pspdef_t *psp)
{
	player->ammo[am_phoenixrod] -= USE_PHRD_AMMO_2;
}

//----------------------------------------------------------------------------
//
// PROC A_FlameEnd
//
//----------------------------------------------------------------------------

void A_FlameEnd(mobj_t *actor)
{
	actor->momz += 1.5*FRACUNIT;
}

//----------------------------------------------------------------------------
//
// PROC A_FloatPuff
//
//----------------------------------------------------------------------------

void A_FloatPuff(mobj_t *puff)
{
	puff->momz += 1.8*FRACUNIT;
}

//---------------------------------------------------------------------------
//
// PROC A_GauntletAttack
//
//---------------------------------------------------------------------------

void A_GauntletAttack(player_t *player, pspdef_t *psp)
{
	angle_t angle;
	int damage;
	int slope;
	int randVal;
	fixed_t dist;

	psp->sx = ((P_Random()&3)-2)*FRACUNIT;
	psp->sy = WEAPONTOP+(P_Random()&3)*FRACUNIT;
	angle = player->mo->angle;
	if(player->powers[pw_weaponlevel2])
	{
		damage = HITDICE(2);
		dist = 4*MELEERANGE;
		angle += P_SignedRandom()<<17;
		PuffType = MT_GAUNTLETPUFF2;
	}
	else
	{
		damage = HITDICE(2);
		dist = MELEERANGE+1;
		angle += P_SignedRandom()<<18;
		PuffType = MT_GAUNTLETPUFF1;
	}
	slope = P_AimLineAttack(player->mo, angle, dist);
	P_LineAttack(player->mo, angle, dist, slope, damage);
	if(!linetarget)
	{
		if(P_Random() > 64)
		{
			player->extralight = !player->extralight;
		}
		S_StartSound(player->mo, sfx_gntful);
		return;
	}
	randVal = P_Random();
	if(randVal < 64)
	{
		player->extralight = 0;
	}
	else if(randVal < 160)
	{
		player->extralight = 1;
	}
	else
	{
		player->extralight = 2;
	}
	if(player->powers[pw_weaponlevel2])
	{
		P_GiveBody(player, damage>>1);
		S_StartSound(player->mo, sfx_gntpow);
	}
	else
	{
		S_StartSound(player->mo, sfx_gnthit);
	}
	// 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;
}