Bug Report: SimpleProjectileType & Child Effect Upgrades

Hey everyone! Let's dive into a critical bug that's been discovered within the Wanderers-Of-The-Rift mod, specifically concerning the SimpleProjectileType and its interaction with child effect ability upgrade modifiers. This issue, if left unaddressed, can significantly impact gameplay, particularly for spells and abilities that rely on projectile effects. We'll break down the problem, explain why it's happening, and discuss the potential consequences. This detailed analysis should provide clarity and highlight the urgency of a fix.

The core of the problem lies within the isRelevant function within SimpleProjectileEffect. This function is responsible for checking the compatibility of child effects with ability upgrade modifiers. However, a crucial oversight exists: the function only checks child effects for ability upgrade modifier compatibility when the modifierEffect being checked is not an AttributeModifierEffect. Now, here's the kicker – almost all ability upgrade modifiers are AttributeModifierEffects. This creates a scenario where the child effect check is essentially bypassed for the very modifiers it's intended to support. This means that projectile-based abilities are unable to correctly inherit their upgrades, which drastically changes their behavior in-game. For instance, if the intent was to upgrade projectile damage or AOE, this would not be correctly applied.

The Technical Breakdown: Why It Matters

To truly understand the significance of this bug, let's delve deeper into the technical implications. The SimpleProjectileType is a fundamental component in many spell and ability implementations, especially those involving projectiles like fireballs, arrows, or magic missiles. These projectiles often have secondary effects, such as applying damage, inflicting status ailments, or creating area-of-effect explosions. The ability to upgrade these secondary effects is paramount for character progression and build diversity. Imagine a wizard investing in fireball upgrades, only to find that the damage and AOE improvements they expected simply aren't materializing.

This bug effectively severs the connection between ability upgrades and the child effects of projectiles. In simpler terms, even if a player invests skill points or uses items to enhance a projectile's secondary effects, these enhancements won't be applied in-game. This can lead to player frustration, character builds that feel weaker than they should, and a general sense of disconnect between player actions and in-game outcomes. The lack of effective upgrades can stifle character progression, rendering significant portions of the character customization system ineffective for affected abilities. This not only weakens the character but also diminishes the sense of accomplishment and strategic growth that is fundamental to the gaming experience. Without the ability to enhance and customize their abilities, players might find the game less engaging and the character progression feeling hollow.

Example: Fireball and the Missing Upgrades

Let's consider a concrete example: the classic fireball spell. A typical fireball might have a primary effect of dealing fire damage upon impact and a secondary effect of creating a small area-of-effect explosion, potentially igniting the ground or nearby enemies. Now, suppose a player invests in ability upgrades specifically designed to increase the fireball's area of effect or the damage dealt by the explosion. Under normal circumstances, these upgrades should directly enhance the fireball's secondary effects, making the spell more potent and versatile. However, due to the bug in SimpleProjectileType, these upgrades simply won't be applied. The fireball will continue to function as if no upgrades were ever purchased, leaving the player feeling cheated out of their investment and potentially weakening their character's overall effectiveness in combat.

The Bug's Impact on Gameplay

The implications of this bug extend far beyond mere inconvenience. It undermines core gameplay mechanics, introduces balance issues, and can lead to significant player frustration. Think about it: players invest time and resources into upgrading their abilities, expecting a tangible return on their investment. When those upgrades fail to function as intended, it creates a sense of disillusionment and can even discourage players from experimenting with different builds or playstyles. The core gameplay loop, which is built upon the idea of gradual character improvement, is disrupted when such a fundamental element breaks down. This issue can lead to broader imbalances across different character classes or builds, undermining the strategic depth of the game. A character that relies heavily on projectile abilities, for example, could feel significantly weaker compared to other classes that do not have the same reliance, even when a player invests in similar upgrades and customizations.

The overall impact is a less rewarding and less engaging gameplay experience. This not only affects player satisfaction in the short term but can also impact the long-term health of the game and its community. Players might become less likely to recommend the game to others, and the community could stagnate if character progression feels unfulfilling.

Potential Consequences

• Weakened Abilities: Projectile-based abilities will be significantly weaker than intended, making them less viable in combat.
• Frustrated Players: Players will be frustrated when their ability upgrades don't work as expected.
• Character Build Imbalance: Builds that rely on projectile abilities will be less effective compared to other builds.
• Reduced Player Agency: The feeling of progression and character customization is diminished when upgrades don't function.

The Root Cause: A Missed Check

Let's revisit the technical explanation to pinpoint the exact cause of this issue. The isRelevant function's logic dictates that it only checks child effects for compatibility with ability upgrade modifiers if the modifierEffect being examined is not an AttributeModifierEffect. This is where the critical error lies. Since the vast majority of ability upgrade modifiers are AttributeModifierEffects (modifying attributes like damage, area of effect, duration, etc.), the check for child effect compatibility is effectively skipped. The function never reaches the point where it considers the potential upgrades applicable to child effects.

Why This Matters Technically

From a code perspective, this suggests a conditional statement (likely an if statement) with a flawed condition. The logic may have been intended to handle certain types of modifiers differently, but the condition used is overly restrictive, inadvertently excluding the most common type of ability upgrade modifier. This type of bug is often subtle and can easily slip through initial testing, especially if the focus is primarily on the primary effects of abilities rather than the intricacies of how upgrades interact with child effects.

The underlying problem is a disconnect between the intended design (allowing upgrades to affect child effects) and the actual implementation. The code does not accurately reflect the desired behavior, and this discrepancy manifests as the bug we're discussing. Fixing this requires modifying the conditional logic within the isRelevant function to correctly account for AttributeModifierEffects when checking child effect compatibility. This will ensure that ability upgrades are properly applied to the secondary effects of projectiles, restoring the intended functionality and balance of the game.

Steps to Reproduce

To verify this bug and ensure it's properly addressed, it's crucial to have clear steps for reproduction. This allows developers to reliably observe the issue in action and confirm that the fix resolves the problem. Here's how you can reproduce the bug:

1. Create a projectile-based ability: For example, a fireball spell with an area-of-effect component.
2. Implement ability upgrade modifiers: Create modifiers that should increase the damage or area of effect of the fireball's explosion (these will likely be AttributeModifierEffects).
3. Apply the upgrades in-game: Through character progression, skill points, or items, apply the upgrade modifiers to the fireball ability.
4. Test the ability: Cast the fireball and observe its behavior. Specifically, check if the area of effect and damage of the explosion increase as expected.
5. Observe the bug: You should notice that the upgrades do not affect the explosion's size or damage. The fireball will behave as if no upgrades were applied to its secondary effects.

Detailed Testing is Key

It's important to test this bug with different types of projectile abilities, various upgrade modifiers, and under diverse in-game conditions. This comprehensive testing approach helps to ensure that the bug is consistently reproducible and that the fix addresses all potential scenarios. By providing detailed and reproducible steps, the reporting process becomes significantly more effective, leading to quicker identification and resolution of the issue.

Proposed Solution

The most straightforward solution is to modify the isRelevant function within SimpleProjectileEffect to correctly handle AttributeModifierEffects. Specifically, the conditional logic needs to be adjusted to ensure that child effects are checked for compatibility even when the modifierEffect is an AttributeModifierEffect.

Technical Implementation

This likely involves removing or modifying the if statement that currently excludes AttributeModifierEffects from the child effect check. The exact code changes will depend on the specific implementation of the function, but the core principle is to ensure that the child effect compatibility check is performed regardless of the modifier type. The code might need adjustments to properly handle various modifier types without inadvertently introducing new issues. It's essential to maintain the function's overall efficiency and avoid creating performance bottlenecks during gameplay.

Testing the Fix

After implementing the fix, thorough testing is crucial to ensure that the bug is resolved and that no new issues have been introduced. This testing should include:

• Regression testing: Verify that the original bug is indeed fixed by following the reproduction steps outlined earlier.
• New functionality testing: Ensure that the ability upgrades now correctly affect the child effects of projectiles.
• Performance testing: Check that the fix does not negatively impact game performance, particularly in scenarios with multiple projectiles or complex effects.
• Edge case testing: Explore different combinations of abilities, modifiers, and game conditions to identify any potential edge cases or unexpected interactions.

Conclusion

In conclusion, the bug within SimpleProjectileType that prevents child effect ability upgrade modifiers from functioning correctly is a significant issue that needs to be addressed promptly. This bug undermines core gameplay mechanics, leads to player frustration, and can create balance issues within the game. By understanding the technical details of the bug, its impact on gameplay, and the proposed solution, we can work together to ensure a more enjoyable and rewarding experience for all players. The urgency of this fix should be recognized to ensure the game continues to provide a fair and engaging experience for all players.

Let's hope the developers can implement a fix soon so we can all get back to enjoying our fully upgraded projectile abilities!