Set victim as tracer?

[Ed the Bat]

Based on some musings from here...

Is it possible to craft a flag or property so that a projectile can mark the actor it struck to be its tracer?

[NeuralStunner]

Sounds reasonable (and quite useful) to me!

[Blue Shadow]

This may sound moot at this point, but why not use the master field, instead? Projectiles don't have a use of that field currently.

Anyway, I'm in support of this. The ability to make a projectile run a script for the thing it hits* is something I needed recently for my mod. And with this, I may be able to achieve that.

---

Please, don't suggest A_RadiusGive.

[Ghastly]

Please, don't suggest A_RadiusGive.

To preempt people that might, A_RadiusGive has the same problems as all the other hacky workarounds for the problem this request would solve. A_SeekerMissile's SMF_LOOK flag, A_Look(Ex) and the various methods of distance-checking all take into account only the center of the actor. Problem is when you're trying to detect what actor was hit by a projectile, it's entirely possible to either not detect large-enough actors (too far from the center), and/or pick out a small-radius target that wasn't even hit.

I think a flag (so it doesn't risk breaking any possibly-existing behavior) to set the actor hit by a projectile as the projectile's master (because projectiles already have extensive use of target and tracer) is the best option.

[Ryan Cordell]

I'm not sure I'll actually post this as a patch, because I'm sure there's a better way of going about this - where you could basically set the hit actor as the Master, Tracer or Target of the projectile/puff - without using up more flags.

Devs are free to chime in on this idea.

---

Code: Select all

 src/actor.h                    | 1 +
 src/p_map.cpp                  | 8 ++++++++
 src/p_mobj.cpp                 | 4 ++++
 src/thingdef/thingdef_data.cpp | 1 +
 4 files changed, 14 insertions(+)

diff --git a/src/actor.h b/src/actor.h
index f8b5831..547447d 100644
--- a/src/actor.h
+++ b/src/actor.h
@@ -340,6 +340,7 @@ enum
     MF7_NOTELESTOMP        = 0x00000002,    // cannot telefrag under any circumstances (even when set by MAPINFO)
     MF7_ALWAYSTELEFRAG    = 0x00000004,    // will unconditionally be telefragged when in the way. Overrides all other settings.
     MF7_HANDLENODELAY    = 0x00000008,    // respect NoDelay state flag
+    MF7_TRACERONHIT        = 0x00000010,    // [RC] Hit actor becomes the inflictor's tracer.
 
 // --- mobj.renderflags ---
 
diff --git a/src/p_map.cpp b/src/p_map.cpp
index 45eb0d9..93b8bf8 100644
--- a/src/p_map.cpp
+++ b/src/p_map.cpp
@@ -3734,6 +3734,10 @@ AActor *P_LineAttack (AActor *t1, angle_t angle, fixed_t distance,
                 *victim = trace.Actor;
             }
         }
+        if (trace.Actor != NULL && puff->flags7 & MF7_TRACERONHIT)
+        {
+            puff->tracer = trace.Actor;
+        }
         if (trace.Crossed3DWater || trace.CrossedWater)
         {
 
@@ -4072,6 +4076,10 @@ void P_RailAttack (AActor *source, int damage, int offset_xy, fixed_t offset_z,
             P_SpawnBlood(x, y, z, (source->angle + angleoffset) - ANG180, newdam > 0 ? newdam : damage, hitactor);
             P_TraceBleed(newdam > 0 ? newdam : damage, x, y, z, hitactor, source->angle, pitch);
         }
+        if (hitactor != NULL && puffDefaults->flags7 & MF7_TRACERONHIT)
+        {
+            puffDefaults->tracer = hitactor;
+        }
     }
 
     // Spawn a decal or puff at the point where the trace ended.
diff --git a/src/p_mobj.cpp b/src/p_mobj.cpp
index eb21427..a9ec5b4 100644
--- a/src/p_mobj.cpp
+++ b/src/p_mobj.cpp
@@ -1170,6 +1170,10 @@ void P_ExplodeMissile (AActor *mo, line_t *line, AActor *target)
     if (nextstate == NULL) nextstate = mo->FindState(NAME_Death);
     mo->SetState (nextstate);
     
+    if (target != NULL && mo->flags7 & MF7_TRACERONHIT)
+    {
+        mo->tracer = target;
+    }
     if (mo->ObjectFlags & OF_EuthanizeMe)
     {
         return;
diff --git a/src/thingdef/thingdef_data.cpp b/src/thingdef/thingdef_data.cpp
index bf0bf2e..45fffd3 100644
--- a/src/thingdef/thingdef_data.cpp
+++ b/src/thingdef/thingdef_data.cpp
@@ -240,6 +240,7 @@ static FFlagDef ActorFlags[]=
     DEFINE_FLAG(MF7, NEVERTARGET, AActor, flags7),
     DEFINE_FLAG(MF7, NOTELESTOMP, AActor, flags7),
     DEFINE_FLAG(MF7, ALWAYSTELEFRAG, AActor, flags7),
+    DEFINE_FLAG(MF7, TRACERONHIT, AActor, flags7),
 
     // Effect flags
     DEFINE_FLAG(FX, VISIBILITYPULSE, AActor, effects),

[Xaser]

This may sound moot at this point, but why not use the master field, instead? Projectiles don't have a use of that field currently.

Semantically it doesn't really make sense why "master" should point at it, but I dunno if that's a big of a deal since the flag's name would explicitly state this behavior so it's not like it would be unintuitive.

Seems like it should be fine for the OP's purposes since A_GiveInventory and other relevant functions like A_Warp seem to have an actor pointer parameter now.

[Ed the Bat]

Any pointer will work, frankly. And since projectiles have traditionally set the Target field to be their owner, semantics were out the window to begin with.

[Ghastly]

Any pointer will work, frankly.

Indeed. Hell, if we're using a function that needs a target anyway and we have it saved as a tracer, we can just A_RearrangePointers(AAPTR_TRACER, AAPTR_DEFAULT, AAPTR_TARGET), do what we need to do and call A_RearrangePointers again to set it back.

[Major Cooke]

Not if they're doing something like A_Explode. AEoD relies specifically on tracer actions, and using target will just cause many things to break there. I strongly must encourage using as the OP intended: tracer.

[NeuralStunner]

Not if they're doing something like A_Explode. AEoD relies specifically on tracer actions, and using target will just cause many things to break there. I strongly must encourage using as the OP intended: tracer.

I'm not sure who you're trying to argue with.

[Major Cooke]

Ed the Bat. Simply put, quite a few projectiles within the mod rely upon hitting something and performing A_SeekerMissile to ensure that the victim and the shooter are consistent (i.e. the stake gun's stakes sticking into the enemy it hits)

[NeuralStunner]

I don't believe he was actually advocating use of Target for the function (since he mentioned right after that it already has a special use).

Aside: There might be a niche use in remembering the intended victim of a seeker missile to compare it to the actual victim. It should work to shuffle the Tracer into Master during the missile's lifetime, right? (I don't assume, since there are a handful of "must be a monster" rules surrounding the Master pointer.)

[Nightfall]

I really don't think using the master pointer here would be a very good idea since then we lock ourselves the possibility of possibly opening the master/minion relationship in the future. Bastardizing it like this isn't the correct way of doing things IMO. I'd rather add a new "victim" field but if something needs to be bastardized for the job perhaps use the lastenemy field for this?

[NeuralStunner]

That could work, but it'd need a pointer "flag" and relevant functions. I think Tracer was chosen because that stuff is already there.

Edit:
I put some options in order from best to worst (as I see them):

1. A new pointer. ("victim" works.) Open it for access and assignent.
2. Use a pointer that projectiles don't normally use. (E.G. lastenemy.) Also needs to be opened up for use.
3. Use tracer or master. (Least work involved as far as access, but cuts into future uses for these.)
4. Bad Decorate/ACS hacks!

[Blue Shadow]

Yeah, #1 and #2 seem to be the best to go for...