zdoom/gzdoom-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom-gles.git synced 2025-02-17 17:11:19 +00:00
Code Issues Projects Releases Packages Wiki Activity

- Eliminated some more global variables (onmobj, DoRipping, LastRipped,

Browse source 
MissileActor, bulletpitch and linetarget.) 

SVN r899 (trunk)
This commit is contained in:
Christoph Oelckers 2008-04-10 14:38:43 +00:00
parent a390ea6a61
commit 3f497fe8e5
24 changed files with 173 additions and 154 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
docs/rh-log.txt
View file

@ -1,3 +1,7 @@
April 10, 2008 (Changes by Graf Zahl)
- Eliminated some more global variables (onmobj, DoRipping, LastRipped,
MissileActor, bulletpitch and linetarget.)
April 9, 2008 (Changes by Graf Zahl) April 9, 2008 (Changes by Graf Zahl)
- Replaced P_PathTraverse with an FPathTraverse class, rewrote all code using - Replaced P_PathTraverse with an FPathTraverse class, rewrote all code using
P_PathTraverse and got rid of a lot of global variables in the process. P_PathTraverse and got rid of a lot of global variables in the process.

4
src/c_cmds.cpp
View file

@ -748,8 +748,10 @@ CCMD (wdir)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
CCMD(linetarget) CCMD(linetarget)
{ {
AActor *linetarget;
if (CheckCheatmode () || players[consoleplayer].mo == NULL) return; if (CheckCheatmode () || players[consoleplayer].mo == NULL) return;
P_AimLineAttack(players[consoleplayer].mo,players[consoleplayer].mo->angle,MISSILERANGE, 0); P_AimLineAttack(players[consoleplayer].mo,players[consoleplayer].mo->angle,MISSILERANGE, &linetarget, 0);
if (linetarget) if (linetarget)
{ {
Printf("Target=%s, Health=%d, Spawnhealth=%d\n", Printf("Target=%s, Health=%d, Spawnhealth=%d\n",

23
src/g_doom/a_doomweaps.cpp
View file

@ -28,6 +28,7 @@ void A_Punch (AActor *actor)
angle_t angle; angle_t angle;
int damage; int damage;
int pitch; int pitch;
AActor *linetarget;
if (actor->player != NULL) if (actor->player != NULL)
{ {
@ -47,7 +48,7 @@ void A_Punch (AActor *actor)
angle = actor->angle; angle = actor->angle;
angle += pr_punch.Random2() << 18; angle += pr_punch.Random2() << 18;
pitch = P_AimLineAttack (actor, angle, MELEERANGE); pitch = P_AimLineAttack (actor, angle, MELEERANGE, &linetarget);
P_LineAttack (actor, angle, MELEERANGE, pitch, damage, NAME_Melee, NAME_BulletPuff, true); P_LineAttack (actor, angle, MELEERANGE, pitch, damage, NAME_Melee, NAME_BulletPuff, true);
// turn to face target // turn to face target
@ -89,8 +90,7 @@ void A_FirePistol (AActor *actor)
S_Sound (actor, CHAN_WEAPON, "weapons/pistol", 1, ATTN_NORM); S_Sound (actor, CHAN_WEAPON, "weapons/pistol", 1, ATTN_NORM);
P_BulletSlope (actor); P_GunShot (actor, accurate, PClass::FindClass(NAME_BulletPuff), P_BulletSlope (actor));
P_GunShot (actor, accurate, PClass::FindClass(NAME_BulletPuff));
} }
// //
@ -101,6 +101,7 @@ void A_Saw (AActor *actor)
angle_t angle; angle_t angle;
int damage=0; int damage=0;
player_t *player; player_t *player;
AActor *linetarget;
int fullsound; int fullsound;
int hitsound; int hitsound;
@ -140,7 +141,7 @@ void A_Saw (AActor *actor)
// use meleerange + 1 so the puff doesn't skip the flash (i.e. plays all states) // use meleerange + 1 so the puff doesn't skip the flash (i.e. plays all states)
P_LineAttack (actor, angle, MELEERANGE+1, P_LineAttack (actor, angle, MELEERANGE+1,
P_AimLineAttack (actor, angle, MELEERANGE+1), damage, P_AimLineAttack (actor, angle, MELEERANGE+1, &linetarget), damage,
GetDefaultByType(pufftype)->DamageType, pufftype); GetDefaultByType(pufftype)->DamageType, pufftype);
if (!linetarget) if (!linetarget)
@ -193,10 +194,10 @@ void A_FireShotgun (AActor *actor)
} }
player->mo->PlayAttacking2 (); player->mo->PlayAttacking2 ();
P_BulletSlope (actor); angle_t pitch = P_BulletSlope (actor);
for (i=0 ; i<7 ; i++) for (i=0 ; i<7 ; i++)
P_GunShot (actor, false, PClass::FindClass(NAME_BulletPuff)); P_GunShot (actor, false, PClass::FindClass(NAME_BulletPuff), pitch);
} }
// //
@ -225,7 +226,7 @@ void A_FireShotgun2 (AActor *actor)
player->mo->PlayAttacking2 (); player->mo->PlayAttacking2 ();
P_BulletSlope (actor); angle_t pitch = P_BulletSlope (actor);
for (i=0 ; i<20 ; i++) for (i=0 ; i<20 ; i++)
{ {
@ -242,7 +243,7 @@ void A_FireShotgun2 (AActor *actor)
P_LineAttack (actor, P_LineAttack (actor,
angle, angle,
PLAYERMISSILERANGE, PLAYERMISSILERANGE,
bulletpitch + (pr_fireshotgun2.Random2() * 332063), damage, pitch + (pr_fireshotgun2.Random2() * 332063), damage,
NAME_None, NAME_BulletPuff); NAME_None, NAME_BulletPuff);
} }
} }
@ -347,8 +348,7 @@ void A_FireCGun (AActor *actor)
} }
player->mo->PlayAttacking2 (); player->mo->PlayAttacking2 ();
P_BulletSlope (actor); P_GunShot (actor, !player->refire, PClass::FindClass(NAME_BulletPuff), P_BulletSlope (actor));
P_GunShot (actor, !player->refire, PClass::FindClass(NAME_BulletPuff));
} }
// //
@ -496,6 +496,7 @@ void A_BFGSpray (AActor *mo)
const PClass *spraytype = NULL; const PClass *spraytype = NULL;
int numrays = 40; int numrays = 40;
int damagecnt = 15; int damagecnt = 15;
AActor *linetarget;
int index = CheckIndex (3, NULL); int index = CheckIndex (3, NULL);
if (index >= 0) if (index >= 0)
@ -523,7 +524,7 @@ void A_BFGSpray (AActor *mo)
an = mo->angle - ANG90/2 + ANG90/numrays*i; an = mo->angle - ANG90/2 + ANG90/numrays*i;
// mo->target is the originator (player) of the missile // mo->target is the originator (player) of the missile
P_AimLineAttack (mo->target, an, 16*64*FRACUNIT, ANGLE_1*32); P_AimLineAttack (mo->target, an, 16*64*FRACUNIT, &linetarget, ANGLE_1*32);
if (!linetarget) if (!linetarget)
continue; continue;

9
src/g_doom/a_scriptedmarine.cpp
View file

@ -397,12 +397,13 @@ void A_M_Saw (AActor *self)
{ {
angle_t angle; angle_t angle;
int damage; int damage;
AActor *linetarget;
damage = 2 * (pr_m_saw()%10+1); damage = 2 * (pr_m_saw()%10+1);
angle = self->angle + (pr_m_saw.Random2() << 18); angle = self->angle + (pr_m_saw.Random2() << 18);
P_LineAttack (self, angle, MELEERANGE+1, P_LineAttack (self, angle, MELEERANGE+1,
P_AimLineAttack (self, angle, MELEERANGE+1), damage, P_AimLineAttack (self, angle, MELEERANGE+1, &linetarget), damage,
NAME_Melee, NAME_BulletPuff); NAME_Melee, NAME_BulletPuff);
if (!linetarget) if (!linetarget)
@ -447,6 +448,7 @@ void A_M_Punch (AActor *self)
angle_t angle; angle_t angle;
int damage; int damage;
int pitch; int pitch;
AActor *linetarget;
if (self->target == NULL) if (self->target == NULL)
return; return;
@ -455,7 +457,7 @@ void A_M_Punch (AActor *self)
A_FaceTarget (self); A_FaceTarget (self);
angle = self->angle + (pr_m_punch.Random2() << 18); angle = self->angle + (pr_m_punch.Random2() << 18);
pitch = P_AimLineAttack (self, angle, MELEERANGE); pitch = P_AimLineAttack (self, angle, MELEERANGE, &linetarget);
P_LineAttack (self, angle, MELEERANGE, pitch, damage, NAME_Melee, NAME_BulletPuff, true); P_LineAttack (self, angle, MELEERANGE, pitch, damage, NAME_Melee, NAME_BulletPuff, true);
// turn to face target // turn to face target
@ -477,6 +479,7 @@ void A_M_BerserkPunch (AActor *self)
angle_t angle; angle_t angle;
int damage; int damage;
int pitch; int pitch;
AActor *linetarget;
if (self->target == NULL) if (self->target == NULL)
return; return;
@ -485,7 +488,7 @@ void A_M_BerserkPunch (AActor *self)
A_FaceTarget (self); A_FaceTarget (self);
angle = self->angle + (pr_m_punch.Random2() << 18); angle = self->angle + (pr_m_punch.Random2() << 18);
pitch = P_AimLineAttack (self, angle, MELEERANGE); pitch = P_AimLineAttack (self, angle, MELEERANGE, &linetarget);
P_LineAttack (self, angle, MELEERANGE, pitch, damage, NAME_Melee, NAME_BulletPuff, true); P_LineAttack (self, angle, MELEERANGE, pitch, damage, NAME_Melee, NAME_BulletPuff, true);
// turn to face target // turn to face target

6
src/g_heretic/a_chicken.cpp
View file

@ -403,6 +403,7 @@ void A_BeakAttackPL1 (AActor *actor)
int damage; int damage;
int slope; int slope;
player_t *player; player_t *player;
AActor *linetarget;
if (NULL == (player = actor->player)) if (NULL == (player = actor->player))
{ {
@ -411,7 +412,7 @@ void A_BeakAttackPL1 (AActor *actor)
damage = 1 + (pr_beakatkpl1()&3); damage = 1 + (pr_beakatkpl1()&3);
angle = player->mo->angle; angle = player->mo->angle;
slope = P_AimLineAttack (player->mo, angle, MELEERANGE); slope = P_AimLineAttack (player->mo, angle, MELEERANGE, &linetarget);
P_LineAttack (player->mo, angle, MELEERANGE, slope, damage, NAME_Melee, RUNTIME_CLASS(ABeakPuff), true); P_LineAttack (player->mo, angle, MELEERANGE, slope, damage, NAME_Melee, RUNTIME_CLASS(ABeakPuff), true);
if (linetarget) if (linetarget)
{ {
@ -435,6 +436,7 @@ void A_BeakAttackPL2 (AActor *actor)
int damage; int damage;
int slope; int slope;
player_t *player; player_t *player;
AActor *linetarget;
if (NULL == (player = actor->player)) if (NULL == (player = actor->player))
{ {
@ -443,7 +445,7 @@ void A_BeakAttackPL2 (AActor *actor)
damage = pr_beakatkpl2.HitDice (4); damage = pr_beakatkpl2.HitDice (4);
angle = player->mo->angle; angle = player->mo->angle;
slope = P_AimLineAttack (player->mo, angle, MELEERANGE); slope = P_AimLineAttack (player->mo, angle, MELEERANGE, &linetarget);
P_LineAttack (player->mo, angle, MELEERANGE, slope, damage, NAME_Melee, RUNTIME_CLASS(ABeakPuff), true); P_LineAttack (player->mo, angle, MELEERANGE, slope, damage, NAME_Melee, RUNTIME_CLASS(ABeakPuff), true);
if (linetarget) if (linetarget)
{ {

33
src/g_heretic/a_hereticweaps.cpp
View file

@ -201,6 +201,7 @@ void A_StaffAttackPL1 (AActor *actor)
int damage; int damage;
int slope; int slope;
player_t *player; player_t *player;
AActor *linetarget;
if (NULL == (player = actor->player)) if (NULL == (player = actor->player))
{ {
@ -216,7 +217,7 @@ void A_StaffAttackPL1 (AActor *actor)
damage = 5+(pr_sap()&15); damage = 5+(pr_sap()&15);
angle = player->mo->angle; angle = player->mo->angle;
angle += pr_sap.Random2() << 18; angle += pr_sap.Random2() << 18;
slope = P_AimLineAttack (player->mo, angle, MELEERANGE); slope = P_AimLineAttack (player->mo, angle, MELEERANGE, &linetarget);
P_LineAttack (player->mo, angle, MELEERANGE, slope, damage, NAME_Melee, RUNTIME_CLASS(AStaffPuff), true); P_LineAttack (player->mo, angle, MELEERANGE, slope, damage, NAME_Melee, RUNTIME_CLASS(AStaffPuff), true);
if (linetarget) if (linetarget)
{ {
@ -239,6 +240,7 @@ void A_StaffAttackPL2 (AActor *actor)
int damage; int damage;
int slope; int slope;
player_t *player; player_t *player;
AActor *linetarget;
if (NULL == (player = actor->player)) if (NULL == (player = actor->player))
{ {
@ -255,7 +257,7 @@ void A_StaffAttackPL2 (AActor *actor)
damage = 18+(pr_sap2()&63); damage = 18+(pr_sap2()&63);
angle = player->mo->angle; angle = player->mo->angle;
angle += pr_sap2.Random2() << 18; angle += pr_sap2.Random2() << 18;
slope = P_AimLineAttack (player->mo, angle, MELEERANGE); slope = P_AimLineAttack (player->mo, angle, MELEERANGE, &linetarget);
P_LineAttack (player->mo, angle, MELEERANGE, slope, damage, NAME_Melee, RUNTIME_CLASS(AStaffPuff2), true); P_LineAttack (player->mo, angle, MELEERANGE, slope, damage, NAME_Melee, RUNTIME_CLASS(AStaffPuff2), true);
if (linetarget) if (linetarget)
{ {
@ -447,14 +449,14 @@ void A_FireGoldWandPL1 (AActor *actor)
if (!weapon->DepleteAmmo (weapon->bAltFire)) if (!weapon->DepleteAmmo (weapon->bAltFire))
return; return;
} }
P_BulletSlope(mo); angle_t pitch = P_BulletSlope(mo);
damage = 7+(pr_fgw()&7); damage = 7+(pr_fgw()&7);
angle = mo->angle; angle = mo->angle;
if (player->refire) if (player->refire)
{ {
angle += pr_fgw.Random2() << 18; angle += pr_fgw.Random2() << 18;
} }
P_LineAttack (mo, angle, PLAYERMISSILERANGE, bulletpitch, damage, NAME_None, RUNTIME_CLASS(AGoldWandPuff1)); P_LineAttack (mo, angle, PLAYERMISSILERANGE, pitch, damage, NAME_None, RUNTIME_CLASS(AGoldWandPuff1));
S_Sound (player->mo, CHAN_WEAPON, "weapons/wandhit", 1, ATTN_NORM); S_Sound (player->mo, CHAN_WEAPON, "weapons/wandhit", 1, ATTN_NORM);
} }
@ -485,16 +487,16 @@ void A_FireGoldWandPL2 (AActor *actor)
if (!weapon->DepleteAmmo (weapon->bAltFire)) if (!weapon->DepleteAmmo (weapon->bAltFire))
return; return;
} }
P_BulletSlope (mo); angle_t pitch = P_BulletSlope(mo);
momz = FixedMul (GetDefault<AGoldWandFX2>()->Speed, momz = FixedMul (GetDefault<AGoldWandFX2>()->Speed,
finetangent[FINEANGLES/4-((signed)bulletpitch>>ANGLETOFINESHIFT)]); finetangent[FINEANGLES/4-((signed)pitch>>ANGLETOFINESHIFT)]);
P_SpawnMissileAngle (mo, RUNTIME_CLASS(AGoldWandFX2), mo->angle-(ANG45/8), momz); P_SpawnMissileAngle (mo, RUNTIME_CLASS(AGoldWandFX2), mo->angle-(ANG45/8), momz);
P_SpawnMissileAngle (mo, RUNTIME_CLASS(AGoldWandFX2), mo->angle+(ANG45/8), momz); P_SpawnMissileAngle (mo, RUNTIME_CLASS(AGoldWandFX2), mo->angle+(ANG45/8), momz);
angle = mo->angle-(ANG45/8); angle = mo->angle-(ANG45/8);
for(i = 0; i < 5; i++) for(i = 0; i < 5; i++)
{ {
damage = 1+(pr_fgw2()&7); damage = 1+(pr_fgw2()&7);
P_LineAttack (mo, angle, PLAYERMISSILERANGE, bulletpitch, damage, NAME_None, RUNTIME_CLASS(AGoldWandPuff2)); P_LineAttack (mo, angle, PLAYERMISSILERANGE, pitch, damage, NAME_None, RUNTIME_CLASS(AGoldWandPuff2));
angle += ((ANG45/8)*2)/4; angle += ((ANG45/8)*2)/4;
} }
S_Sound (player->mo, CHAN_WEAPON, "weapons/wandhit", 1, ATTN_NORM); S_Sound (player->mo, CHAN_WEAPON, "weapons/wandhit", 1, ATTN_NORM);
@ -1339,6 +1341,7 @@ void A_FireMacePL2 (AActor *actor)
{ {
AActor *mo; AActor *mo;
player_t *player; player_t *player;
AActor *linetarget;
if (NULL == (player = actor->player)) if (NULL == (player = actor->player))
{ {
@ -1351,7 +1354,7 @@ void A_FireMacePL2 (AActor *actor)
if (!weapon->DepleteAmmo (weapon->bAltFire)) if (!weapon->DepleteAmmo (weapon->bAltFire))
return; return;
} }
mo = P_SpawnPlayerMissile (player->mo, RUNTIME_CLASS(AMaceFX4)); mo = P_SpawnPlayerMissile (player->mo, 0,0,0, RUNTIME_CLASS(AMaceFX4), 0, &linetarget);
if (mo) if (mo)
{ {
mo->momx += player->mo->momx; mo->momx += player->mo->momx;
@ -1378,6 +1381,7 @@ void A_DeathBallImpact (AActor *ball)
AActor *target; AActor *target;
angle_t angle = 0; angle_t angle = 0;
bool newAngle; bool newAngle;
AActor *linetarget;
if ((ball->z <= ball->floorz) && P_HitFloor (ball)) if ((ball->z <= ball->floorz) && P_HitFloor (ball))
{ // Landed in some sort of liquid { // Landed in some sort of liquid
@ -1424,7 +1428,7 @@ void A_DeathBallImpact (AActor *ball)
angle = 0; angle = 0;
for (i = 0; i < 16; i++) for (i = 0; i < 16; i++)
{ {
P_AimLineAttack (ball, angle, 10*64*FRACUNIT); P_AimLineAttack (ball, angle, 10*64*FRACUNIT, &linetarget);
if (linetarget && ball->target != linetarget) if (linetarget && ball->target != linetarget)
{ {
ball->tracer = linetarget; ball->tracer = linetarget;
@ -1624,6 +1628,7 @@ void A_GauntletAttack (AActor *actor)
player_t *player; player_t *player;
const PClass *pufftype; const PClass *pufftype;
AInventory *power; AInventory *power;
AActor *linetarget;
if (NULL == (player = actor->player)) if (NULL == (player = actor->player))
{ {
@ -1654,7 +1659,7 @@ void A_GauntletAttack (AActor *actor)
angle += pr_gatk.Random2() << 18; angle += pr_gatk.Random2() << 18;
pufftype = RUNTIME_CLASS(AGauntletPuff1); pufftype = RUNTIME_CLASS(AGauntletPuff1);
} }
slope = P_AimLineAttack (player->mo, angle, dist); slope = P_AimLineAttack (player->mo, angle, dist, &linetarget);
P_LineAttack (player->mo, angle, dist, slope, damage, NAME_Melee, pufftype); P_LineAttack (player->mo, angle, dist, slope, damage, NAME_Melee, pufftype);
if (!linetarget) if (!linetarget)
{ {
@ -1973,14 +1978,14 @@ void A_FireBlasterPL1 (AActor *actor)
if (!weapon->DepleteAmmo (weapon->bAltFire)) if (!weapon->DepleteAmmo (weapon->bAltFire))
return; return;
} }
P_BulletSlope(actor); angle_t pitch = P_BulletSlope(actor);
damage = pr_fb1.HitDice (4); damage = pr_fb1.HitDice (4);
angle = actor->angle; angle = actor->angle;
if (player->refire) if (player->refire)
{ {
angle += pr_fb1.Random2() << 18; angle += pr_fb1.Random2() << 18;
} }
P_LineAttack (actor, angle, PLAYERMISSILERANGE, bulletpitch, damage, NAME_None, RUNTIME_CLASS(ABlasterPuff)); P_LineAttack (actor, angle, PLAYERMISSILERANGE, pitch, damage, NAME_None, RUNTIME_CLASS(ABlasterPuff));
S_Sound (actor, CHAN_WEAPON, "weapons/blastershoot", 1, ATTN_NORM); S_Sound (actor, CHAN_WEAPON, "weapons/blastershoot", 1, ATTN_NORM);
} }
@ -2392,6 +2397,8 @@ void A_FireSkullRodPL1 (AActor *actor)
void A_FireSkullRodPL2 (AActor *actor) void A_FireSkullRodPL2 (AActor *actor)
{ {
player_t *player; player_t *player;
AActor *MissileActor;
AActor *linetarget;
if (NULL == (player = actor->player)) if (NULL == (player = actor->player))
{ {
@ -2403,7 +2410,7 @@ void A_FireSkullRodPL2 (AActor *actor)
if (!weapon->DepleteAmmo (weapon->bAltFire)) if (!weapon->DepleteAmmo (weapon->bAltFire))
return; return;
} }
P_SpawnPlayerMissile (player->mo, RUNTIME_CLASS(AHornRodFX2)); P_SpawnPlayerMissile (player->mo, 0,0,0, RUNTIME_CLASS(AHornRodFX2), 0, &linetarget, &MissileActor);
// Use MissileActor instead of the return value from // Use MissileActor instead of the return value from
// P_SpawnPlayerMissile because we need to give info to the mobj // P_SpawnPlayerMissile because we need to give info to the mobj
// even if it exploded immediately. // even if it exploded immediately.

3
src/g_hexen/a_clericholy.cpp
View file

@ -559,6 +559,7 @@ void SpawnSpiritTail (AActor *spirit)
void A_CHolyAttack (AActor *actor) void A_CHolyAttack (AActor *actor)
{ {
player_t *player; player_t *player;
AActor *linetarget;
if (NULL == (player = actor->player)) if (NULL == (player = actor->player))
{ {
@ -570,7 +571,7 @@ void A_CHolyAttack (AActor *actor)
if (!weapon->DepleteAmmo (weapon->bAltFire)) if (!weapon->DepleteAmmo (weapon->bAltFire))
return; return;
} }
AActor * missile = P_SpawnPlayerMissile (actor, RUNTIME_CLASS(AHolyMissile)); AActor * missile = P_SpawnPlayerMissile (actor, 0,0,0, RUNTIME_CLASS(AHolyMissile), 0, &linetarget);
if (missile != NULL) missile->tracer = linetarget; if (missile != NULL) missile->tracer = linetarget;
weapon->CHolyCount = 3; weapon->CHolyCount = 3;

13
src/g_hexen/a_clericmace.cpp
View file

@ -11,7 +11,7 @@
#include "gstrings.h" #include "gstrings.h"
#include "a_hexenglobal.h" #include "a_hexenglobal.h"
extern void AdjustPlayerAngle (AActor *pmo); extern void AdjustPlayerAngle (AActor *pmo, AActor *linetarget);
static FRandom pr_atk ("CMaceAttack"); static FRandom pr_atk ("CMaceAttack");
@ -81,6 +81,7 @@ void A_CMaceAttack (AActor *actor)
int slope; int slope;
int i; int i;
player_t *player; player_t *player;
AActor *linetarget;
if (NULL == (player = actor->player)) if (NULL == (player = actor->player))
{ {
@ -91,21 +92,21 @@ void A_CMaceAttack (AActor *actor)
for (i = 0; i < 16; i++) for (i = 0; i < 16; i++)
{ {
angle = player->mo->angle+i*(ANG45/16); angle = player->mo->angle+i*(ANG45/16);
slope = P_AimLineAttack (player->mo, angle, 2*MELEERANGE); slope = P_AimLineAttack (player->mo, angle, 2*MELEERANGE, &linetarget);
if (linetarget) if (linetarget)
{ {
P_LineAttack (player->mo, angle, 2*MELEERANGE, slope, damage, NAME_Melee, RUNTIME_CLASS(AHammerPuff), true); P_LineAttack (player->mo, angle, 2*MELEERANGE, slope, damage, NAME_Melee, RUNTIME_CLASS(AHammerPuff), true);
AdjustPlayerAngle (player->mo); AdjustPlayerAngle (player->mo, linetarget);
// player->mo->angle = R_PointToAngle2(player->mo->x, // player->mo->angle = R_PointToAngle2(player->mo->x,
// player->mo->y, linetarget->x, linetarget->y); // player->mo->y, linetarget->x, linetarget->y);
goto macedone; goto macedone;
} }
angle = player->mo->angle-i*(ANG45/16); angle = player->mo->angle-i*(ANG45/16);
slope = P_AimLineAttack (player->mo, angle, 2*MELEERANGE); slope = P_AimLineAttack (player->mo, angle, 2*MELEERANGE, &linetarget);
if (linetarget) if (linetarget)
{ {
P_LineAttack (player->mo, angle, 2*MELEERANGE, slope, damage, NAME_Melee, RUNTIME_CLASS(AHammerPuff), true); P_LineAttack (player->mo, angle, 2*MELEERANGE, slope, damage, NAME_Melee, RUNTIME_CLASS(AHammerPuff), true);
AdjustPlayerAngle (player->mo); AdjustPlayerAngle (player->mo, linetarget);
// player->mo->angle = R_PointToAngle2(player->mo->x, // player->mo->angle = R_PointToAngle2(player->mo->x,
// player->mo->y, linetarget->x, linetarget->y); // player->mo->y, linetarget->x, linetarget->y);
goto macedone; goto macedone;
@ -115,7 +116,7 @@ void A_CMaceAttack (AActor *actor)
player->mo->special1 = 0; player->mo->special1 = 0;
angle = player->mo->angle; angle = player->mo->angle;
slope = P_AimLineAttack (player->mo, angle, MELEERANGE); slope = P_AimLineAttack (player->mo, angle, MELEERANGE, &linetarget);
P_LineAttack (player->mo, angle, MELEERANGE, slope, damage, NAME_Melee, RUNTIME_CLASS(AHammerPuff)); P_LineAttack (player->mo, angle, MELEERANGE, slope, damage, NAME_Melee, RUNTIME_CLASS(AHammerPuff));
macedone: macedone:
return; return;

5
src/g_hexen/a_clericstaff.cpp
View file

@ -188,6 +188,7 @@ void A_CStaffCheck (AActor *actor)
int slope; int slope;
int i; int i;
player_t *player; player_t *player;
AActor *linetarget;
if (NULL == (player = actor->player)) if (NULL == (player = actor->player))
{ {
@ -200,7 +201,7 @@ void A_CStaffCheck (AActor *actor)
for (i = 0; i < 3; i++) for (i = 0; i < 3; i++)
{ {
angle = pmo->angle+i*(ANG45/16); angle = pmo->angle+i*(ANG45/16);
slope = P_AimLineAttack (pmo, angle, fixed_t(1.5*MELEERANGE)); slope = P_AimLineAttack (pmo, angle, fixed_t(1.5*MELEERANGE), &linetarget);
if (linetarget) if (linetarget)
{ {
P_LineAttack (pmo, angle, fixed_t(1.5*MELEERANGE), slope, damage, NAME_Melee, RUNTIME_CLASS(ACStaffPuff)); P_LineAttack (pmo, angle, fixed_t(1.5*MELEERANGE), slope, damage, NAME_Melee, RUNTIME_CLASS(ACStaffPuff));
@ -224,7 +225,7 @@ void A_CStaffCheck (AActor *actor)
break; break;
} }
angle = pmo->angle-i*(ANG45/16); angle = pmo->angle-i*(ANG45/16);
slope = P_AimLineAttack (player->mo, angle, fixed_t(1.5*MELEERANGE)); slope = P_AimLineAttack (player->mo, angle, fixed_t(1.5*MELEERANGE), &linetarget);
if (linetarget) if (linetarget)
{ {
P_LineAttack (pmo, angle, fixed_t(1.5*MELEERANGE), slope, damage, NAME_Melee, RUNTIME_CLASS(ACStaffPuff)); P_LineAttack (pmo, angle, fixed_t(1.5*MELEERANGE), slope, damage, NAME_Melee, RUNTIME_CLASS(ACStaffPuff));

13
src/g_hexen/a_fighteraxe.cpp
View file

@ -23,7 +23,7 @@ void A_FAxeCheckReadyG (AActor *actor);
void A_FAxeCheckUpG (AActor *actor); void A_FAxeCheckUpG (AActor *actor);
void A_FAxeAttack (AActor *actor); void A_FAxeAttack (AActor *actor);
extern void AdjustPlayerAngle (AActor *pmo); extern void AdjustPlayerAngle (AActor *pmo, AActor *linetarget);
EXTERN_CVAR (Int, cl_bloodtype) EXTERN_CVAR (Int, cl_bloodtype)
@ -323,6 +323,7 @@ void A_FAxeAttack (AActor *actor)
player_t *player; player_t *player;
AWeapon *weapon; AWeapon *weapon;
const PClass *pufftype; const PClass *pufftype;
AActor *linetarget;
if (NULL == (player = actor->player)) if (NULL == (player = actor->player))
{ {
@ -349,7 +350,7 @@ void A_FAxeAttack (AActor *actor)
for (i = 0; i < 16; i++) for (i = 0; i < 16; i++)
{ {
angle = pmo->angle+i*(ANG45/16); angle = pmo->angle+i*(ANG45/16);
slope = P_AimLineAttack (pmo, angle, AXERANGE); slope = P_AimLineAttack (pmo, angle, AXERANGE, &linetarget);
if (linetarget) if (linetarget)
{ {
P_LineAttack (pmo, angle, AXERANGE, slope, damage, NAME_Melee, pufftype, true); P_LineAttack (pmo, angle, AXERANGE, slope, damage, NAME_Melee, pufftype, true);
@ -357,12 +358,12 @@ void A_FAxeAttack (AActor *actor)
{ {
P_ThrustMobj (linetarget, angle, power); P_ThrustMobj (linetarget, angle, power);
} }
AdjustPlayerAngle (pmo); AdjustPlayerAngle (pmo, linetarget);
useMana++; useMana++;
goto axedone; goto axedone;
} }
angle = pmo->angle-i*(ANG45/16); angle = pmo->angle-i*(ANG45/16);
slope = P_AimLineAttack (pmo, angle, AXERANGE); slope = P_AimLineAttack (pmo, angle, AXERANGE, &linetarget);
if (linetarget) if (linetarget)
{ {
P_LineAttack (pmo, angle, AXERANGE, slope, damage, NAME_Melee, pufftype, true); P_LineAttack (pmo, angle, AXERANGE, slope, damage, NAME_Melee, pufftype, true);
@ -370,7 +371,7 @@ void A_FAxeAttack (AActor *actor)
{ {
P_ThrustMobj (linetarget, angle, power); P_ThrustMobj (linetarget, angle, power);
} }
AdjustPlayerAngle (pmo); AdjustPlayerAngle (pmo, linetarget);
useMana++; useMana++;
goto axedone; goto axedone;
} }
@ -379,7 +380,7 @@ void A_FAxeAttack (AActor *actor)
pmo->special1 = 0; pmo->special1 = 0;
angle = pmo->angle; angle = pmo->angle;
slope = P_AimLineAttack (pmo, angle, MELEERANGE); slope = P_AimLineAttack (pmo, angle, MELEERANGE, &linetarget);
P_LineAttack (pmo, angle, MELEERANGE, slope, damage, NAME_Melee, pufftype, true); P_LineAttack (pmo, angle, MELEERANGE, slope, damage, NAME_Melee, pufftype, true);
axedone: axedone:

13
src/g_hexen/a_fighterhammer.cpp
View file

@ -15,7 +15,7 @@ const fixed_t HAMMER_RANGE = MELEERANGE+MELEERANGE/2;
static FRandom pr_atk ("FHammerAtk"); static FRandom pr_atk ("FHammerAtk");
extern void AdjustPlayerAngle (AActor *pmo); extern void AdjustPlayerAngle (AActor *pmo, AActor *linetarget);
void A_FHammerAttack (AActor *actor); void A_FHammerAttack (AActor *actor);
void A_FHammerThrow (AActor *actor); void A_FHammerThrow (AActor *actor);
@ -179,6 +179,7 @@ void A_FHammerAttack (AActor *actor)
int slope; int slope;
int i; int i;
player_t *player; player_t *player;
AActor *linetarget;
if (NULL == (player = actor->player)) if (NULL == (player = actor->player))
{ {
@ -191,11 +192,11 @@ void A_FHammerAttack (AActor *actor)
for (i = 0; i < 16; i++) for (i = 0; i < 16; i++)
{ {
angle = pmo->angle + i*(ANG45/32); angle = pmo->angle + i*(ANG45/32);
slope = P_AimLineAttack (pmo, angle, HAMMER_RANGE); slope = P_AimLineAttack (pmo, angle, HAMMER_RANGE, &linetarget);
if (linetarget) if (linetarget)
{ {
P_LineAttack (pmo, angle, HAMMER_RANGE, slope, damage, NAME_Melee, RUNTIME_CLASS(AHammerPuff), true); P_LineAttack (pmo, angle, HAMMER_RANGE, slope, damage, NAME_Melee, RUNTIME_CLASS(AHammerPuff), true);
AdjustPlayerAngle(pmo); AdjustPlayerAngle(pmo, linetarget);
if (linetarget->flags3&MF3_ISMONSTER || linetarget->player) if (linetarget->flags3&MF3_ISMONSTER || linetarget->player)
{ {
P_ThrustMobj (linetarget, angle, power); P_ThrustMobj (linetarget, angle, power);
@ -204,11 +205,11 @@ void A_FHammerAttack (AActor *actor)
goto hammerdone; goto hammerdone;
} }
angle = pmo->angle-i*(ANG45/32); angle = pmo->angle-i*(ANG45/32);
slope = P_AimLineAttack(pmo, angle, HAMMER_RANGE); slope = P_AimLineAttack(pmo, angle, HAMMER_RANGE, &linetarget);
if(linetarget) if(linetarget)
{ {
P_LineAttack(pmo, angle, HAMMER_RANGE, slope, damage, NAME_Melee, RUNTIME_CLASS(AHammerPuff), true); P_LineAttack(pmo, angle, HAMMER_RANGE, slope, damage, NAME_Melee, RUNTIME_CLASS(AHammerPuff), true);
AdjustPlayerAngle(pmo); AdjustPlayerAngle(pmo, linetarget);
if (linetarget->flags3&MF3_ISMONSTER || linetarget->player) if (linetarget->flags3&MF3_ISMONSTER || linetarget->player)
{ {
P_ThrustMobj(linetarget, angle, power); P_ThrustMobj(linetarget, angle, power);
@ -219,7 +220,7 @@ void A_FHammerAttack (AActor *actor)
} }
// didn't find any targets in meleerange, so set to throw out a hammer // didn't find any targets in meleerange, so set to throw out a hammer
angle = pmo->angle; angle = pmo->angle;
slope = P_AimLineAttack (pmo, angle, HAMMER_RANGE); slope = P_AimLineAttack (pmo, angle, HAMMER_RANGE, &linetarget);
if (P_LineAttack (pmo, angle, HAMMER_RANGE, slope, damage, NAME_Melee, RUNTIME_CLASS(AHammerPuff), true) != NULL) if (P_LineAttack (pmo, angle, HAMMER_RANGE, slope, damage, NAME_Melee, RUNTIME_CLASS(AHammerPuff), true) != NULL)
{ {
pmo->special1 = false; pmo->special1 = false;

13
src/g_hexen/a_fighterplayer.cpp
View file

@ -109,7 +109,7 @@ static FRandom pr_fpatk ("FPunchAttack");
#define MAX_ANGLE_ADJUST (5*ANGLE_1) #define MAX_ANGLE_ADJUST (5*ANGLE_1)
void AdjustPlayerAngle (AActor *pmo) void AdjustPlayerAngle (AActor *pmo, AActor *linetarget)
{ {
angle_t angle; angle_t angle;
int difference; int difference;
@ -235,6 +235,7 @@ void A_FPunchAttack (AActor *actor)
int i; int i;
player_t *player; player_t *player;
const PClass *pufftype; const PClass *pufftype;
AActor *linetarget;
if (NULL == (player = actor->player)) if (NULL == (player = actor->player))
{ {
@ -248,7 +249,7 @@ void A_FPunchAttack (AActor *actor)
for (i = 0; i < 16; i++) for (i = 0; i < 16; i++)
{ {
angle = pmo->angle + i*(ANG45/16); angle = pmo->angle + i*(ANG45/16);
slope = P_AimLineAttack (pmo, angle, 2*MELEERANGE); slope = P_AimLineAttack (pmo, angle, 2*MELEERANGE, &linetarget);
if (linetarget) if (linetarget)
{ {
pmo->special1++; pmo->special1++;
@ -263,11 +264,11 @@ void A_FPunchAttack (AActor *actor)
{ {
P_ThrustMobj (linetarget, angle, power); P_ThrustMobj (linetarget, angle, power);
} }
AdjustPlayerAngle (pmo); AdjustPlayerAngle (pmo, linetarget);
goto punchdone; goto punchdone;
} }
angle = pmo->angle-i * (ANG45/16); angle = pmo->angle-i * (ANG45/16);
slope = P_AimLineAttack (pmo, angle, 2*MELEERANGE); slope = P_AimLineAttack (pmo, angle, 2*MELEERANGE, &linetarget);
if (linetarget) if (linetarget)
{ {
pmo->special1++; pmo->special1++;
@ -282,7 +283,7 @@ void A_FPunchAttack (AActor *actor)
{ {
P_ThrustMobj (linetarget, angle, power); P_ThrustMobj (linetarget, angle, power);
} }
AdjustPlayerAngle (pmo); AdjustPlayerAngle (pmo, linetarget);
goto punchdone; goto punchdone;
} }
} }
@ -290,7 +291,7 @@ void A_FPunchAttack (AActor *actor)
pmo->special1 = 0; pmo->special1 = 0;
angle = pmo->angle; angle = pmo->angle;
slope = P_AimLineAttack (pmo, angle, MELEERANGE); slope = P_AimLineAttack (pmo, angle, MELEERANGE, &linetarget);
P_LineAttack (pmo, angle, MELEERANGE, slope, damage, NAME_Melee, pufftype, true); P_LineAttack (pmo, angle, MELEERANGE, slope, damage, NAME_Melee, pufftype, true);
punchdone: punchdone:

3
src/g_hexen/a_magecone.cpp
View file

@ -159,6 +159,7 @@ void A_FireConePL1 (AActor *actor)
AActor *mo; AActor *mo;
bool conedone=false; bool conedone=false;
player_t *player; player_t *player;
AActor *linetarget;
if (NULL == (player = actor->player)) if (NULL == (player = actor->player))
{ {
@ -177,7 +178,7 @@ void A_FireConePL1 (AActor *actor)
for (i = 0; i < 16; i++) for (i = 0; i < 16; i++)
{ {
angle = actor->angle+i*(ANG45/16); angle = actor->angle+i*(ANG45/16);
slope = P_AimLineAttack (actor, angle, MELEERANGE); slope = P_AimLineAttack (actor, angle, MELEERANGE, &linetarget);
if (linetarget) if (linetarget)
{ {
P_DamageMobj (linetarget, actor, actor, damage, NAME_Ice); P_DamageMobj (linetarget, actor, actor, damage, NAME_Ice);

6
src/g_hexen/a_magestaff.cpp
View file

@ -387,9 +387,10 @@ void A_MStaffAttack2 (AActor *actor)
void MStaffSpawn (AActor *pmo, angle_t angle) void MStaffSpawn (AActor *pmo, angle_t angle)
{ {
AActor *mo; AActor *mo;
AActor *linetarget;
mo = P_SpawnPlayerMissile (pmo, 0, 0, 8*FRACUNIT, mo = P_SpawnPlayerMissile (pmo, 0, 0, 8*FRACUNIT,
RUNTIME_CLASS(AMageStaffFX2), angle); RUNTIME_CLASS(AMageStaffFX2), angle, &linetarget);
if (mo) if (mo)
{ {
mo->target = pmo; mo->target = pmo;
@ -407,6 +408,7 @@ void A_MStaffAttack (AActor *actor)
{ {
angle_t angle; angle_t angle;
player_t *player; player_t *player;
AActor *linetarget;
if (NULL == (player = actor->player)) if (NULL == (player = actor->player))
{ {
@ -422,7 +424,7 @@ void A_MStaffAttack (AActor *actor)
angle = actor->angle; angle = actor->angle;
// [RH] Let's try and actually track what the player aimed at // [RH] Let's try and actually track what the player aimed at
P_AimLineAttack (actor, angle, PLAYERMISSILERANGE, ANGLE_1*32); P_AimLineAttack (actor, angle, PLAYERMISSILERANGE, &linetarget, ANGLE_1*32);
if (linetarget == NULL) if (linetarget == NULL)
{ {
BlockCheckLine.x = actor->x; BlockCheckLine.x = actor->x;

11
src/g_hexen/a_magewand.cpp
View file

@ -124,7 +124,7 @@ void AMageWandMissile::Tick ()
PrevZ = z; PrevZ = z;
// [RH] Ripping is a little different than it was in Hexen // [RH] Ripping is a little different than it was in Hexen
DoRipping = true; FCheckPosition tm(!!(flags2 & MF2_RIP));
// Handle movement // Handle movement
if (momx || momy || (z != floorz) || momz) if (momx || momy || (z != floorz) || momz)
@ -137,11 +137,10 @@ void AMageWandMissile::Tick ()
{ {
if (changexy) if (changexy)
{ {
LastRipped = NULL; // [RH] Do rip damage each step, like Hexen tm.LastRipped = NULL; // [RH] Do rip damage each step, like Hexen
if (!P_TryMove (this, x+xfrac,y+yfrac, true)) if (!P_TryMove (this, x+xfrac,y+yfrac, true, false, tm))
{ // Blocked move { // Blocked move
P_ExplodeMissile (this, BlockingLine, BlockingMobj); P_ExplodeMissile (this, BlockingLine, BlockingMobj);
DoRipping = false;
return; return;
} }
} }
@ -151,14 +150,12 @@ void AMageWandMissile::Tick ()
z = floorz; z = floorz;
P_HitFloor (this); P_HitFloor (this);
P_ExplodeMissile (this, NULL, NULL); P_ExplodeMissile (this, NULL, NULL);
DoRipping = false;
return; return;
} }
if (z+height > ceilingz) if (z+height > ceilingz)
{ // Hit the ceiling { // Hit the ceiling
z = ceilingz-height; z = ceilingz-height;
P_ExplodeMissile (this, NULL, NULL); P_ExplodeMissile (this, NULL, NULL);
DoRipping = false;
return; return;
} }
if (changexy) if (changexy)
@ -175,7 +172,7 @@ void AMageWandMissile::Tick ()
} }
} }
} }
DoRipping = false;
// Advance the state // Advance the state
if (tics != -1) if (tics != -1)
{ {

7
src/g_hexen/a_pig.cpp
View file

@ -16,7 +16,7 @@ static FRandom pr_snoutattack ("SnoutAttack");
static FRandom pr_pigattack ("PigAttack"); static FRandom pr_pigattack ("PigAttack");
static FRandom pr_pigplayerthink ("PigPlayerThink"); static FRandom pr_pigplayerthink ("PigPlayerThink");
extern void AdjustPlayerAngle (AActor *); extern void AdjustPlayerAngle (AActor *, AActor *);
void A_SnoutAttack (AActor *actor); void A_SnoutAttack (AActor *actor);
@ -260,6 +260,7 @@ void A_SnoutAttack (AActor *actor)
int slope; int slope;
player_t *player; player_t *player;
AActor *puff; AActor *puff;
AActor *linetarget;
if (NULL == (player = actor->player)) if (NULL == (player = actor->player))
{ {
@ -268,12 +269,12 @@ void A_SnoutAttack (AActor *actor)
damage = 3+(pr_snoutattack()&3); damage = 3+(pr_snoutattack()&3);
angle = player->mo->angle; angle = player->mo->angle;
slope = P_AimLineAttack(player->mo, angle, MELEERANGE); slope = P_AimLineAttack(player->mo, angle, MELEERANGE, &linetarget);
puff = P_LineAttack(player->mo, angle, MELEERANGE, slope, damage, NAME_Melee, RUNTIME_CLASS(ASnoutPuff), true); puff = P_LineAttack(player->mo, angle, MELEERANGE, slope, damage, NAME_Melee, RUNTIME_CLASS(ASnoutPuff), true);
S_Sound(player->mo, CHAN_VOICE, "PigActive", 1, ATTN_NORM); S_Sound(player->mo, CHAN_VOICE, "PigActive", 1, ATTN_NORM);
if(linetarget) if(linetarget)
{ {
AdjustPlayerAngle(player->mo); AdjustPlayerAngle(player->mo, linetarget);
if(puff != NULL) if(puff != NULL)
{ // Bit something { // Bit something
S_Sound(player->mo, CHAN_VOICE, "PigAttack", 1, ATTN_NORM); S_Sound(player->mo, CHAN_VOICE, "PigAttack", 1, ATTN_NORM);

22
src/g_strife/a_strifeweapons.cpp
View file

@ -199,6 +199,7 @@ void A_JabDagger (AActor *actor)
int damage; int damage;
int pitch; int pitch;
int power; int power;
AActor *linetarget;
power = MIN(10, actor->player->stamina / 10); power = MIN(10, actor->player->stamina / 10);
damage = (pr_jabdagger() % (power + 8)) * (power + 2); damage = (pr_jabdagger() % (power + 8)) * (power + 2);
@ -209,7 +210,7 @@ void A_JabDagger (AActor *actor)
} }
angle = actor->angle + (pr_jabdagger.Random2() << 18); angle = actor->angle + (pr_jabdagger.Random2() << 18);
pitch = P_AimLineAttack (actor, angle, 80*FRACUNIT); pitch = P_AimLineAttack (actor, angle, 80*FRACUNIT, &linetarget);
P_LineAttack (actor, angle, 80*FRACUNIT, pitch, damage, NAME_Melee, RUNTIME_CLASS(AStrifeSpark), true); P_LineAttack (actor, angle, 80*FRACUNIT, pitch, damage, NAME_Melee, RUNTIME_CLASS(AStrifeSpark), true);
// turn to face target // turn to face target
@ -675,7 +676,7 @@ bool AAssaultGun::HandlePickup (AInventory *item)
// //
//============================================================================ //============================================================================
void P_StrifeGunShot (AActor *mo, bool accurate) void P_StrifeGunShot (AActor *mo, bool accurate, angle_t pitch)
{ {
angle_t angle; angle_t angle;
int damage; int damage;
@ -688,7 +689,7 @@ void P_StrifeGunShot (AActor *mo, bool accurate)
angle += pr_sgunshot.Random2() << (20 - mo->player->accuracy * 5 / 100); angle += pr_sgunshot.Random2() << (20 - mo->player->accuracy * 5 / 100);
} }
P_LineAttack (mo, angle, PLAYERMISSILERANGE, bulletpitch, damage, NAME_None, RUNTIME_CLASS(AStrifePuff)); P_LineAttack (mo, angle, PLAYERMISSILERANGE, pitch, damage, NAME_None, RUNTIME_CLASS(AStrifePuff));
} }
//============================================================================ //============================================================================
@ -719,8 +720,7 @@ void A_FireAssaultGun (AActor *self)
accurate = true; accurate = true;
} }
P_BulletSlope (self); P_StrifeGunShot (self, accurate, P_BulletSlope (self));
P_StrifeGunShot (self, accurate);
} }
// Standing variant of the assault gun -------------------------------------- // Standing variant of the assault gun --------------------------------------
@ -1303,13 +1303,13 @@ void A_FireMauler1 (AActor *self)
S_Sound (self, CHAN_WEAPON, "weapons/mauler1", 1, ATTN_NORM); S_Sound (self, CHAN_WEAPON, "weapons/mauler1", 1, ATTN_NORM);
P_BulletSlope (self); int bpitch = P_BulletSlope (self);
for (int i = 0; i < 20; ++i) for (int i = 0; i < 20; ++i)
{ {
int damage = 5 * (pr_mauler1() % 3 + 1); int damage = 5 * (pr_mauler1() % 3 + 1);
angle_t angle = self->angle + (pr_mauler1.Random2() << 19); angle_t angle = self->angle + (pr_mauler1.Random2() << 19);
int pitch = bulletpitch + (pr_mauler1.Random2() * 332063); int pitch = bpitch + (pr_mauler1.Random2() * 332063);
// Strife used a range of 2112 units for the mauler to signal that // Strife used a range of 2112 units for the mauler to signal that
// it should use a different puff. ZDoom's default range is longer // it should use a different puff. ZDoom's default range is longer
@ -2185,6 +2185,7 @@ void A_FireSigil1 (AActor *actor)
{ {
AActor *spot; AActor *spot;
player_t *player = actor->player; player_t *player = actor->player;
AActor *linetarget;
if (player == NULL || player->ReadyWeapon == NULL) if (player == NULL || player->ReadyWeapon == NULL)
return; return;
@ -2192,7 +2193,7 @@ void A_FireSigil1 (AActor *actor)
P_DamageMobj (actor, actor, NULL, 1*4, 0, DMG_NO_ARMOR); P_DamageMobj (actor, actor, NULL, 1*4, 0, DMG_NO_ARMOR);
S_Sound (actor, CHAN_WEAPON, "weapons/sigilcharge", 1, ATTN_NORM); S_Sound (actor, CHAN_WEAPON, "weapons/sigilcharge", 1, ATTN_NORM);
P_BulletSlope (actor); P_BulletSlope (actor, &linetarget);
if (linetarget != NULL) if (linetarget != NULL)
{ {
spot = Spawn<ASpectralLightningSpot> (linetarget->x, linetarget->y, ONFLOORZ, ALLOW_REPLACE); spot = Spawn<ASpectralLightningSpot> (linetarget->x, linetarget->y, ONFLOORZ, ALLOW_REPLACE);
@ -2283,6 +2284,7 @@ void A_FireSigil4 (AActor *actor)
{ {
AActor *spot; AActor *spot;
player_t *player = actor->player; player_t *player = actor->player;
AActor *linetarget;
if (player == NULL || player->ReadyWeapon == NULL) if (player == NULL || player->ReadyWeapon == NULL)
return; return;
@ -2290,10 +2292,10 @@ void A_FireSigil4 (AActor *actor)
P_DamageMobj (actor, actor, NULL, 4*4, 0, DMG_NO_ARMOR); P_DamageMobj (actor, actor, NULL, 4*4, 0, DMG_NO_ARMOR);
S_Sound (actor, CHAN_WEAPON, "weapons/sigilcharge", 1, ATTN_NORM); S_Sound (actor, CHAN_WEAPON, "weapons/sigilcharge", 1, ATTN_NORM);
P_BulletSlope (actor); P_BulletSlope (actor, &linetarget);
if (linetarget != NULL) if (linetarget != NULL)
{ {
spot = P_SpawnPlayerMissile (actor, RUNTIME_CLASS(ASpectralLightningBigV1)); spot = P_SpawnPlayerMissile (actor, 0,0,0, RUNTIME_CLASS(ASpectralLightningBigV1), 0, &linetarget);
if (spot != NULL) if (spot != NULL)
{ {
spot->tracer = linetarget; spot->tracer = linetarget;

4
src/p_enemy.cpp
View file

@ -349,11 +349,13 @@ bool AActor::SuggestMissileAttack (fixed_t dist)
bool P_HitFriend(AActor * self) bool P_HitFriend(AActor * self)
{ {
AActor *linetarget;
if (self->flags&MF_FRIENDLY && self->target != NULL) if (self->flags&MF_FRIENDLY && self->target != NULL)
{ {
angle_t angle = R_PointToAngle2 (self->x, self->y, self->target->x, self->target->y); angle_t angle = R_PointToAngle2 (self->x, self->y, self->target->x, self->target->y);
fixed_t dist = P_AproxDistance (self->x-self->target->x, self->y-self->target->y); fixed_t dist = P_AproxDistance (self->x-self->target->x, self->y-self->target->y);
P_AimLineAttack (self, angle, dist, 0, true); P_AimLineAttack (self, angle, dist, &linetarget, 0, true);
if (linetarget != NULL && linetarget != self->target) if (linetarget != NULL && linetarget != self->target)
{ {
return self->IsFriend (linetarget); return self->IsFriend (linetarget);

25
src/p_local.h
View file

@ -86,7 +86,6 @@ void P_UnPredictPlayer ();
#define FLOATRANDZ (FIXED_MAX-1) #define FLOATRANDZ (FIXED_MAX-1)
extern fixed_t FloatBobOffsets[64]; extern fixed_t FloatBobOffsets[64];
extern AActor *MissileActor;
APlayerPawn *P_SpawnPlayer (mapthing2_t* mthing, bool tempplayer=false); APlayerPawn *P_SpawnPlayer (mapthing2_t* mthing, bool tempplayer=false);
@ -120,7 +119,8 @@ AActor *P_SpawnMissileZAimed (AActor *source, fixed_t z, AActor *dest, const PCl
AActor *P_SpawnPlayerMissile (AActor* source, const PClass *type); AActor *P_SpawnPlayerMissile (AActor* source, const PClass *type);
AActor *P_SpawnPlayerMissile (AActor *source, const PClass *type, angle_t angle); AActor *P_SpawnPlayerMissile (AActor *source, const PClass *type, angle_t angle);
AActor *P_SpawnPlayerMissile (AActor *source, fixed_t x, fixed_t y, fixed_t z, const PClass *type, angle_t angle); AActor *P_SpawnPlayerMissile (AActor *source, fixed_t x, fixed_t y, fixed_t z, const PClass *type, angle_t angle,
AActor **pLineTarget = NULL, AActor **MissileActor = NULL);
void P_CheckFakeFloorTriggers (AActor *mo, fixed_t oldz, bool oldz_has_viewheight=false); void P_CheckFakeFloorTriggers (AActor *mo, fixed_t oldz, bool oldz_has_viewheight=false);
@ -345,6 +345,17 @@ struct FCheckPosition
bool touchmidtex; bool touchmidtex;
bool floatok; bool floatok;
line_t *ceilingline; line_t *ceilingline;
AActor *stepthing;
// [RH] These are used by PIT_CheckThing and P_XYMovement to apply
// ripping damage once per tic instead of once per move.
bool DoRipping;
AActor *LastRipped;
FCheckPosition(bool rip=false)
{
DoRipping = rip;
LastRipped = NULL;
}
}; };
@ -355,13 +366,9 @@ extern msecnode_t *sector_list; // phares 3/16/98
extern TArray<line_t *> spechit; extern TArray<line_t *> spechit;
// [RH] These are used by PIT_CheckThing and P_XYMovement to apply
// ripping damage once per tic instead of once per move.
extern bool DoRipping;
extern AActor *LastRipped;
bool P_TestMobjLocation (AActor *mobj); bool P_TestMobjLocation (AActor *mobj);
bool P_TestMobjZ (AActor *mobj, bool quick=true); bool P_TestMobjZ (AActor *mobj, bool quick=true, AActor **pOnmobj = NULL);
bool P_CheckPosition (AActor *thing, fixed_t x, fixed_t y, FCheckPosition &tm); bool P_CheckPosition (AActor *thing, fixed_t x, fixed_t y, FCheckPosition &tm);
bool P_CheckPosition (AActor *thing, fixed_t x, fixed_t y); bool P_CheckPosition (AActor *thing, fixed_t x, fixed_t y);
AActor *P_CheckOnmobj (AActor *thing); AActor *P_CheckOnmobj (AActor *thing);
@ -380,9 +387,7 @@ void P_FindFloorCeiling (AActor *actor);
bool P_ChangeSector (sector_t* sector, int crunch, int amt, int floorOrCeil, bool isreset); bool P_ChangeSector (sector_t* sector, int crunch, int amt, int floorOrCeil, bool isreset);
extern AActor* linetarget; // who got hit (or NULL) fixed_t P_AimLineAttack (AActor *t1, angle_t angle, fixed_t distance, AActor **pLineTarget = NULL, fixed_t vrange=0, bool forcenosmart=false);
fixed_t P_AimLineAttack (AActor *t1, angle_t angle, fixed_t distance, fixed_t vrange=0, bool forcenosmart=false);
AActor *P_LineAttack (AActor *t1, angle_t angle, fixed_t distance, int pitch, int damage, FName damageType, const PClass *pufftype, bool ismelee = false); AActor *P_LineAttack (AActor *t1, angle_t angle, fixed_t distance, int pitch, int damage, FName damageType, const PClass *pufftype, bool ismelee = false);
AActor *P_LineAttack (AActor *t1, angle_t angle, fixed_t distance, int pitch, int damage, FName damageType, FName pufftype, bool ismelee = false); AActor *P_LineAttack (AActor *t1, angle_t angle, fixed_t distance, int pitch, int damage, FName damageType, FName pufftype, bool ismelee = false);
void P_TraceBleed (int damage, fixed_t x, fixed_t y, fixed_t z, AActor *target, angle_t angle, int pitch); void P_TraceBleed (int damage, fixed_t x, fixed_t y, fixed_t z, AActor *target, angle_t angle, int pitch);

49
src/p_map.cpp
View file

@ -77,14 +77,9 @@ static FRandom pr_crunch ("DoCrunch");
// but don't process them until the move is proven valid // but don't process them until the move is proven valid
TArray<line_t *> spechit; TArray<line_t *> spechit;
AActor *onmobj; // generic global onmobj...used for landing on pods/players
// Temporary holder for thing_sectorlist threads // Temporary holder for thing_sectorlist threads
msecnode_t* sector_list = NULL; // phares 3/16/98 msecnode_t* sector_list = NULL; // phares 3/16/98
bool DoRipping;
AActor *LastRipped;
//========================================================================== //==========================================================================
// //
// PIT_FindFloorCeiling // PIT_FindFloorCeiling
@ -643,8 +638,6 @@ bool PIT_CheckLine (line_t *ld, const FBoundingBox &box, FCheckPosition &tm)
// //
//========================================================================== //==========================================================================
static AActor *stepthing;
bool PIT_CheckThing (AActor *thing, FCheckPosition &tm) bool PIT_CheckThing (AActor *thing, FCheckPosition &tm)
{ {
fixed_t topz; fixed_t topz;
@ -675,7 +668,7 @@ bool PIT_CheckThing (AActor *thing, FCheckPosition &tm)
// if (abs(thing->x - tmx) <= thing->radius && // if (abs(thing->x - tmx) <= thing->radius &&
// abs(thing->y - tmy) <= thing->radius) // abs(thing->y - tmy) <= thing->radius)
{ {
stepthing = thing; tm.stepthing = thing;
tm.floorz = topz; tm.floorz = topz;
} }
} }
@ -842,11 +835,11 @@ bool PIT_CheckThing (AActor *thing, FCheckPosition &tm)
{ {
return true; return true;
} }
if (DoRipping && !(thing->flags5 & MF5_DONTRIP)) if (tm.DoRipping && !(thing->flags5 & MF5_DONTRIP))
{ {
if (LastRipped != thing) if (tm.LastRipped != thing)
{ {
LastRipped = thing; tm.LastRipped = thing;
if (!(thing->flags & MF_NOBLOOD) && if (!(thing->flags & MF_NOBLOOD) &&
!(thing->flags2 & MF2_REFLECTIVE) && !(thing->flags2 & MF2_REFLECTIVE) &&
!(tm.thing->flags3 & MF3_BLOODLESSIMPACT) && !(tm.thing->flags3 & MF3_BLOODLESSIMPACT) &&
@ -1042,7 +1035,7 @@ bool P_CheckPosition (AActor *thing, fixed_t x, fixed_t y, FCheckPosition &tm)
thing->height = realheight + thing->MaxStepHeight; thing->height = realheight + thing->MaxStepHeight;
} }
stepthing = NULL; tm.stepthing = NULL;
FRadiusThingsIterator it2(x, y, thing->radius); FRadiusThingsIterator it2(x, y, thing->radius);
AActor *th; AActor *th;
@ -1125,7 +1118,7 @@ bool P_CheckPosition (AActor *thing, fixed_t x, fixed_t y, FCheckPosition &tm)
if (tm.ceilingz - tm.floorz < thing->height) if (tm.ceilingz - tm.floorz < thing->height)
return false; return false;
if (stepthing != NULL || tm.touchmidtex) if (tm.stepthing != NULL || tm.touchmidtex)
{ {
tm.dropoffz = thingdropoffz; tm.dropoffz = thingdropoffz;
} }
@ -1150,10 +1143,11 @@ AActor *P_CheckOnmobj (AActor *thing)
{ {
fixed_t oldz; fixed_t oldz;
bool good; bool good;
AActor *onmobj;
oldz = thing->z; oldz = thing->z;
P_FakeZMovement (thing); P_FakeZMovement (thing);
good = P_TestMobjZ (thing, false); good = P_TestMobjZ (thing, false, &onmobj);
thing->z = oldz; thing->z = oldz;
return good ? NULL : onmobj; return good ? NULL : onmobj;
@ -1165,11 +1159,14 @@ AActor *P_CheckOnmobj (AActor *thing)
// //
//============================================================================= //=============================================================================
bool P_TestMobjZ (AActor *actor, bool quick) bool P_TestMobjZ (AActor *actor, bool quick, AActor **pOnmobj)
{ {
onmobj = NULL; AActor *onmobj = NULL;
if (actor->flags & MF_NOCLIP) if (actor->flags & MF_NOCLIP)
{
if (pOnmobj) *pOnmobj = NULL;
return true; return true;
}
FRadiusThingsIterator it(actor->x, actor->y, actor->radius); FRadiusThingsIterator it(actor->x, actor->y, actor->radius);
AActor *thing; AActor *thing;
@ -1208,7 +1205,7 @@ bool P_TestMobjZ (AActor *actor, bool quick)
if (quick) break; if (quick) break;
} }
if (pOnmobj) *pOnmobj = onmobj;
return onmobj == NULL; return onmobj == NULL;
} }
@ -2306,7 +2303,6 @@ bool P_BounceWall (AActor *mo)
// Aiming // Aiming
// //
//============================================================================ //============================================================================
AActor* linetarget; // who got hit (or NULL)
struct aim_t struct aim_t
{ {
@ -2316,6 +2312,7 @@ struct aim_t
AActor* shootthing; AActor* shootthing;
fixed_t toppitch, bottompitch; fixed_t toppitch, bottompitch;
AActor * linetarget;
AActor * thing_friend, * thing_other; AActor * thing_friend, * thing_other;
angle_t pitch_friend, pitch_other; angle_t pitch_friend, pitch_other;
bool notsmart; bool notsmart;
@ -2460,7 +2457,7 @@ void aim_t::AimTraverse (fixed_t startx, fixed_t starty, fixed_t endx, fixed_t e
// P_AimLineAttack // P_AimLineAttack
// //
//============================================================================ //============================================================================
fixed_t P_AimLineAttack (AActor *t1, angle_t angle, fixed_t distance, fixed_t vrange, bool forcenosmart) fixed_t P_AimLineAttack (AActor *t1, angle_t angle, fixed_t distance, AActor **pLineTarget, fixed_t vrange, bool forcenosmart)
{ {
fixed_t x2; fixed_t x2;
fixed_t y2; fixed_t y2;
@ -2502,7 +2499,7 @@ fixed_t P_AimLineAttack (AActor *t1, angle_t angle, fixed_t distance, fixed_t vr
aim.notsmart = forcenosmart; aim.notsmart = forcenosmart;
aim.attackrange = distance; aim.attackrange = distance;
linetarget = NULL; aim.linetarget = NULL;
// for smart aiming // for smart aiming
aim.thing_friend=aim.thing_other=NULL; aim.thing_friend=aim.thing_other=NULL;
@ -2511,20 +2508,21 @@ fixed_t P_AimLineAttack (AActor *t1, angle_t angle, fixed_t distance, fixed_t vr
aim.aimpitch=t1->pitch; aim.aimpitch=t1->pitch;
aim.AimTraverse (t1->x, t1->y, x2, y2); aim.AimTraverse (t1->x, t1->y, x2, y2);
if (!linetarget) if (!aim.linetarget)
{ {
if (aim.thing_other) if (aim.thing_other)
{ {
linetarget=aim.thing_other; aim.linetarget=aim.thing_other;
aim.aimpitch=aim.pitch_other; aim.aimpitch=aim.pitch_other;
} }
else if (aim.thing_friend) else if (aim.thing_friend)
{ {
linetarget=aim.thing_friend; aim.linetarget=aim.thing_friend;
aim.aimpitch=aim.pitch_friend; aim.aimpitch=aim.pitch_friend;
} }
} }
return linetarget ? aim.aimpitch : t1->pitch; if (pLineTarget) *pLineTarget = aim.linetarget;
return aim.linetarget ? aim.aimpitch : t1->pitch;
} }
@ -4037,7 +4035,8 @@ void PIT_CeilingRaise (AActor *thing, FChangePosition *cpos)
} }
else if ((thing->flags2 & MF2_PASSMOBJ) && !isgood && thing->z + thing->height < thing->ceilingz) else if ((thing->flags2 & MF2_PASSMOBJ) && !isgood && thing->z + thing->height < thing->ceilingz)
{ {
if (!P_TestMobjZ (thing) && onmobj->z <= thing->z) AActor *onmobj;
if (!P_TestMobjZ (thing, true, &onmobj) && onmobj->z <= thing->z)
{ {
thing->z = MIN (thing->ceilingz - thing->height, thing->z = MIN (thing->ceilingz - thing->height,
onmobj->z + onmobj->height); onmobj->z + onmobj->height);

27
src/p_mobj.cpp
View file

@ -157,8 +157,6 @@ fixed_t FloatBobDiffs[64] =
CVAR (Int, cl_pufftype, 0, CVAR_ARCHIVE); CVAR (Int, cl_pufftype, 0, CVAR_ARCHIVE);
CVAR (Int, cl_bloodtype, 0, CVAR_ARCHIVE); CVAR (Int, cl_bloodtype, 0, CVAR_ARCHIVE);
AActor *MissileActor;
// CODE -------------------------------------------------------------------- // CODE --------------------------------------------------------------------
IMPLEMENT_POINTY_CLASS (AActor) IMPLEMENT_POINTY_CLASS (AActor)
@ -1508,11 +1506,7 @@ void P_XYMovement (AActor *mo, fixed_t scrollx, fixed_t scrolly)
// passes through more than one actor this tic, each one takes damage // passes through more than one actor this tic, each one takes damage
// and not just the first one. // and not just the first one.
if (mo->flags2 & MF2_RIP) FCheckPosition tm(!!(mo->flags2 & MF2_RIP));
{
DoRipping = true;
LastRipped = NULL;
}
do do
{ {
@ -1524,7 +1518,6 @@ void P_XYMovement (AActor *mo, fixed_t scrollx, fixed_t scrolly)
*/ */
// [RH] If walking on a slope, stay on the slope // [RH] If walking on a slope, stay on the slope
// killough 3/15/98: Allow objects to drop off // killough 3/15/98: Allow objects to drop off
FCheckPosition tm;
if (!P_TryMove (mo, ptryx, ptryy, true, walkplane, tm)) if (!P_TryMove (mo, ptryx, ptryy, true, walkplane, tm))
{ {
// blocked move // blocked move
@ -1631,13 +1624,11 @@ void P_XYMovement (AActor *mo, fixed_t scrollx, fixed_t scrolly)
{ {
S_SoundID (mo, CHAN_VOICE, mo->SeeSound, 1, ATTN_IDLE); S_SoundID (mo, CHAN_VOICE, mo->SeeSound, 1, ATTN_IDLE);
} }
DoRipping = false;
return; return;
} }
else else
{ // Struck a player/creature { // Struck a player/creature
P_ExplodeMissile (mo, NULL, BlockingMobj); P_ExplodeMissile (mo, NULL, BlockingMobj);
DoRipping = false;
return; return;
} }
} }
@ -1651,7 +1642,6 @@ void P_XYMovement (AActor *mo, fixed_t scrollx, fixed_t scrolly)
{ {
S_SoundID (mo, CHAN_VOICE, mo->SeeSound, 1, ATTN_IDLE); S_SoundID (mo, CHAN_VOICE, mo->SeeSound, 1, ATTN_IDLE);
} }
DoRipping = false;
return; return;
} }
} }
@ -1679,7 +1669,6 @@ void P_XYMovement (AActor *mo, fixed_t scrollx, fixed_t scrolly)
mo->tracer = mo->target; mo->tracer = mo->target;
} }
mo->target = BlockingMobj; mo->target = BlockingMobj;
DoRipping = false;
return; return;
} }
explode: explode:
@ -1693,18 +1682,15 @@ explode:
// Hack to prevent missiles exploding against the sky. // Hack to prevent missiles exploding against the sky.
// Does not handle sky floors. // Does not handle sky floors.
mo->Destroy (); mo->Destroy ();
DoRipping = false;
return; return;
} }
// [RH] Don't explode on horizon lines. // [RH] Don't explode on horizon lines.
if (mo->BlockingLine != NULL && mo->BlockingLine->special == Line_Horizon) if (mo->BlockingLine != NULL && mo->BlockingLine->special == Line_Horizon)
{ {
mo->Destroy (); mo->Destroy ();
DoRipping = false;
return; return;
} }
P_ExplodeMissile (mo, mo->BlockingLine, BlockingMobj); P_ExplodeMissile (mo, mo->BlockingLine, BlockingMobj);
DoRipping = false;
return; return;
} }
else else
@ -1734,8 +1720,6 @@ explode:
} }
} while (++step <= steps); } while (++step <= steps);
DoRipping = false;
// Friction // Friction
if (player && player->mo == mo && player->cheats & CF_NOMOMENTUM) if (player && player->mo == mo && player->cheats & CF_NOMOMENTUM)
@ -4726,19 +4710,20 @@ AActor *P_SpawnPlayerMissile (AActor *source, const PClass *type, angle_t angle)
} }
AActor *P_SpawnPlayerMissile (AActor *source, fixed_t x, fixed_t y, fixed_t z, AActor *P_SpawnPlayerMissile (AActor *source, fixed_t x, fixed_t y, fixed_t z,
const PClass *type, angle_t angle) const PClass *type, angle_t angle, AActor **pLineTarget, AActor **pMissileActor)
{ {
static const int angdiff[3] = { -1<<26, 1<<26, 0 }; static const int angdiff[3] = { -1<<26, 1<<26, 0 };
int i; int i;
angle_t an; angle_t an;
angle_t pitch; angle_t pitch;
AActor *linetarget;
// see which target is to be aimed at // see which target is to be aimed at
i = 2; i = 2;
do do
{ {
an = angle + angdiff[i]; an = angle + angdiff[i];
pitch = P_AimLineAttack (source, an, 16*64*FRACUNIT); pitch = P_AimLineAttack (source, an, 16*64*FRACUNIT, &linetarget);
if (source->player != NULL && if (source->player != NULL &&
level.IsFreelookAllowed() && level.IsFreelookAllowed() &&
@ -4752,6 +4737,7 @@ AActor *P_SpawnPlayerMissile (AActor *source, fixed_t x, fixed_t y, fixed_t z,
{ {
an = angle; an = angle;
} }
if (pLineTarget) *pLineTarget = linetarget;
i = GetDefaultByType (type)->flags3; i = GetDefaultByType (type)->flags3;
@ -4781,7 +4767,8 @@ AActor *P_SpawnPlayerMissile (AActor *source, fixed_t x, fixed_t y, fixed_t z,
z = source->floorz; z = source->floorz;
} }
} }
MissileActor = Spawn (type, source->x + x, source->y + y, z, ALLOW_REPLACE); AActor *MissileActor = Spawn (type, source->x + x, source->y + y, z, ALLOW_REPLACE);
if (pMissileActor) *pMissileActor = MissileActor;
P_PlaySpawnSound(MissileActor, source); P_PlaySpawnSound(MissileActor, source);
MissileActor->target = source; MissileActor->target = source;
MissileActor->angle = an; MissileActor->angle = an;

13
src/p_pspr.cpp
View file

@ -45,8 +45,6 @@
// PUBLIC DATA DEFINITIONS ------------------------------------------------- // PUBLIC DATA DEFINITIONS -------------------------------------------------
angle_t bulletpitch;
// [SO] 1=Weapons states are all 1 tick // [SO] 1=Weapons states are all 1 tick
// 2=states with a function 1 tick, others 0 ticks. // 2=states with a function 1 tick, others 0 ticks.
CVAR(Int, sv_fastweapons, false, CVAR_SERVERINFO); CVAR(Int, sv_fastweapons, false, CVAR_SERVERINFO);
@ -632,18 +630,20 @@ void A_GunFlash (AActor *actor)
// the height of the intended target // the height of the intended target
// //
void P_BulletSlope (AActor *mo) angle_t P_BulletSlope (AActor *mo, AActor **pLineTarget)
{ {
static const int angdiff[3] = { -1<<26, 1<<26, 0 }; static const int angdiff[3] = { -1<<26, 1<<26, 0 };
int i; int i;
angle_t an; angle_t an;
angle_t pitch;
AActor *linetarget;
// see which target is to be aimed at // see which target is to be aimed at
i = 2; i = 2;
do do
{ {
an = mo->angle + angdiff[i]; an = mo->angle + angdiff[i];
bulletpitch = P_AimLineAttack (mo, an, 16*64*FRACUNIT); pitch = P_AimLineAttack (mo, an, 16*64*FRACUNIT, &linetarget);
if (mo->player != NULL && if (mo->player != NULL &&
level.IsFreelookAllowed() && level.IsFreelookAllowed() &&
@ -652,13 +652,14 @@ void P_BulletSlope (AActor *mo)
break; break;
} }
} while (linetarget == NULL && --i >= 0); } while (linetarget == NULL && --i >= 0);
return pitch;
} }
// //
// P_GunShot // P_GunShot
// //
void P_GunShot (AActor *mo, bool accurate, const PClass *pufftype) void P_GunShot (AActor *mo, bool accurate, const PClass *pufftype, angle_t pitch)
{ {
angle_t angle; angle_t angle;
int damage; int damage;
@ -671,7 +672,7 @@ void P_GunShot (AActor *mo, bool accurate, const PClass *pufftype)
angle += pr_gunshot.Random2 () << 18; angle += pr_gunshot.Random2 () << 18;
} }
P_LineAttack (mo, angle, PLAYERMISSILERANGE, bulletpitch, damage, NAME_None, pufftype); P_LineAttack (mo, angle, PLAYERMISSILERANGE, pitch, damage, NAME_None, pufftype);
} }
void A_Light0 (AActor *actor) void A_Light0 (AActor *actor)

6
src/p_pspr.h
View file

@ -90,8 +90,8 @@ void P_BringUpWeapon (player_s *player);
void P_FireWeapon (player_s *player); void P_FireWeapon (player_s *player);
void P_DropWeapon (player_s *player); void P_DropWeapon (player_s *player);
void P_BobWeapon (player_s *player, pspdef_t *psp, fixed_t *x, fixed_t *y); void P_BobWeapon (player_s *player, pspdef_t *psp, fixed_t *x, fixed_t *y);
void P_BulletSlope (AActor *mo); angle_t P_BulletSlope (AActor *mo, AActor **pLineTarget = NULL);
void P_GunShot (AActor *mo, bool accurate, const PClass *pufftype); void P_GunShot (AActor *mo, bool accurate, const PClass *pufftype, angle_t pitch);
void A_WeaponReady (AActor *actor); void A_WeaponReady (AActor *actor);
void A_ReFire (AActor *actor); void A_ReFire (AActor *actor);
@ -103,6 +103,4 @@ void A_Light0 (AActor *actor);
void A_Light1 (AActor *actor); void A_Light1 (AActor *actor);
void A_Light2 (AActor *actor); void A_Light2 (AActor *actor);
extern angle_t bulletpitch;
#endif // __P_PSPR_H__ #endif // __P_PSPR_H__

15
src/thingdef/thingdef_codeptr.cpp
View file

@ -540,8 +540,7 @@ void A_JumpIfCloser(AActor * self)
else else
{ {
// Does the player aim at something that can be shot? // Does the player aim at something that can be shot?
P_BulletSlope(self); P_BulletSlope(self, &target);
target = linetarget;
} }
if (pStateCall != NULL) pStateCall->Result=false; // Jumps should never set the result for inventory state chains! if (pStateCall != NULL) pStateCall->Result=false; // Jumps should never set the result for inventory state chains!
@ -1016,9 +1015,8 @@ void A_FireBullets (AActor *self)
static_cast<APlayerPawn *>(self)->PlayAttacking2 (); static_cast<APlayerPawn *>(self)->PlayAttacking2 ();
P_BulletSlope(self); bslope = P_BulletSlope(self);
bangle = self->angle; bangle = self->angle;
bslope = bulletpitch;
PuffType = PClass::FindClass(PuffTypeName); PuffType = PClass::FindClass(PuffTypeName);
if (!PuffType) PuffType = PClass::FindClass(NAME_BulletPuff); if (!PuffType) PuffType = PClass::FindClass(NAME_BulletPuff);
@ -1063,6 +1061,7 @@ void A_FireCustomMissile (AActor * self)
player_t *player=self->player; player_t *player=self->player;
AWeapon * weapon=player->ReadyWeapon; AWeapon * weapon=player->ReadyWeapon;
AActor *linetarget;
if (UseAmmo && weapon) if (UseAmmo && weapon)
{ {
@ -1080,7 +1079,7 @@ void A_FireCustomMissile (AActor * self)
if (AimAtAngle) shootangle+=Angle; if (AimAtAngle) shootangle+=Angle;
AActor * misl=P_SpawnPlayerMissile (self, x, y, z, ti, shootangle); AActor * misl=P_SpawnPlayerMissile (self, x, y, z, ti, shootangle, &linetarget);
// automatic handling of seeker missiles // automatic handling of seeker missiles
if (misl) if (misl)
{ {
@ -1129,12 +1128,13 @@ void A_CustomPunch (AActor *self)
angle_t angle; angle_t angle;
int pitch; int pitch;
AActor * linetarget;
if (!norandom) Damage *= (pr_cwpunch()%8+1); if (!norandom) Damage *= (pr_cwpunch()%8+1);
angle = self->angle + (pr_cwpunch.Random2() << 18); angle = self->angle + (pr_cwpunch.Random2() << 18);
if (Range == 0) Range = MELEERANGE; if (Range == 0) Range = MELEERANGE;
pitch = P_AimLineAttack (self, angle, Range); pitch = P_AimLineAttack (self, angle, Range, &linetarget);
// only use ammo when actually hitting something! // only use ammo when actually hitting something!
if (UseAmmo && linetarget && weapon) if (UseAmmo && linetarget && weapon)
@ -2164,8 +2164,7 @@ void A_JumpIfTargetInLOS(AActor * self)
else else
{ {
// Does the player aim at something that can be shot? // Does the player aim at something that can be shot?
P_BulletSlope(self); P_BulletSlope(self, &target);
target = linetarget;
} }
// No target - return // No target - return