DSDA Vs. Woof: Kill Count Discrepancies With Friendly Creatures

Introduction

Hey guys, let's dive into a quirky issue that's been popping up in the Doom community regarding how different source ports handle kill counts when friendly creatures are involved. Specifically, we're looking at a discrepancy between DSDA and Woof, two popular source ports, when dealing with monster resurrection and kill floors, particularly in scenarios involving friendly Archviles. This came to light thanks to Grapes on the DSDA server, who noticed some weird behavior while mapping for Fastfood 2. So, what's the deal? Let's break it down and see if we can figure out which port is behaving "correctly," or if there's even a correct way to handle this bizarre situation.

The Problem: Kill Count Gone Wild

Grapes designed a map for Fastfood 2 where monsters are subjected to an MBF21 kill floor transfer, which essentially means they're constantly being killed and resurrected. The twist? Friendly Archviles are the ones doing the resurrecting. In DSDA/Nyan, this setup causes the kill count to go absolutely bonkers. As you can see in the image Grapes shared, the kill count skyrockets to an absurd number, far beyond what you'd expect from the actual number of unique monsters present.

Now, here's where it gets interesting. In Woof, the behavior is different. Woof seems to only count the first 128 kills, and then it just stops registering any of the respawns as new kills. This is a significant difference from DSDA, where every single kill, even those resulting from resurrection, seems to be added to the total count. So, which port is right? Is one of them bugging out, or is this just an edge case that exposes different interpretations of how kill counts should work?

Why This Matters

Before we get too deep into the technical weeds, let's talk about why this discrepancy matters. For mapmakers, consistency across source ports is crucial. You want players to have a similar experience regardless of which port they choose to play on. If a map behaves wildly differently in DSDA compared to Woof, it can lead to confusion and frustration. Imagine designing a map with a specific kill count in mind, only to find that it's completely off in one of the most popular source ports.

Moreover, this issue touches on the fundamental mechanics of Doom and how different engines interpret those mechanics. Kill counts aren't just arbitrary numbers; they're often tied to progression, secrets, and overall gameplay. A broken kill count can throw off the balance of a map and make it either too easy or impossibly difficult.

Diving Deeper: Technical Considerations

To understand why DSDA and Woof behave differently, we need to consider a few technical aspects of Doom and its source ports.

1. How Kill Counts Are Tracked

In the original Doom engine, the kill count is a simple integer that increments whenever a monster dies. However, source ports have made various modifications and extensions to this system. Some ports might implement limits to prevent integer overflow, while others might introduce more sophisticated tracking mechanisms to handle special cases.

2. The Role of MBF21 and Kill Floors

MBF21 is a set of extensions to the Doom engine that allows for more advanced scripting and behavior. The kill floor transfer effect, in particular, is a powerful tool that can be used to create interesting gameplay scenarios. However, it also introduces complexity, as it involves constantly killing and potentially resurrecting monsters.

3. Friendly Monsters and Their Impact

Friendly monsters add another layer of complexity. In Doom, monsters can be flagged as friendly, meaning they won't attack the player. However, they can still be killed by other monsters or environmental hazards. The question is, should kills caused by friendly monsters count towards the total kill count? Different source ports might have different answers to this question.

4. Resurrection and the Kill Count

Resurrection, typically performed by Archviles, is a key factor in this scenario. When an Archvile resurrects a monster, is that considered a new kill if the monster is subsequently killed again? DSDA seems to say yes, while Woof appears to say no, at least after a certain threshold. Understanding how each port handles resurrection is crucial to resolving this discrepancy.

Analyzing DSDA's Behavior

DSDA appears to be counting every single kill, regardless of whether the monster has been previously killed and resurrected. This means that in Grapes' map, where monsters are constantly being killed and resurrected, the kill count will continue to climb indefinitely. This behavior might be considered a bug, as it doesn't accurately reflect the number of unique monsters killed.

However, it could also be argued that DSDA is simply following the literal definition of the kill count: every time a monster dies, increment the counter. In this view, the fact that the monster was previously killed and resurrected is irrelevant. The key point here is that DSDA does not appear to have any built-in safeguards to prevent the kill count from going wild in scenarios like this.

Analyzing Woof's Behavior

Woof, on the other hand, seems to be implementing some kind of limit or filtering mechanism. It counts the first 128 kills, but then stops counting any subsequent kills resulting from resurrection. This behavior suggests that Woof is trying to prevent the kill count from going out of control in situations like this.

One possible explanation for this behavior is that Woof is tracking which monsters have already been killed and resurrected, and it's only counting the initial kill for each monster. Another possibility is that Woof has a hard-coded limit on the number of kills it will count in a given timeframe. Whatever the underlying mechanism, the end result is that Woof's kill count remains more reasonable in Grapes' map.

Is Woof "Correcting" the Kill Count?

It's tempting to say that Woof is behaving more "correctly" in this scenario, as its kill count is more representative of the actual number of unique monsters killed. However, it's important to remember that the definition of "correct" is somewhat subjective here. The original Doom engine didn't anticipate scenarios like this, so there's no definitive answer as to how kill counts should behave in these situations.

Potential Solutions and Workarounds

So, what can be done to address this discrepancy between DSDA and Woof? Here are a few potential solutions and workarounds:

1. Standardize Kill Count Behavior

One option would be for the developers of DSDA and Woof to collaborate and standardize the way kill counts are handled in these edge cases. This could involve implementing a filtering mechanism similar to Woof's in DSDA, or removing the limit in Woof. However, this would require careful consideration to ensure that the changes don't break existing maps or introduce new issues.

2. Map-Specific Fixes

Another approach would be to implement map-specific fixes to prevent the kill count from going wild. This could involve using scripting to track the number of unique monsters killed and adjust the kill count accordingly. However, this would require more work on the part of the mapmaker and might not be feasible for all maps.

3. Educate Mapmakers

Finally, it's important to educate mapmakers about this discrepancy so they can take it into account when designing their maps. By understanding how different source ports handle kill counts, mapmakers can avoid creating scenarios that lead to unexpected behavior.

Conclusion

The discrepancy between DSDA and Woof in handling kill counts with friendly creatures and monster resurrection highlights the complexities of maintaining compatibility and consistency across different Doom source ports. While there's no easy answer as to which port is behaving "correctly," understanding the underlying mechanics and potential solutions can help mapmakers create maps that work well on all platforms. Whether it's standardizing kill count behavior, implementing map-specific fixes, or simply educating mapmakers, addressing this issue will ultimately lead to a better experience for Doom players. Keep experimenting, keep mapping, and keep pushing the boundaries of what's possible in the Doom universe! And hopefully, this deep dive has been helpful in understanding this quirky aspect of Doom modding.