New MBF21 DEHACKED codepointers (first batch)

prboom2/src/d_deh.c

@@ -1393,6 +1393,20 @@ static const deh_bexptr deh_bexptrs[] = // CPhipps - static const
   {A_BetaSkullAttack, "A_BetaSkullAttack"}, // killough 10/98: beta lost souls attacked different
   {A_Stop,            "A_Stop"},
 
+  // [XA] New mbf21 codepointers
+  {A_SpawnFacing,         "A_SpawnFacing"},
+  {A_MonsterProjectile,   "A_MonsterProjectile"},
+  {A_MonsterBulletAttack, "A_MonsterBulletAttack"},
+  {A_RadiusDamage,        "A_RadiusDamage"},
+  {A_WeaponProjectile,    "A_WeaponProjectile"},
+  {A_WeaponBulletAttack,  "A_WeaponBulletAttack"},
+  {A_WeaponSound,         "A_WeaponSound"},
+  {A_WeaponJump,          "A_WeaponJump"},
+  {A_ConsumeAmmo,         "A_ConsumeAmmo"},
+  {A_CheckAmmo,           "A_CheckAmmo"},
+  {A_RefireTo,            "A_RefireTo"},
+  {A_GunFlashTo,          "A_GunFlashTo"},
+
   // This NULL entry must be the last in the list
   {NULL,              "A_NULL"},  // Ty 05/16/98
 };

prboom2/src/m_random.c

@@ -41,6 +41,7 @@
 #include "doomstat.h"
 #include "m_random.h"
 #include "lprintf.h"
+#include "tables.h"
 
 //
 // M_Random
@@ -146,6 +147,45 @@ void M_ClearRandom (void)
   rng.prndindex = rng.rndindex = 0;    // clear two compatibility indices
 }
 
+// [XA] Common random formulas used by codepointers
+
+//
+// P_RandomHitscanAngle
+// Outputs a random angle between (-spread, spread), as an int ('cause it can be negative).
+//   spread: Maximum angle (degrees, in fixed point -- not BAM!)
+//
+int P_RandomHitscanAngle(pr_class_t pr_class, fixed_t spread)
+{
+  int t;
+  int_64_t spread_bam;
+
+  // FixedToAngle doesn't work for negative numbers,
+  // so for convenience take just the absolute value.
+  spread_bam = (spread < 0 ? FixedToAngle(-spread) : FixedToAngle(spread));
+  t = P_Random(pr_class);
+  return (int)((spread_bam * (t - P_Random(pr_class))) / 255);
+}
+
+//
+// P_RandomHitscanSlope
+// Outputs a random angle between (-spread, spread), converted to values used for slope
+//   spread: Maximum vertical angle (degrees, in fixed point -- not BAM!)
+//
+int P_RandomHitscanSlope(pr_class_t pr_class, fixed_t spread)
+{
+  int angle;
+
+  angle = P_RandomHitscanAngle(pr_class, spread);
+
+  // clamp it, yo
+  if (angle > ANG90)
+    return finetangent[0];
+  else if (-angle > ANG90)
+    return finetangent[FINEANGLES/2 - 1];
+  else
+    return finetangent[(ANG90 - angle) >> ANGLETOFINESHIFT];
+}
+
 // heretic
 
 int P_SubRandom (void)

prboom2/src/m_random.h

@@ -124,6 +124,7 @@ typedef enum {
   pr_randomjump,              // #61
   pr_defect,                  // #62  // Start new entries -- add new entries below
   pr_heretic,                 // #63
+  pr_mbf21,                   // #64
 
   // End of new entries
   NUMPRCLASS               // MUST be last item in list
@@ -152,6 +153,10 @@ int P_Random(pr_class_t DA(const char *, int));
 // Fix randoms for demos.
 void M_ClearRandom(void);
 
+// [XA] Common random formulas used by codepointers
+int P_RandomHitscanAngle(pr_class_t pr_class, fixed_t spread);
+int P_RandomHitscanSlope(pr_class_t pr_class, fixed_t spread);
+
 // heretic
 
 #define HITDICE(a) ((1+(P_Random(pr_heretic)&7))*a)

prboom2/src/mbf21.md

@@ -68,3 +68,20 @@ The DEH specification is still TBD - this is just a list of implemented flags of
 | MF2_E4M6BOSS       | MF2_E4M6BOSS       | E4M6 boss (cyberdemon)                                                                         |
 | MF2_E4M8BOSS       | MF2_E4M8BOSS       | E4M8 boss (mastermind)                                                                         |
 | MF2_RIP            | MF3_RIP            | Ripper projectile (does not disappear on impact)                                               |
+
+#### New DEHACKED Codepointers
+- [PR](https://github.com/kraflab/dsda-doom/pull/20)
+- Actor pointers:
+  - **A_SpawnFacing(type, height)** -- spawns an actor of `type` at `height` z units and sets its angle to the caller's angle.
+  - **A_MonsterProjectile(type, angle)** -- generic monster projectile attack; always sets `tracer` field.
+  - **A_MonsterBulletAttack(damage, spread)** -- generic monster bullet attack w/horizontal `spread`; if `spread` is negative, apply vertical spread equal to 2/3 of this value (approx. equal to SSG vert-spread)
+  - **A_RadiusDamage(damage, radius)** -- generic A_Explode, w/customizable damage and radius (helll yeah)
+- Weapon pointers:
+  - **A_WeaponProjectile(type, angle)** -- generic weapon projectile attack; does not consume ammo
+  - **A_WeaponBulletAttack(damage, spread)** -- generic weapon bullet attack; does not consume ammo; same `spread` behavior as A_MonsterBulletAttack
+  - **A_WeaponSound(sound, fullvol)** -- same as A_PlaySound, but for weapons
+  - **A_WeaponJump(state, chance)** -- same as A_RandomJump, but for  weapons
+  - **A_ConsumeAmmo(amount)** -- subtract `amount` units of ammo. if `amount` is zero, use the weapon slot's `ammopershot`. will not reduce ammo below zero.
+  - **A_CheckAmmo(state, amount)** -- jumps to `state` if ammo is below `amount`; if `amount` is zero, use the weapon slot's `ammopershot` value instead
+  - **A_RefireTo(state, noammocheck)** -- jumps to `state` if trigger is still held down; will also check ammo unless `noammocheck` is set
+  - **A_GunFlashTo(state, nothirdperson)** -- sets the weapon's flash state to `state`; also sets the player's 3rd-person sprite to the player actor's firing frame unless `nothirdperson` is set

prboom2/src/p_enemy.c

@@ -1972,7 +1972,7 @@ void A_VileAttack(mobj_t *actor)
   // move the fire between the vile and the player
   fire->x = actor->target->x - FixedMul (24*FRACUNIT, finecosine[an]);
   fire->y = actor->target->y - FixedMul (24*FRACUNIT, finesine[an]);
-  P_RadiusAttack(fire, actor, 70);
+  P_RadiusAttack(fire, actor, 70, 70);
 }
 
 //
@@ -2335,7 +2335,7 @@ void A_Explode(mobj_t *thingy)
       break;
   }
 
-  P_RadiusAttack(thingy, thingy->target, damage);
+  P_RadiusAttack(thingy, thingy->target, damage, damage);
   if (heretic) P_HitFloor(thingy);
 }
 
@@ -2817,7 +2817,7 @@ void A_Detonate(mobj_t *mo)
       !prboom_comp[PC_APPLY_MBF_CODEPOINTERS_TO_ANY_COMPLEVEL].state)
     return;
 
-  P_RadiusAttack(mo, mo->target, mo->info->damage);
+  P_RadiusAttack(mo, mo->target, mo->info->damage, mo->info->damage);
 }
 
 //
@@ -2959,6 +2959,106 @@ void A_LineEffect(mobj_t *mo)
   mo->player = oldplayer;
 }
 
+//
+// [XA] New mbf21 codepointers
+//
+
+//
+// A_SpawnFacing
+// Spawns an actor facing the same direction as the caller.
+// Basically just A_Spawn with a major quality-of-life tweak.
+//   misc1: Type of actor to spawn
+//   misc2: Height to spawn at, relative to calling actor
+//
+void A_SpawnFacing(mobj_t *actor)
+{
+  mobj_t *mo;
+
+  if (!mbf21 || !actor->state->misc1)
+    return;
+
+  mo = P_SpawnMobj(actor->x, actor->y, (actor->state->misc2 << FRACBITS) + actor->z, actor->state->misc1 - 1);
+  if (mo)
+    mo->angle = actor->angle;
+
+  // [XA] don't bother with the dont-inherit-friendliness hack
+  // that exists in A_Spawn, 'cause WTF is that about anyway?
+}
+
+//
+// A_MonsterProjectile
+// A parameterized monster projectile attack.
+//   misc1: Type of actor to spawn
+//   misc2: Angle (degrees, in fixed point), relative to calling actor's angle
+//
+void A_MonsterProjectile(mobj_t *actor)
+{
+  mobj_t *mo;
+  int an;
+
+  if (!mbf21 || !actor->target || !actor->state->misc1)
+    return;
+
+  A_FaceTarget(actor);
+  mo = P_SpawnMissile(actor, actor->target, actor->state->misc1 - 1);
+  if (!mo)
+    return;
+
+  // adjust the angle by misc2;
+  mo->angle += (unsigned int)(((int_64_t)actor->state->misc2 << 16) / 360);
+  an = mo->angle >> ANGLETOFINESHIFT;
+  mo->momx = FixedMul(mo->info->speed, finecosine[an]);
+  mo->momy = FixedMul(mo->info->speed, finesine[an]);
+
+  // always set the 'tracer' field, so this pointer
+  // can be used to fire seeker missiles at will.
+  P_SetTarget(&mo->tracer, actor->target);
+}
+
+//
+// A_MonsterBulletAttack
+// A parameterized monster bullet attack.
+//   misc1: Damage of attack (times 1d5)
+//   misc2: Horizontal spread (degrees, in fixed point);
+//          if negative, also use 2/3 of this value for vertical spread
+//
+void A_MonsterBulletAttack(mobj_t *actor)
+{
+  int damage, angle, slope, t;
+  int_64_t spread;
+
+  if (!mbf21 || !actor->target)
+    return;
+
+  A_FaceTarget(actor);
+  S_StartSound(actor, actor->info->attacksound);
+
+  damage = (P_Random(pr_mbf21) % 5 + 1) * actor->state->misc1;
+
+  angle = (int)actor->angle + P_RandomHitscanAngle(pr_mbf21, actor->state->misc2);;
+  slope = P_AimLineAttack(actor, angle, MISSILERANGE, 0);
+
+  if (actor->state->misc2 < 0)
+    slope += P_RandomHitscanSlope(pr_mbf21, actor->state->misc2 * 2 / 3);
+
+  P_LineAttack(actor, angle, MISSILERANGE, slope, damage);
+}
+
+//
+// A_RadiusDamage
+// A parameterized version of A_Explode. Friggin' finally. :P
+//   misc1: Damage (int)
+//   misc2: Radius (also int; no real need for fractional precision here)
+//
+void A_RadiusDamage(mobj_t *actor)
+{
+  if (!mbf21 || !actor->state)
+    return;
+
+  P_RadiusAttack(actor, actor->target, actor->state->misc1, actor->state->misc2);
+}
+
+
 // heretic
 
 #include "heretic/def.h"
@@ -4109,7 +4209,7 @@ void A_VolcBallImpact(mobj_t * ball)
         ball->z += 28 * FRACUNIT;
         //ball->momz = 3*FRACUNIT;
     }
-    P_RadiusAttack(ball, ball->target, 25);
+    P_RadiusAttack(ball, ball->target, 25, 25);
     for (i = 0; i < 4; i++)
     {
         tiny = P_SpawnMobj(ball->x, ball->y, ball->z, HERETIC_MT_VOLCANOTBLAST);

prboom2/src/p_enemy.h

@@ -120,6 +120,13 @@ void A_Stop(mobj_t *);
 
 void A_SkullPop(mobj_t *);
 
+// [XA] New mbf21 codepointers
+
+void A_SpawnFacing(mobj_t *);
+void A_MonsterProjectile(mobj_t *);
+void A_MonsterBulletAttack(mobj_t *);
+void A_RadiusDamage(mobj_t *);
+
 // heretic
 
 void P_NoiseAlert(mobj_t * target, mobj_t * emmiter);

prboom2/src/p_map.c

@@ -2016,6 +2016,7 @@ void P_UseLines (player_t*  player)
 mobj_t *bombsource, *bombspot;
 //e6y static
 int bombdamage;
+int bombdistance;
 
 
 //
@@ -2029,6 +2030,7 @@ dboolean PIT_RadiusAttack (mobj_t* thing)
   fixed_t dx;
   fixed_t dy;
   fixed_t dist;
+  int damage;
 
   /* killough 8/20/98: allow bouncers to take damage
    * (missile bouncers are already excluded with MF_NOBLOCKMAP)
@@ -2058,13 +2060,21 @@ dboolean PIT_RadiusAttack (mobj_t* thing)
   if (dist < 0)
   dist = 0;
 
-  if (dist >= bombdamage)
+  if (dist >= bombdistance)
     return true;  // out of range
 
   if ( P_CheckSight (thing, bombspot) )
     {
     // must be in direct path
-    P_DamageMobj (thing, bombspot, bombsource, bombdamage - dist);
+
+    // [XA] independent damage/distance calculation.
+    //      same formula as eternity; thanks Quas :P
+    if (bombdamage == bombdistance)
+      damage = bombdamage - dist;
+    else
+      damage = (bombdamage * (bombdistance - dist) / bombdistance) + 1;
+
+    P_DamageMobj (thing, bombspot, bombsource, damage);
     }
 
   return true;
@@ -2075,7 +2085,7 @@ dboolean PIT_RadiusAttack (mobj_t* thing)
 // P_RadiusAttack
 // Source is the creature that caused the explosion at spot.
 //
-void P_RadiusAttack(mobj_t* spot,mobj_t* source,int damage)
+void P_RadiusAttack(mobj_t* spot,mobj_t* source, int damage, int distance)
 {
   int x;
   int y;
@@ -2087,7 +2097,7 @@ void P_RadiusAttack(mobj_t* spot,mobj_t* source,int damage)
 
   fixed_t dist;
 
-  dist = (damage+MAXRADIUS)<<FRACBITS;
+  dist = (distance+MAXRADIUS)<<FRACBITS;
   yh = P_GetSafeBlockY(spot->y + dist - bmaporgy);
   yl = P_GetSafeBlockY(spot->y - dist - bmaporgy);
   xh = P_GetSafeBlockX(spot->x + dist - bmaporgx);
@@ -2102,6 +2112,7 @@ void P_RadiusAttack(mobj_t* spot,mobj_t* source,int damage)
     bombsource = source;
   }
   bombdamage = damage;
+  bombdistance = distance;
 
   for (y=yl ; y<=yh ; y++)
     for (x=xl ; x<=xh ; x++)

prboom2/src/p_map.h

@@ -65,7 +65,7 @@ fixed_t P_AimLineAttack(mobj_t *t1,angle_t angle,fixed_t distance, uint_64_t mas
 
 void    P_LineAttack(mobj_t *t1, angle_t angle, fixed_t distance,
                      fixed_t slope, int damage );
-void    P_RadiusAttack(mobj_t *spot, mobj_t *source, int damage);
+void    P_RadiusAttack(mobj_t *spot, mobj_t *source, int damage, int distance);
 dboolean P_CheckPosition(mobj_t *thing, fixed_t x, fixed_t y);
 
 //jff 3/19/98 P_CheckSector(): new routine to replace P_ChangeSector()