zdoom/gzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom.git synced 2024-11-10 23:01:50 +00:00
Code Issues Projects Releases Packages Wiki Activity

- fixed some leftover unused variable warnings.

Browse source 
- match the variable names in thingdef_codeptr.cpp to the ones in the scripting branch to reduce the amount of merge conflicts in upcoming changes.
This commit is contained in:
Christoph Oelckers 2016-01-19 16:09:44 +01:00
parent 27aeb6a656
commit 97620b0645
5 changed files with 289 additions and 258 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/g_raven/a_minotaur.cpp
View file

@ -367,7 +367,6 @@ DEFINE_ACTION_FUNCTION(AActor, A_MinotaurAtk3)
DEFINE_ACTION_FUNCTION(AActor, A_MntrFloorFire) DEFINE_ACTION_FUNCTION(AActor, A_MntrFloorFire)
{ {
AActor *mo; AActor *mo;
fixed_t x, y;
self->SetZ(self->floorz); self->SetZ(self->floorz);
fixedvec2 pos = self->Vec2Offset( fixedvec2 pos = self->Vec2Offset(

2
src/g_shared/a_debris.cpp
View file

@ -31,10 +31,8 @@ IMPLEMENT_CLASS(AGlassShard)
void P_SpawnDirt (AActor *actor, fixed_t radius) void P_SpawnDirt (AActor *actor, fixed_t radius)
{ {
fixed_t x,y,z;
const PClass *dtype = NULL; const PClass *dtype = NULL;
AActor *mo; AActor *mo;
angle_t angle;
fixedvec3 pos = actor->Vec3Angle(radius, pr_dirt() << 24, (pr_dirt() << 9) + FRACUNIT); fixedvec3 pos = actor->Vec3Angle(radius, pr_dirt() << 24, (pr_dirt() << 9) + FRACUNIT);

1
src/g_strife/a_spectral.cpp
View file

@ -53,7 +53,6 @@ static FRandom pr_zap5 ("Zap5");
DEFINE_ACTION_FUNCTION(AActor, A_SpectralLightning) DEFINE_ACTION_FUNCTION(AActor, A_SpectralLightning)
{ {
AActor *flash; AActor *flash;
fixed_t x, y;
if (self->threshold != 0) if (self->threshold != 0)
--self->threshold; --self->threshold;

2
src/g_strife/a_thingstoblowup.cpp
View file

@ -18,8 +18,6 @@ extern const PClass *QuestItemClasses[31];
DEFINE_ACTION_FUNCTION(AActor, A_Bang4Cloud) DEFINE_ACTION_FUNCTION(AActor, A_Bang4Cloud)
{ {
fixed_t spawnx, spawny;
fixedvec3 pos = self->Vec3Offset((pr_bang4cloud.Random2() & 3) * 10240, (pr_bang4cloud.Random2() & 3) * 10240, 0); fixedvec3 pos = self->Vec3Offset((pr_bang4cloud.Random2() & 3) * 10240, (pr_bang4cloud.Random2() & 3) * 10240, 0);
Spawn("Bang4Cloud", pos, ALLOW_REPLACE); Spawn("Bang4Cloud", pos, ALLOW_REPLACE);

489
src/thingdef/thingdef_codeptr.cpp
View file

@ -235,27 +235,27 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_TransferPointer)
{ {
ACTION_PARAM_START(5); ACTION_PARAM_START(5);
ACTION_PARAM_INT(ptr_source, 0); ACTION_PARAM_INT(ptr_source, 0);
ACTION_PARAM_INT(ptr_recepient, 1); ACTION_PARAM_INT(ptr_recipient, 1);
ACTION_PARAM_INT(ptr_sourcefield, 2); ACTION_PARAM_INT(ptr_sourcefield, 2);
ACTION_PARAM_INT(ptr_recepientfield, 3); ACTION_PARAM_INT(ptr_recipientfield, 3);
ACTION_PARAM_INT(flags, 4); ACTION_PARAM_INT(flags, 4);
AActor *source, *recepient; AActor *source, *recipient;
// Exchange pointers with actors to whom you have pointers (or with yourself, if you must) // Exchange pointers with actors to whom you have pointers (or with yourself, if you must)
source = COPY_AAPTR(self, ptr_source); source = COPY_AAPTR(self, ptr_source);
COPY_AAPTR_NOT_NULL(self, recepient, ptr_recepient); // pick an actor to store the provided pointer value COPY_AAPTR_NOT_NULL(self, recipient, ptr_recipient); // pick an actor to store the provided pointer value
// convert source from dataprovider to data // convert source from dataprovider to data
source = COPY_AAPTR(source, ptr_sourcefield); source = COPY_AAPTR(source, ptr_sourcefield);
if (source == recepient) source = NULL; // The recepient should not acquire a pointer to itself; will write NULL if (source == recipient) source = NULL; // The recipient should not acquire a pointer to itself; will write NULL
if (ptr_recepientfield == AAPTR_DEFAULT) ptr_recepientfield = ptr_sourcefield; // If default: Write to same field as data was read from if (ptr_recipientfield == AAPTR_DEFAULT) ptr_recipientfield = ptr_sourcefield; // If default: Write to same field as data was read from
ASSIGN_AAPTR(recepient, ptr_recepientfield, source, flags); ASSIGN_AAPTR(recipient, ptr_recipientfield, source, flags);
} }
//========================================================================== //==========================================================================
@ -913,9 +913,9 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomMissile)
{ {
ACTION_PARAM_START(7); ACTION_PARAM_START(7);
ACTION_PARAM_CLASS(ti, 0); ACTION_PARAM_CLASS(ti, 0);
ACTION_PARAM_FIXED(SpawnHeight, 1); ACTION_PARAM_FIXED(spawnheight, 1);
ACTION_PARAM_INT(Spawnofs_XY, 2); ACTION_PARAM_INT(spawnofs_xy, 2);
ACTION_PARAM_ANGLE(Angle, 3); ACTION_PARAM_ANGLE(angle, 3);
ACTION_PARAM_INT(flags, 4); ACTION_PARAM_INT(flags, 4);
ACTION_PARAM_ANGLE(pitch, 5); ACTION_PARAM_ANGLE(pitch, 5);
ACTION_PARAM_INT(ptr, 6); ACTION_PARAM_INT(ptr, 6);
@ -932,9 +932,9 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomMissile)
if (ti) if (ti)
{ {
angle_t ang = (self->angle - ANGLE_90) >> ANGLETOFINESHIFT; angle_t ang = (self->angle - ANGLE_90) >> ANGLETOFINESHIFT;
fixed_t x = Spawnofs_XY * finecosine[ang]; fixed_t x = spawnofs_xy * finecosine[ang];
fixed_t y = Spawnofs_XY * finesine[ang]; fixed_t y = spawnofs_xy * finesine[ang];
fixed_t z = SpawnHeight + self->GetBobOffset() - 32*FRACUNIT + (self->player? self->player->crouchoffset : 0); fixed_t z = spawnheight + self->GetBobOffset() - 32*FRACUNIT + (self->player? self->player->crouchoffset : 0);
switch (aimmode) switch (aimmode)
{ {
@ -951,13 +951,13 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomMissile)
break; break;
case 1: case 1:
missile = P_SpawnMissileXYZ(self->x+x, self->y+y, self->z + self->GetBobOffset() + SpawnHeight, self, ref, ti, false); missile = P_SpawnMissileXYZ(self->x+x, self->y+y, self->z + self->GetBobOffset() + spawnheight, self, ref, ti, false);
break; break;
case 2: case 2:
self->x += x; self->x += x;
self->y += y; self->y += y;
missile = P_SpawnMissileAngleZSpeed(self, self->z + self->GetBobOffset() + SpawnHeight, ti, self->angle, 0, GetDefaultByType(ti)->Speed, self, false); missile = P_SpawnMissileAngleZSpeed(self, self->z + self->GetBobOffset() + spawnheight, ti, self->angle, 0, GetDefaultByType(ti)->Speed, self, false);
self->x -= x; self->x -= x;
self->y -= y; self->y -= y;
@ -966,7 +966,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomMissile)
break; break;
} }
if (missile) if (missile != NULL)
{ {
// Use the actual velocity instead of the missile's Speed property // Use the actual velocity instead of the missile's Speed property
// so that this can handle missiles with a high vertical velocity // so that this can handle missiles with a high vertical velocity
@ -999,7 +999,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomMissile)
// otherwise affecting the spawned actor. // otherwise affecting the spawned actor.
} }
missile->angle = (CMF_ABSOLUTEANGLE & flags) ? Angle : missile->angle + Angle ; missile->angle = (CMF_ABSOLUTEANGLE & flags) ? angle : missile->angle + angle ;
ang = missile->angle >> ANGLETOFINESHIFT; ang = missile->angle >> ANGLETOFINESHIFT;
missile->velx = FixedMul(missilespeed, finecosine[ang]); missile->velx = FixedMul(missilespeed, finecosine[ang]);
@ -1010,7 +1010,8 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomMissile)
if (self->isMissile(!!(flags & CMF_TRACKOWNER))) if (self->isMissile(!!(flags & CMF_TRACKOWNER)))
{ {
AActor *owner = self ;//->target; AActor *owner = self ;//->target;
while (owner->isMissile(!!(flags & CMF_TRACKOWNER)) && owner->target) owner=owner->target; while (owner->isMissile(!!(flags & CMF_TRACKOWNER)) && owner->target)
owner = owner->target;
targ = owner; targ = owner;
missile->target = owner; missile->target = owner;
// automatic handling of seeker missiles // automatic handling of seeker missiles
@ -1043,7 +1044,8 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomMissile)
else if (flags & CMF_CHECKTARGETDEAD) else if (flags & CMF_CHECKTARGETDEAD)
{ {
// Target is dead and the attack shall be aborted. // Target is dead and the attack shall be aborted.
if (self->SeeState != NULL && (self->health > 0 || !(self->flags3 & MF3_ISMONSTER))) self->SetState(self->SeeState); if (self->SeeState != NULL && (self->health > 0 || !(self->flags3 & MF3_ISMONSTER)))
self->SetState(self->SeeState);
} }
} }
@ -1064,27 +1066,28 @@ enum CBA_Flags
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomBulletAttack) DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomBulletAttack)
{ {
ACTION_PARAM_START(8); ACTION_PARAM_START(8);
ACTION_PARAM_ANGLE(Spread_XY, 0); ACTION_PARAM_ANGLE(spread_xy, 0);
ACTION_PARAM_ANGLE(Spread_Z, 1); ACTION_PARAM_ANGLE(spread_z, 1);
ACTION_PARAM_INT(NumBullets, 2); ACTION_PARAM_INT(numbullets, 2);
ACTION_PARAM_INT(DamagePerBullet, 3); ACTION_PARAM_INT(damageperbullet, 3);
ACTION_PARAM_CLASS(pufftype, 4); ACTION_PARAM_CLASS(pufftype, 4);
ACTION_PARAM_FIXED(Range, 5); ACTION_PARAM_FIXED(range, 5);
ACTION_PARAM_INT(Flags, 6); ACTION_PARAM_INT(flags, 6);
ACTION_PARAM_INT(ptr, 7); ACTION_PARAM_INT(ptr, 7);
AActor *ref = COPY_AAPTR(self, ptr); AActor *ref = COPY_AAPTR(self, ptr);
if(Range==0) Range=MISSILERANGE; if (range == 0)
range = MISSILERANGE;
int i; int i;
int bangle; int bangle;
int bslope = 0; int bslope = 0;
int laflags = (Flags & CBAF_NORANDOMPUFFZ)? LAF_NORANDOMPUFFZ : 0; int laflags = (flags & CBAF_NORANDOMPUFFZ)? LAF_NORANDOMPUFFZ : 0;
if (ref || (Flags & CBAF_AIMFACING)) if (ref != NULL || (flags & CBAF_AIMFACING))
{ {
if (!(Flags & CBAF_AIMFACING)) if (!(flags & CBAF_AIMFACING))
{ {
A_Face(self, ref); A_Face(self, ref);
} }
@ -1092,31 +1095,31 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomBulletAttack)
if (!pufftype) pufftype = PClass::FindClass(NAME_BulletPuff); if (!pufftype) pufftype = PClass::FindClass(NAME_BulletPuff);
if (!(Flags & CBAF_NOPITCH)) bslope = P_AimLineAttack (self, bangle, MISSILERANGE); if (!(flags & CBAF_NOPITCH)) bslope = P_AimLineAttack (self, bangle, MISSILERANGE);
S_Sound (self, CHAN_WEAPON, self->AttackSound, 1, ATTN_NORM); S_Sound (self, CHAN_WEAPON, self->AttackSound, 1, ATTN_NORM);
for (i=0 ; i<NumBullets ; i++) for (i = 0; i < numbullets; i++)
{ {
int angle = bangle; int angle = bangle;
int slope = bslope; int slope = bslope;
if (Flags & CBAF_EXPLICITANGLE) if (flags & CBAF_EXPLICITANGLE)
{ {
angle += Spread_XY; angle += spread_xy;
slope += Spread_Z; slope += spread_z;
} }
else else
{ {
angle += pr_cwbullet.Random2() * (Spread_XY / 255); angle += pr_cwbullet.Random2() * (spread_xy / 255);
slope += pr_cwbullet.Random2() * (Spread_Z / 255); slope += pr_cwbullet.Random2() * (spread_z / 255);
} }
int damage = DamagePerBullet; int damage = damageperbullet;
if (!(Flags & CBAF_NORANDOM)) if (!(flags & CBAF_NORANDOM))
damage *= ((pr_cabullet()%3)+1); damage *= ((pr_cabullet()%3)+1);
P_LineAttack(self, angle, Range, slope, damage, NAME_Hitscan, pufftype, laflags); P_LineAttack(self, angle, range, slope, damage, NAME_Hitscan, pufftype, laflags);
} }
} }
} }
@ -1130,12 +1133,13 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomMeleeAttack)
{ {
ACTION_PARAM_START(5); ACTION_PARAM_START(5);
ACTION_PARAM_INT(damage, 0); ACTION_PARAM_INT(damage, 0);
ACTION_PARAM_SOUND(MeleeSound, 1); ACTION_PARAM_SOUND(meleesound, 1);
ACTION_PARAM_SOUND(MissSound, 2); ACTION_PARAM_SOUND(misssound, 2);
ACTION_PARAM_NAME(DamageType, 3); ACTION_PARAM_NAME(damagetype, 3);
ACTION_PARAM_BOOL(bleed, 4); ACTION_PARAM_BOOL(bleed, 4);
if (DamageType==NAME_None) DamageType = NAME_Melee; // Melee is the default type if (damagetype == NAME_None)
damagetype = NAME_Melee; // Melee is the default type
if (!self->target) if (!self->target)
return; return;
@ -1143,13 +1147,16 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomMeleeAttack)
A_FaceTarget (self); A_FaceTarget (self);
if (self->CheckMeleeRange ()) if (self->CheckMeleeRange ())
{ {
if (MeleeSound) S_Sound (self, CHAN_WEAPON, MeleeSound, 1, ATTN_NORM); if (meleesound)
int newdam = P_DamageMobj (self->target, self, self, damage, DamageType); S_Sound (self, CHAN_WEAPON, meleesound, 1, ATTN_NORM);
if (bleed) P_TraceBleed (newdam > 0 ? newdam : damage, self->target, self); int newdam = P_DamageMobj (self->target, self, self, damage, damagetype);
if (bleed)
P_TraceBleed (newdam > 0 ? newdam : damage, self->target, self);
} }
else else
{ {
if (MissSound) S_Sound (self, CHAN_WEAPON, MissSound, 1, ATTN_NORM); if (misssound)
S_Sound (self, CHAN_WEAPON, misssound, 1, ATTN_NORM);
} }
} }
@ -1162,10 +1169,10 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomComboAttack)
{ {
ACTION_PARAM_START(6); ACTION_PARAM_START(6);
ACTION_PARAM_CLASS(ti, 0); ACTION_PARAM_CLASS(ti, 0);
ACTION_PARAM_FIXED(SpawnHeight, 1); ACTION_PARAM_FIXED(spawnheight, 1);
ACTION_PARAM_INT(damage, 2); ACTION_PARAM_INT(damage, 2);
ACTION_PARAM_SOUND(MeleeSound, 3); ACTION_PARAM_SOUND(meleesound, 3);
ACTION_PARAM_NAME(DamageType, 4); ACTION_PARAM_NAME(damagetype, 4);
ACTION_PARAM_BOOL(bleed, 5); ACTION_PARAM_BOOL(bleed, 5);
if (!self->target) if (!self->target)
@ -1174,17 +1181,20 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomComboAttack)
A_FaceTarget (self); A_FaceTarget (self);
if (self->CheckMeleeRange()) if (self->CheckMeleeRange())
{ {
if (DamageType==NAME_None) DamageType = NAME_Melee; // Melee is the default type if (damagetype == NAME_None)
if (MeleeSound) S_Sound (self, CHAN_WEAPON, MeleeSound, 1, ATTN_NORM); damagetype = NAME_Melee; // Melee is the default type
int newdam = P_DamageMobj (self->target, self, self, damage, DamageType); if (meleesound)
if (bleed) P_TraceBleed (newdam > 0 ? newdam : damage, self->target, self); S_Sound (self, CHAN_WEAPON, meleesound, 1, ATTN_NORM);
int newdam = P_DamageMobj (self->target, self, self, damage, damagetype);
if (bleed)
P_TraceBleed (newdam > 0 ? newdam : damage, self->target, self);
} }
else if (ti) else if (ti)
{ {
// This seemingly senseless code is needed for proper aiming. // This seemingly senseless code is needed for proper aiming.
self->z += SpawnHeight + self->GetBobOffset() - 32*FRACUNIT; self->z += spawnheight + self->GetBobOffset() - 32*FRACUNIT;
AActor *missile = P_SpawnMissileXYZ (self->x, self->y, self->z + 32*FRACUNIT, self, self->target, ti, false); AActor *missile = P_SpawnMissileXYZ (self->x, self->y, self->z + 32*FRACUNIT, self, self->target, ti, false);
self->z -= SpawnHeight + self->GetBobOffset() - 32*FRACUNIT; self->z -= spawnheight + self->GetBobOffset() - 32*FRACUNIT;
if (missile) if (missile)
{ {
@ -1237,13 +1247,13 @@ enum FB_Flags
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FireBullets) DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FireBullets)
{ {
ACTION_PARAM_START(7); ACTION_PARAM_START(7);
ACTION_PARAM_ANGLE(Spread_XY, 0); ACTION_PARAM_ANGLE(spread_xy, 0);
ACTION_PARAM_ANGLE(Spread_Z, 1); ACTION_PARAM_ANGLE(spread_z, 1);
ACTION_PARAM_INT(NumberOfBullets, 2); ACTION_PARAM_INT(numbullets, 2);
ACTION_PARAM_INT(DamagePerBullet, 3); ACTION_PARAM_INT(damageperbullet, 3);
ACTION_PARAM_CLASS(PuffType, 4); ACTION_PARAM_CLASS(pufftype, 4);
ACTION_PARAM_INT(Flags, 5); ACTION_PARAM_INT(flags, 5);
ACTION_PARAM_FIXED(Range, 6); ACTION_PARAM_FIXED(range, 6);
if (!self->player) return; if (!self->player) return;
@ -1253,61 +1263,65 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FireBullets)
int i; int i;
int bangle; int bangle;
int bslope = 0; int bslope = 0;
int laflags = (Flags & FBF_NORANDOMPUFFZ)? LAF_NORANDOMPUFFZ : 0; int laflags = (flags & FBF_NORANDOMPUFFZ)? LAF_NORANDOMPUFFZ : 0;
if ((Flags & FBF_USEAMMO) && weapon) if ((flags & FBF_USEAMMO) && weapon)
{ {
if (!weapon->DepleteAmmo(weapon->bAltFire, true)) return; // out of ammo if (!weapon->DepleteAmmo(weapon->bAltFire, true))
return; // out of ammo
} }
if (Range == 0) Range = PLAYERMISSILERANGE; if (range == 0)
range = PLAYERMISSILERANGE;
if (!(Flags & FBF_NOFLASH)) static_cast<APlayerPawn *>(self)->PlayAttacking2 (); if (!(flags & FBF_NOFLASH)) static_cast<APlayerPawn *>(self)->PlayAttacking2 ();
if (!(Flags & FBF_NOPITCH)) bslope = P_BulletSlope(self); if (!(flags & FBF_NOPITCH)) bslope = P_BulletSlope(self);
bangle = self->angle; bangle = self->angle;
if (!PuffType) PuffType = PClass::FindClass(NAME_BulletPuff); if (pufftype == NULL)
pufftype = PClass::FindClass(NAME_BulletPuff);
if (weapon != NULL) if (weapon != NULL)
{ {
S_Sound(self, CHAN_WEAPON, weapon->AttackSound, 1, ATTN_NORM); S_Sound(self, CHAN_WEAPON, weapon->AttackSound, 1, ATTN_NORM);
} }
if ((NumberOfBullets==1 && !player->refire) || NumberOfBullets==0) if ((numbullets == 1 && !player->refire) || numbullets == 0)
{ {
int damage = DamagePerBullet; int damage = damageperbullet;
if (!(Flags & FBF_NORANDOM)) if (!(flags & FBF_NORANDOM))
damage *= ((pr_cwbullet()%3)+1); damage *= ((pr_cwbullet()%3)+1);
P_LineAttack(self, bangle, Range, bslope, damage, NAME_Hitscan, PuffType, laflags); P_LineAttack(self, bangle, range, bslope, damage, NAME_Hitscan, pufftype, laflags);
} }
else else
{ {
if (NumberOfBullets == -1) NumberOfBullets = 1; if (numbullets < 0)
for (i=0 ; i<NumberOfBullets ; i++) numbullets = 1;
for (i = 0; i < numbullets; i++)
{ {
int angle = bangle; int angle = bangle;
int slope = bslope; int slope = bslope;
if (Flags & FBF_EXPLICITANGLE) if (flags & FBF_EXPLICITANGLE)
{ {
angle += Spread_XY; angle += spread_xy;
slope += Spread_Z; slope += spread_z;
} }
else else
{ {
angle += pr_cwbullet.Random2() * (Spread_XY / 255); angle += pr_cwbullet.Random2() * (spread_xy / 255);
slope += pr_cwbullet.Random2() * (Spread_Z / 255); slope += pr_cwbullet.Random2() * (spread_z / 255);
} }
int damage = DamagePerBullet; int damage = damageperbullet;
if (!(Flags & FBF_NORANDOM)) if (!(flags & FBF_NORANDOM))
damage *= ((pr_cwbullet()%3)+1); damage *= ((pr_cwbullet()%3)+1);
P_LineAttack(self, angle, Range, slope, damage, NAME_Hitscan, PuffType, laflags); P_LineAttack(self, angle, range, slope, damage, NAME_Hitscan, pufftype, laflags);
} }
} }
} }
@ -1328,11 +1342,11 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FireCustomMissile)
{ {
ACTION_PARAM_START(7); ACTION_PARAM_START(7);
ACTION_PARAM_CLASS(ti, 0); ACTION_PARAM_CLASS(ti, 0);
ACTION_PARAM_ANGLE(Angle, 1); ACTION_PARAM_ANGLE(angle, 1);
ACTION_PARAM_BOOL(UseAmmo, 2); ACTION_PARAM_BOOL(useammo, 2);
ACTION_PARAM_INT(SpawnOfs_XY, 3); ACTION_PARAM_INT(spawnofs_xy, 3);
ACTION_PARAM_FIXED(SpawnHeight, 4); ACTION_PARAM_FIXED(spawnheight, 4);
ACTION_PARAM_INT(Flags, 5); ACTION_PARAM_INT(flags, 5);
ACTION_PARAM_ANGLE(pitch, 6); ACTION_PARAM_ANGLE(pitch, 6);
if (!self->player) return; if (!self->player) return;
@ -1343,39 +1357,42 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FireCustomMissile)
AActor *linetarget; AActor *linetarget;
// Only use ammo if called from a weapon // Only use ammo if called from a weapon
if (UseAmmo && ACTION_CALL_FROM_WEAPON() && weapon) if (useammo && ACTION_CALL_FROM_WEAPON() && weapon)
{ {
if (!weapon->DepleteAmmo(weapon->bAltFire, true)) return; // out of ammo if (!weapon->DepleteAmmo(weapon->bAltFire, true))
return; // out of ammo
} }
if (ti) if (ti)
{ {
angle_t ang = (self->angle - ANGLE_90) >> ANGLETOFINESHIFT; angle_t ang = (self->angle - ANGLE_90) >> ANGLETOFINESHIFT;
fixed_t x = SpawnOfs_XY * finecosine[ang]; fixed_t x = spawnofs_xy * finecosine[ang];
fixed_t y = SpawnOfs_XY * finesine[ang]; fixed_t y = spawnofs_xy * finesine[ang];
fixed_t z = SpawnHeight; fixed_t z = spawnheight;
fixed_t shootangle = self->angle; fixed_t shootangle = self->angle;
if (Flags & FPF_AIMATANGLE) shootangle += Angle; if (flags & FPF_AIMATANGLE) shootangle += angle;
// Temporarily adjusts the pitch // Temporarily adjusts the pitch
fixed_t SavedPlayerPitch = self->pitch; fixed_t saved_player_pitch = self->pitch;
self->pitch -= pitch; self->pitch -= pitch;
AActor * misl=P_SpawnPlayerMissile (self, x, y, z, ti, shootangle, &linetarget, NULL, false, (Flags & FPF_NOAUTOAIM) != 0); AActor * misl=P_SpawnPlayerMissile (self, x, y, z, ti, shootangle, &linetarget, NULL, false, (flags & FPF_NOAUTOAIM) != 0);
self->pitch = SavedPlayerPitch; self->pitch = saved_player_pitch;
// automatic handling of seeker missiles // automatic handling of seeker missiles
if (misl) if (misl)
{ {
if (Flags & FPF_TRANSFERTRANSLATION) misl->Translation = self->Translation; if (flags & FPF_TRANSFERTRANSLATION)
if (linetarget && misl->flags2&MF2_SEEKERMISSILE) misl->tracer=linetarget; misl->Translation = self->Translation;
if (!(Flags & FPF_AIMATANGLE)) if (linetarget && (misl->flags2 & MF2_SEEKERMISSILE))
misl->tracer = linetarget;
if (!(flags & FPF_AIMATANGLE))
{ {
// This original implementation is to aim straight ahead and then offset // This original implementation is to aim straight ahead and then offset
// the angle from the resulting direction. // the angle from the resulting direction.
FVector3 velocity(misl->velx, misl->vely, 0); FVector3 velocity(misl->velx, misl->vely, 0);
fixed_t missilespeed = (fixed_t)velocity.Length(); fixed_t missilespeed = (fixed_t)velocity.Length();
misl->angle += Angle; misl->angle += angle;
angle_t an = misl->angle >> ANGLETOFINESHIFT; angle_t an = misl->angle >> ANGLETOFINESHIFT;
misl->velx = FixedMul (missilespeed, finecosine[an]); misl->velx = FixedMul (missilespeed, finecosine[an]);
misl->vely = FixedMul (missilespeed, finesine[an]); misl->vely = FixedMul (missilespeed, finesine[an]);
@ -1406,12 +1423,12 @@ enum
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomPunch) DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomPunch)
{ {
ACTION_PARAM_START(8); ACTION_PARAM_START(8);
ACTION_PARAM_INT(Damage, 0); ACTION_PARAM_INT(damage, 0);
ACTION_PARAM_BOOL(norandom, 1); ACTION_PARAM_BOOL(norandom, 1);
ACTION_PARAM_INT(flags, 2); ACTION_PARAM_INT(flags, 2);
ACTION_PARAM_CLASS(PuffType, 3); ACTION_PARAM_CLASS(pufftype, 3);
ACTION_PARAM_FIXED(Range, 4); ACTION_PARAM_FIXED(range, 4);
ACTION_PARAM_FIXED(LifeSteal, 5); ACTION_PARAM_FIXED(lifesteal, 5);
ACTION_PARAM_INT(lifestealmax, 6); ACTION_PARAM_INT(lifestealmax, 6);
ACTION_PARAM_CLASS(armorbonustype, 7); ACTION_PARAM_CLASS(armorbonustype, 7);
ACTION_PARAM_SOUND(MeleeSound, 8); ACTION_PARAM_SOUND(MeleeSound, 8);
@ -1428,22 +1445,26 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomPunch)
AActor * linetarget; AActor * linetarget;
int actualdamage; int actualdamage;
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)
pitch = P_AimLineAttack (self, angle, Range, &linetarget); range = MELEERANGE;
pitch = P_AimLineAttack (self, angle, range, &linetarget);
// only use ammo when actually hitting something! // only use ammo when actually hitting something!
if ((flags & CPF_USEAMMO) && linetarget && weapon) if ((flags & CPF_USEAMMO) && linetarget && weapon)
{ {
if (!weapon->DepleteAmmo(weapon->bAltFire, true)) return; // out of ammo if (!weapon->DepleteAmmo(weapon->bAltFire, true))
return; // out of ammo
} }
if (!PuffType) PuffType = PClass::FindClass(NAME_BulletPuff); if (pufftype == NULL)
pufftype = PClass::FindClass(NAME_BulletPuff);
int puffFlags = LAF_ISMELEEATTACK | ((flags & CPF_NORANDOMPUFFZ) ? LAF_NORANDOMPUFFZ : 0); int puffFlags = LAF_ISMELEEATTACK | ((flags & CPF_NORANDOMPUFFZ) ? LAF_NORANDOMPUFFZ : 0);
P_LineAttack (self, angle, Range, pitch, Damage, NAME_Melee, PuffType, puffFlags, &linetarget, &actualdamage); P_LineAttack (self, angle, range, pitch, damage, NAME_Melee, pufftype, puffFlags, &linetarget, &actualdamage);
if (!linetarget) if (!linetarget)
{ {
@ -1451,16 +1472,19 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomPunch)
} }
else else
{ {
if (LifeSteal && !(linetarget->flags5 & MF5_DONTDRAIN)) if (lifesteal && !(linetarget->flags5 & MF5_DONTDRAIN))
{ {
if (flags & CPF_STEALARMOR) if (flags & CPF_STEALARMOR)
{ {
if (!armorbonustype) armorbonustype = PClass::FindClass("ArmorBonus"); if (armorbonustype == NULL)
if (armorbonustype->IsDescendantOf (RUNTIME_CLASS(ABasicArmorBonus)))
{ {
armorbonustype = PClass::FindClass("ArmorBonus");
}
if (armorbonustype != NULL)
{
assert(armorbonustype->IsDescendantOf(RUNTIME_CLASS(ABasicArmorBonus)));
ABasicArmorBonus *armorbonus = static_cast<ABasicArmorBonus *>(Spawn(armorbonustype, 0,0,0, NO_REPLACE)); ABasicArmorBonus *armorbonus = static_cast<ABasicArmorBonus *>(Spawn(armorbonustype, 0,0,0, NO_REPLACE));
armorbonus->SaveAmount *= (actualdamage * LifeSteal) >> FRACBITS; armorbonus->SaveAmount *= (actualdamage * lifesteal) >> FRACBITS;
armorbonus->MaxSaveAmount = lifestealmax <= 0 ? armorbonus->MaxSaveAmount : lifestealmax; armorbonus->MaxSaveAmount = lifestealmax <= 0 ? armorbonus->MaxSaveAmount : lifestealmax;
armorbonus->flags |= MF_DROPPED; armorbonus->flags |= MF_DROPPED;
armorbonus->ClearCounters(); armorbonus->ClearCounters();
@ -1471,13 +1495,11 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomPunch)
} }
} }
} }
else else
{ {
P_GiveBody (self, (actualdamage * LifeSteal) >> FRACBITS, lifestealmax); P_GiveBody (self, (actualdamage * lifesteal) >> FRACBITS, lifestealmax);
} }
} }
if (weapon != NULL) if (weapon != NULL)
{ {
if (MeleeSound) S_Sound(self, CHAN_WEAPON, MeleeSound, 1, ATTN_NORM); if (MeleeSound) S_Sound(self, CHAN_WEAPON, MeleeSound, 1, ATTN_NORM);
@ -1504,52 +1526,53 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomPunch)
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_RailAttack) DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_RailAttack)
{ {
ACTION_PARAM_START(17); ACTION_PARAM_START(17);
ACTION_PARAM_INT(Damage, 0); ACTION_PARAM_INT(damage, 0);
ACTION_PARAM_INT(Spawnofs_XY, 1); ACTION_PARAM_INT(spawnofs_xy, 1);
ACTION_PARAM_BOOL(UseAmmo, 2); ACTION_PARAM_BOOL(useammo, 2);
ACTION_PARAM_COLOR(Color1, 3); ACTION_PARAM_COLOR(color1, 3);
ACTION_PARAM_COLOR(Color2, 4); ACTION_PARAM_COLOR(color2, 4);
ACTION_PARAM_INT(Flags, 5); ACTION_PARAM_INT(flags, 5);
ACTION_PARAM_DOUBLE(MaxDiff, 6); ACTION_PARAM_DOUBLE(maxdiff, 6);
ACTION_PARAM_CLASS(PuffType, 7); ACTION_PARAM_CLASS(pufftype, 7);
ACTION_PARAM_ANGLE(Spread_XY, 8); ACTION_PARAM_ANGLE(spread_xy, 8);
ACTION_PARAM_ANGLE(Spread_Z, 9); ACTION_PARAM_ANGLE(spread_z, 9);
ACTION_PARAM_FIXED(Range, 10); ACTION_PARAM_FIXED(range, 10);
ACTION_PARAM_INT(Duration, 11); ACTION_PARAM_INT(duration, 11);
ACTION_PARAM_DOUBLE(Sparsity, 12); ACTION_PARAM_DOUBLE(sparsity, 12);
ACTION_PARAM_DOUBLE(DriftSpeed, 13); ACTION_PARAM_DOUBLE(driftspeed, 13);
ACTION_PARAM_CLASS(SpawnClass, 14); ACTION_PARAM_CLASS(spawnclass, 14);
ACTION_PARAM_FIXED(Spawnofs_Z, 15); ACTION_PARAM_FIXED(spawnofs_z, 15);
ACTION_PARAM_INT(SpiralOffset, 16); ACTION_PARAM_INT(SpiralOffset, 16);
if(Range==0) Range=8192*FRACUNIT; if (range == 0) range = 8192*FRACUNIT;
if(Sparsity==0) Sparsity=1.0; if (sparsity == 0) sparsity=1.0;
if (!self->player) return; if (!self->player) return;
AWeapon *weapon = self->player->ReadyWeapon; AWeapon *weapon = self->player->ReadyWeapon;
// only use ammo when actually hitting something! // only use ammo when actually hitting something!
if (UseAmmo) if (useammo)
{ {
if (!weapon->DepleteAmmo(weapon->bAltFire, true)) return; // out of ammo if (!weapon->DepleteAmmo(weapon->bAltFire, true))
return; // out of ammo
} }
angle_t angle; angle_t angle;
angle_t slope; angle_t slope;
if (Flags & RAF_EXPLICITANGLE) if (flags & RAF_EXPLICITANGLE)
{ {
angle = Spread_XY; angle = spread_xy;
slope = Spread_Z; slope = spread_z;
} }
else else
{ {
angle = pr_crailgun.Random2() * (Spread_XY / 255); angle = pr_crailgun.Random2() * (spread_xy / 255);
slope = pr_crailgun.Random2() * (Spread_Z / 255); slope = pr_crailgun.Random2() * (spread_z / 255);
} }
P_RailAttack (self, Damage, Spawnofs_XY, Spawnofs_Z, Color1, Color2, MaxDiff, Flags, PuffType, angle, slope, Range, Duration, Sparsity, DriftSpeed, SpawnClass, SpiralOffset); P_RailAttack (self, damage, spawnofs_xy, spawnofs_z, color1, color2, maxdiff, flags, pufftype, angle, slope, range, duration, sparsity, driftspeed, spawnclass, SpiralOffset);
} }
//========================================================================== //==========================================================================
@ -1568,26 +1591,26 @@ enum
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomRailgun) DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomRailgun)
{ {
ACTION_PARAM_START(17); ACTION_PARAM_START(17);
ACTION_PARAM_INT(Damage, 0); ACTION_PARAM_INT(damage, 0);
ACTION_PARAM_INT(Spawnofs_XY, 1); ACTION_PARAM_INT(spawnofs_xy, 1);
ACTION_PARAM_COLOR(Color1, 2); ACTION_PARAM_COLOR(color1, 2);
ACTION_PARAM_COLOR(Color2, 3); ACTION_PARAM_COLOR(color2, 3);
ACTION_PARAM_INT(Flags, 4); ACTION_PARAM_INT(flags, 4);
ACTION_PARAM_INT(aim, 5); ACTION_PARAM_INT(aim, 5);
ACTION_PARAM_DOUBLE(MaxDiff, 6); ACTION_PARAM_DOUBLE(maxdiff, 6);
ACTION_PARAM_CLASS(PuffType, 7); ACTION_PARAM_CLASS(pufftype, 7);
ACTION_PARAM_ANGLE(Spread_XY, 8); ACTION_PARAM_ANGLE(spread_xy, 8);
ACTION_PARAM_ANGLE(Spread_Z, 9); ACTION_PARAM_ANGLE(spread_z, 9);
ACTION_PARAM_FIXED(Range, 10); ACTION_PARAM_FIXED(range, 10);
ACTION_PARAM_INT(Duration, 11); ACTION_PARAM_INT(duration, 11);
ACTION_PARAM_DOUBLE(Sparsity, 12); ACTION_PARAM_DOUBLE(sparsity, 12);
ACTION_PARAM_DOUBLE(DriftSpeed, 13); ACTION_PARAM_DOUBLE(driftspeed, 13);
ACTION_PARAM_CLASS(SpawnClass, 14); ACTION_PARAM_CLASS(spawnclass, 14);
ACTION_PARAM_FIXED(Spawnofs_Z, 15); ACTION_PARAM_FIXED(spawnofs_z, 15);
ACTION_PARAM_INT(SpiralOffset, 16); ACTION_PARAM_INT(SpiralOffset, 16);
if(Range==0) Range=8192*FRACUNIT; if (range == 0) range = 8192*FRACUNIT;
if(Sparsity==0) Sparsity=1.0; if (sparsity == 0) sparsity = 1;
AActor *linetarget; AActor *linetarget;
@ -1631,9 +1654,9 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomRailgun)
{ {
// Tricky: We must offset to the angle of the current position // Tricky: We must offset to the angle of the current position
// but then change the angle again to ensure proper aim. // but then change the angle again to ensure proper aim.
self->x += Spawnofs_XY * finecosine[self->angle]; self->x += spawnofs_xy * finecosine[self->angle];
self->y += Spawnofs_XY * finesine[self->angle]; self->y += spawnofs_xy * finesine[self->angle];
Spawnofs_XY = 0; spawnofs_xy = 0;
self->angle = self->AngleTo(self->target,- self->target->velx * 3, -self->target->vely * 3); self->angle = self->AngleTo(self->target,- self->target->velx * 3, -self->target->vely * 3);
} }
@ -1650,18 +1673,18 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CustomRailgun)
angle_t angleoffset; angle_t angleoffset;
angle_t slopeoffset; angle_t slopeoffset;
if (Flags & CRF_EXPLICITANGLE) if (flags & CRF_EXPLICITANGLE)
{ {
angleoffset = Spread_XY; angleoffset = spread_xy;
slopeoffset = Spread_Z; slopeoffset = spread_z;
} }
else else
{ {
angleoffset = pr_crailgun.Random2() * (Spread_XY / 255); angleoffset = pr_crailgun.Random2() * (spread_xy / 255);
slopeoffset = pr_crailgun.Random2() * (Spread_Z / 255); slopeoffset = pr_crailgun.Random2() * (spread_z / 255);
} }
P_RailAttack (self, Damage, Spawnofs_XY, Spawnofs_Z, Color1, Color2, MaxDiff, Flags, PuffType, angleoffset, slopeoffset, Range, Duration, Sparsity, DriftSpeed, SpawnClass, SpiralOffset); P_RailAttack (self, damage, spawnofs_xy, spawnofs_z, color1, color2, maxdiff, flags, pufftype, angleoffset, slopeoffset, range, duration, sparsity, driftspeed, spawnclass,SpiralOffset);
self->x = saved_x; self->x = saved_x;
self->y = saved_y; self->y = saved_y;
@ -1958,7 +1981,7 @@ static bool InitSpawnedItem(AActor *self, AActor *mo, int flags)
mo->tracer = NULL; mo->tracer = NULL;
} }
if (flags & SIXF_SETMASTER) if (flags & SIXF_SETMASTER)
{ { // don't let it attack you (optional)!
mo->master = originator; mo->master = originator;
} }
if (flags & SIXF_SETTARGET) if (flags & SIXF_SETTARGET)
@ -2100,7 +2123,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SpawnItemEx)
ACTION_PARAM_FIXED(xvel, 4); ACTION_PARAM_FIXED(xvel, 4);
ACTION_PARAM_FIXED(yvel, 5); ACTION_PARAM_FIXED(yvel, 5);
ACTION_PARAM_FIXED(zvel, 6); ACTION_PARAM_FIXED(zvel, 6);
ACTION_PARAM_ANGLE(Angle, 7); ACTION_PARAM_ANGLE(angle, 7);
ACTION_PARAM_INT(flags, 8); ACTION_PARAM_INT(flags, 8);
ACTION_PARAM_INT(chance, 9); ACTION_PARAM_INT(chance, 9);
ACTION_PARAM_INT(tid, 10); ACTION_PARAM_INT(tid, 10);
@ -2120,10 +2143,10 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SpawnItemEx)
if (!(flags & SIXF_ABSOLUTEANGLE)) if (!(flags & SIXF_ABSOLUTEANGLE))
{ {
Angle += self->angle; angle += self->angle;
} }
angle_t ang = Angle >> ANGLETOFINESHIFT; angle_t ang = angle >> ANGLETOFINESHIFT;
if (flags & SIXF_ABSOLUTEPOSITION) if (flags & SIXF_ABSOLUTEPOSITION)
{ {
@ -2169,7 +2192,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SpawnItemEx)
mo->vely = yvel; mo->vely = yvel;
mo->velz = zvel; mo->velz = zvel;
} }
mo->angle = Angle; mo->angle = angle;
} }
} }
@ -2434,14 +2457,18 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FadeIn)
self->RenderStyle.Flags &= ~STYLEF_Alpha1; self->RenderStyle.Flags &= ~STYLEF_Alpha1;
self->alpha += reduce; self->alpha += reduce;
if (self->alpha >= (FRACUNIT * 1)) if (self->alpha >= FRACUNIT)
{ {
if (flags & FTF_CLAMP) if (flags & FTF_CLAMP)
self->alpha = (FRACUNIT * 1); {
self->alpha = FRACUNIT;
}
if (flags & FTF_REMOVE) if (flags & FTF_REMOVE)
{
P_RemoveThing(self); P_RemoveThing(self);
} }
} }
}
//=========================================================================== //===========================================================================
// //
@ -2465,11 +2492,15 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FadeOut)
if (self->alpha <= 0) if (self->alpha <= 0)
{ {
if (flags & FTF_CLAMP) if (flags & FTF_CLAMP)
{
self->alpha = 0; self->alpha = 0;
}
if (flags & FTF_REMOVE) if (flags & FTF_REMOVE)
{
P_RemoveThing(self); P_RemoveThing(self);
} }
} }
}
//=========================================================================== //===========================================================================
// //
@ -2508,10 +2539,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FadeTo)
} }
if (flags & FTF_CLAMP) if (flags & FTF_CLAMP)
{ {
if (self->alpha > (FRACUNIT * 1)) self->alpha = clamp(self->alpha, 0, FRACUNIT);
self->alpha = (FRACUNIT * 1);
else if (self->alpha < 0)
self->alpha = 0;
} }
if (self->alpha == target && (flags & FTF_REMOVE)) if (self->alpha == target && (flags & FTF_REMOVE))
{ {
@ -2579,8 +2607,10 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SpawnDebris)
if (debris == NULL) return; if (debris == NULL) return;
// only positive values make sense here // only positive values make sense here
if (mult_v<=0) mult_v=FRACUNIT; if (mult_v <= 0)
if (mult_h<=0) mult_h=FRACUNIT; mult_v = FRACUNIT;
if (mult_h <= 0)
mult_h = FRACUNIT;
for (i = 0; i < GetDefaultByType(debris)->health; i++) for (i = 0; i < GetDefaultByType(debris)->health; i++)
{ {
@ -3046,8 +3076,10 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Respawn)
else else
{ {
// Don't attack yourself (Re: "Marine targets itself after suicide") // Don't attack yourself (Re: "Marine targets itself after suicide")
if (self->target == self) self->target = NULL; if (self->target == self)
if (self->lastenemy == self) self->lastenemy = NULL; self->target = NULL;
if (self->lastenemy == self)
self->lastenemy = NULL;
} }
self->flags = (defs->flags & ~MF_FRIENDLY) | (self->flags & MF_FRIENDLY); self->flags = (defs->flags & ~MF_FRIENDLY) | (self->flags & MF_FRIENDLY);
@ -3487,9 +3519,13 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfTargetInLOS)
target = self->target; target = self->target;
} }
if (!target) return; // [KS] Let's not call P_CheckSight unnecessarily in this case. if (target == NULL)
return; // [KS] Let's not call P_CheckSight unnecessarily in this case.
if ((flags & JLOSF_DEADNOJUMP) && (target->health <= 0)) return; if ((flags & JLOSF_DEADNOJUMP) && (target->health <= 0))
{
return;
}
doCheckSight = !(flags & JLOSF_NOSIGHT); doCheckSight = !(flags & JLOSF_NOSIGHT);
} }
@ -3922,7 +3958,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_MonsterRefire)
if (pr_monsterrefire() < prob) if (pr_monsterrefire() < prob)
return; return;
if (!self->target if (self->target == NULL
|| P_HitFriend (self) || P_HitFriend (self)
|| self->target->health <= 0 || self->target->health <= 0
|| !P_CheckSight (self, self->target, SF_SEEPASTBLOCKEVERYTHING|SF_SEEPASTSHOOTABLELINES) ) || !P_CheckSight (self, self->target, SF_SEEPASTBLOCKEVERYTHING|SF_SEEPASTSHOOTABLELINES) )
@ -3953,8 +3989,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SetAngle)
ACTION_PARAM_INT(ptr, 2); ACTION_PARAM_INT(ptr, 2);
AActor *ref = COPY_AAPTR(self, ptr); AActor *ref = COPY_AAPTR(self, ptr);
if (ref != NULL)
if (!ref)
{ {
ACTION_SET_RESULT(false); ACTION_SET_RESULT(false);
return; return;
@ -4235,12 +4270,12 @@ enum T_Flags
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Teleport) DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Teleport)
{ {
ACTION_PARAM_START(7); ACTION_PARAM_START(7);
ACTION_PARAM_STATE(TeleportState, 0); ACTION_PARAM_STATE(teleport_state, 0);
ACTION_PARAM_CLASS(TargetType, 1); ACTION_PARAM_CLASS(target_type, 1);
ACTION_PARAM_CLASS(FogType, 2); ACTION_PARAM_CLASS(fog_type, 2);
ACTION_PARAM_INT(Flags, 3); ACTION_PARAM_INT(flags, 3);
ACTION_PARAM_FIXED(MinDist, 4); ACTION_PARAM_FIXED(mindist, 4);
ACTION_PARAM_FIXED(MaxDist, 5); ACTION_PARAM_FIXED(maxdist, 5);
ACTION_PARAM_INT(ptr, 6); ACTION_PARAM_INT(ptr, 6);
AActor *ref = COPY_AAPTR(self, ptr); AActor *ref = COPY_AAPTR(self, ptr);
@ -4251,14 +4286,14 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Teleport)
return; return;
} }
if ((ref->flags2 & MF2_NOTELEPORT) && !(Flags & TF_OVERRIDE)) if ((ref->flags2 & MF2_NOTELEPORT) && !(flags & TF_OVERRIDE))
{ {
ACTION_SET_RESULT(false); ACTION_SET_RESULT(false);
return; return;
} }
// Randomly choose not to teleport like A_Srcr2Decide. // Randomly choose not to teleport like A_Srcr2Decide.
if (Flags & TF_RANDOMDECIDE) if (flags & TF_RANDOMDECIDE)
{ {
static const int chance[] = static const int chance[] =
{ {
@ -4282,10 +4317,12 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Teleport)
return; return;
} }
if (!TargetType) if (target_type == NULL)
TargetType = PClass::FindClass("BossSpot"); {
target_type = PClass::FindClass("BossSpot");
}
AActor * spot = state->GetSpotWithMinMaxDistance(TargetType, ref->x, ref->y, MinDist, MaxDist); AActor * spot = state->GetSpotWithMinMaxDistance(target_type, ref->x, ref->y, mindist, maxdist);
if (spot == NULL) if (spot == NULL)
{ {
ACTION_SET_RESULT(false); ACTION_SET_RESULT(false);
@ -4303,76 +4340,76 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Teleport)
else if (spot->z < spot->floorz) else if (spot->z < spot->floorz)
finalz = spot->floorz; finalz = spot->floorz;
//Take precedence and cooperate with telefragging first. //Take precedence and cooperate with telefragging first.
bool teleResult = P_TeleportMove(ref, spot->x, spot->y, finalz, Flags & TF_TELEFRAG); bool tele_result = P_TeleportMove(ref, spot->x, spot->y, finalz, flags & TF_TELEFRAG);
if (!teleResult && (Flags & TF_FORCED)) if (!tele_result && (flags & TF_FORCED))
{ {
//If for some reason the original move didn't work, regardless of telefrag, force it to move. //If for some reason the original move didn't work, regardless of telefrag, force it to move.
ref->SetOrigin(spot->x, spot->y, finalz); ref->SetOrigin(spot->x, spot->y, finalz);
teleResult = true; tele_result = true;
} }
AActor *fog1 = NULL, *fog2 = NULL; AActor *fog1 = NULL, *fog2 = NULL;
if (teleResult) if (tele_result)
{ {
//If a fog type is defined in the parameter, or the user wants to use the actor's predefined fogs, //If a fog type is defined in the parameter, or the user wants to use the actor's predefined fogs,
//and if there's no desire to be fogless, spawn a fog based upon settings. //and if there's no desire to be fogless, spawn a fog based upon settings.
if (FogType || (Flags & TF_USEACTORFOG)) if (fog_type || (flags & TF_USEACTORFOG))
{ {
if (!(Flags & TF_NOSRCFOG)) if (!(flags & TF_NOSRCFOG))
{ {
if (Flags & TF_USEACTORFOG) if (flags & TF_USEACTORFOG)
P_SpawnTeleportFog(ref, prevX, prevY, prevZ, true, true); P_SpawnTeleportFog(ref, prevX, prevY, prevZ, true, true);
else else
{ {
fog1 = Spawn(FogType, prevX, prevY, prevZ, ALLOW_REPLACE); fog1 = Spawn(fog_type, prevX, prevY, prevZ, ALLOW_REPLACE);
if (fog1 != NULL) if (fog1 != NULL)
fog1->target = ref; fog1->target = ref;
} }
} }
if (!(Flags & TF_NODESTFOG)) if (!(flags & TF_NODESTFOG))
{ {
if (Flags & TF_USEACTORFOG) if (flags & TF_USEACTORFOG)
P_SpawnTeleportFog(ref, ref->x, ref->y, ref->z, false, true); P_SpawnTeleportFog(ref, ref->x, ref->y, ref->z, false, true);
else else
{ {
fog2 = Spawn(FogType, ref->x, ref->y, ref->z, ALLOW_REPLACE); fog2 = Spawn(fog_type, ref->x, ref->y, ref->z, ALLOW_REPLACE);
if (fog2 != NULL) if (fog2 != NULL)
fog2->target = ref; fog2->target = ref;
} }
} }
} }
if (Flags & TF_USESPOTZ) if (flags & TF_USESPOTZ)
ref->z = spot->z; ref->z = spot->z;
else else
ref->z = ref->floorz; ref->z = ref->floorz;
if (!(Flags & TF_KEEPANGLE)) self->z = (flags & TF_USESPOTZ) ? spot->z : self->floorz;
if (!(flags & TF_KEEPANGLE))
ref->angle = spot->angle; ref->angle = spot->angle;
if (!(Flags & TF_KEEPVELOCITY)) if (!(flags & TF_KEEPVELOCITY))
ref->velx = ref->vely = ref->velz = 0; ref->velx = ref->vely = ref->velz = 0;
if (!(Flags & TF_NOJUMP)) //The state jump should only happen with the calling actor. if (!(flags & TF_NOJUMP)) //The state jump should only happen with the calling actor.
{ {
ACTION_SET_RESULT(false); // Jumps should never set the result for inventory state chains! ACTION_SET_RESULT(false); // Jumps should never set the result for inventory state chains!
if (TeleportState == NULL) if (teleport_state == NULL)
{ {
// Default to Teleport. // Default to Teleport.
TeleportState = self->FindState("Teleport"); teleport_state = self->FindState("Teleport");
// If still nothing, then return. // If still nothing, then return.
if (!TeleportState) return; if (teleport_state == NULL)
return;
} }
ACTION_JUMP(TeleportState); ACTION_JUMP(teleport_state);
return; return;
} }
} }
ACTION_SET_RESULT(teleResult); ACTION_SET_RESULT(tele_result);
} }
//=========================================================================== //===========================================================================