RJW Cumpilation & Menstruation Compatibility Patch

Features

• Resolves direct conflicts between Cumpilation and RJW Menstruation.
• Integrates relevant mechanics where overlap occurs (e.g., fluid interactions, mood effects).
• Adjusts definitions and patches to ensure both mods function as intended when loaded together.

Installation

1. Ensure you have the required mods installed:
   • RimJobWorld (RJW)
   • RJW Menstruation
   • Cumpilation
2. Subscribe to this mod on the Steam Workshop OR download the release and place it in your RimWorld Mods folder.
3. Activate the mod in the RimWorld mod list.
4. Recommended Load Order:
   • Core
   • Royalty (if applicable)
   • Ideology (if applicable)
   • Biotech (if applicable)
   • Anomaly (if applicable)
   • RimJobWorld (RJW)
   • RJW Menstruation
   • Cumpilation
   • RJW Cumpilation & Menstruation Compatibility Patch (This Mod)
   • Other mods

Compatibility

• Required: RimJobWorld, RJW Menstruation, Cumpilation.
• Designed For: RimWorld versions 1.4, 1.5 (Specify supported versions). Maintain a clear version compatibility matrix for required mods.
• Known Incompatibilities: None currently known. Please report any issues.

Design Ideas & Considerations

This section outlines the guiding principles and areas of focus for the patch's development and maintenance.

Core Philosophy & Scope

• Strict Scope Definition: Focus solely on resolving conflicts and enabling sensible, intuitive interactions between Cumpilation and Menstruation. Avoid feature creep; new mechanics should belong in the parent mods or dedicated add-ons.
• Philosophical Alignment: Ensure integrations align with the design intent and "feel" of RJW, Cumpilation, and Menstruation, avoiding changes that contradict their core mechanics unless essential for compatibility. Prioritize lore-friendliness within the RJW context.
• Modularity: Design patches to be as independent as possible. Consider optional sub-modules (potentially separate mini-mods requiring this patch) for deeper integration with specific third-party mods (e.g., Dubs Bad Hygiene, specific race mods, psychology mods) to keep the core patch lean and focused.

Gameplay Integration & Mechanics

• Body Fluid Management:
  • Establish a unified framework for how relevant body fluids (RJW core, Cumpilation, Menstruation) are handled (generation, tracking, cleaning, effects, genetics influence) when the patch is active.
  • Ensure Cumpilation's systems correctly account for menstrual blood without duplication or conflict (e.g., cleaning jobs, fluid map tracking, 'messiness' calculations).
  • Explore balanced cross-mod fluid effects (e.g., Cumpilation fluids influencing cycle intensity/symptoms, menstrual blood affecting Cumpilation mechanics like 'messiness' or specific interactions, potential impact on fertility beyond cycle suspension) within the defined scope. Avoid overly complex or niche interactions.
  • Verify visual consistency of fluid decals/textures, preventing overlap or rendering glitches. Consider subtle visual cues for mixed fluids if feasible and performant.
  • Investigate interactions with fluid-related genes (Biotech) or traits, ensuring predictable outcomes. Consider xenotype-specific fluid production or cycle differences.
  • Evaluate interactions with artificial body parts related to reproduction or fluid generation.
• Hediff & Mood Interactions:
  • Review and harmonize Hediffs and mood effects. Define clear interaction rules (stacking, modification, cancellation, thresholds) to prevent unintended consequences (e.g., excessive mood swings, conflicting physiological states like arousal vs. pain, Hediff loops). Provide specific examples like how menstrual cramps might interact with arousal or post-coital moodlets.
  • Consider if states/Hediffs from one mod should influence the triggers, severity, or duration of effects from the other (e.g., sickness affecting cycle regularity/severity, cycle stage affecting Cumpilation moodlets or interaction outcomes, arousal levels influencing cycle symptoms).
  • Ensure pregnancy mechanics (from RJW or other mods) interact predictably with both Menstruation (cycle suspension) and Cumpilation (relevant fluid/state changes). Verify interactions with RJW's own fertility calculations.
  • Consider long-term or cumulative effects of combined Hediffs over a pawn's lifespan.
• Event & Trigger Interactions:
  • Analyze how events/triggers from one mod should logically interact with the state determined by the other (e.g., Cumpilation events considering menstrual phase, Menstruation events considering Cumpilation states like arousal or recent activity).
  • Ensure timed events or cycles from both mods remain synchronized and function correctly together, especially across save/load cycles.
• AI Behavior:
  • Evaluate if combined states should influence pawn AI decisions (e.g., cleaning priorities based on fluid type/mix, mood-driven behavior changes, interaction seeking/avoidance based on cycle/fluid state, partner choice considerations based on perceived 'messiness' or mood). Keep AI changes subtle and performance-conscious.
  • Consider impact on social interactions: How do pawns react to others experiencing strong mood swings or messiness resulting from combined effects?
• Hygiene & Cleaning:
  • Verify that cleaning mechanics (from Cumpilation, RJW, Vanilla, or popular hygiene mods like Dubs Bad Hygiene) properly handle fluids generated by both mods under the patch. Ensure correct job assignment and filth removal.
  • Consider optional, explicit support for popular hygiene mods, ensuring graceful degradation if they aren't present. This might involve specific PatchOperations targeting hygiene mod Defs or providing API hooks if available.
• Trait, Gene, & Race Compatibility:
  • Ensure compatibility with relevant traits (e.g., Lecher, Nympho, Prude, Sanguine, Volatile), Biotech genes (especially those affecting reproduction, fluids, mood, pain sensitivity), and common custom races. Address how combined effects manifest regarding menstruation and Cumpilation mechanics.
  • Test with common race mods (e.g., HAR-based races) to ensure body part definitions and physiological responses are handled correctly. Define fallback mechanisms for unknown races where possible.
  • Explicitly consider Biotech xenotypes and their unique physiologies or gene combinations.
• Anomaly DLC Integration (Optional):
  • Investigate potential interactions with Anomaly content if deemed relevant and within scope. Examples: How do psychic effects influence cycles or Cumpilation states? Do specific entities react differently to pawns based on combined states? Are there interactions with bioferrite harvesting or mutations? (Requires careful consideration to maintain scope).
• Mechanic Balancing:
  • Continuously evaluate the combined effects on gameplay balance within RimWorld and RJW. Avoid creating exploits, unintended power shifts, or excessive pawn micromanagement.
  • Actively solicit and incorporate community feedback on balance, especially regarding mood intensity, frequency of events, resource implications (e.g., cleaning, hygiene needs), and impact on pawn effectiveness.

Configuration & User Experience

• Configuration Options:
  • Implement Mod Settings for granular control over integration features (e.g., toggling specific fluid interactions, mood stacking rules, AI behavior adjustments) and balance parameters (e.g., effect intensity multipliers, frequency checks, specific Hediff interaction toggles).
  • Clearly define how patch settings interact with parent mod settings (precedence, linkage, detection of parent settings). Aim for patch settings to override or modify behavior only when necessary for compatibility or explicit user choice. Consider dynamically enabling/disabling patch settings based on detected parent mod settings.
  • Explore configuration profiles (presets) for different playstyles (e.g., "Minimal Impact", "Full Integration", "Performance Focus").
• User Experience & Documentation:
  • Strive for seamless and intuitive integration; patched interactions should feel natural and require minimal user intervention beyond initial setup.
  • Improve in-game tooltips/descriptions on relevant Hediffs, items, and interactions to clarify combined effects or states originating from the patch. Use dynamic text where possible to reflect current settings.
  • Provide clear visual feedback for combined states where appropriate and feasible (e.g., distinct icons/overlays on the pawn's health tab, subtle visual cues on the pawn itself), avoiding UI clutter.
  • Write clear, concise explanations for Mod Settings options and their impact within the settings menu itself. Include warnings for settings with significant performance implications.
  • Maintain a comprehensive CHANGELOG detailing changes, additions, and fixes per version. Clearly state compatibility versions for RimWorld and all required mods.
• Localization:
  • Structure all user-facing text (settings, tooltips, logs, messages) using standard RimWorld localization keys (`Keyed` folder) for easy community translation efforts. Provide English source files.

Technical Implementation & Maintenance

• Patching Strategy:
  • Prioritize XML XPath patching for robustness against updates, targeting specific Defs and nodes precisely. Use C# Harmony patching only when essential for complex logic, conditional checks, modifying private methods, or achieving specific interaction flows inaccessible via XML.
  • Use PatchOperationFindMod rigorously for all dependencies. Define dependencies clearly using loadAfter in About.xml. Ensure this patch loads *after* Cumpilation and Menstruation.
  • Consider checks for specific dependency *versions* (`supportedVersions` in `About.xml` or runtime checks) if breaking changes are common in dependencies. Maintain the version compatibility matrix diligently.
  • Employ conditional patching (`MayRequire` attribute in XPath, conditional logic in C#) based on mod presence and potentially their settings to maximize compatibility and minimize errors.
  • When using Harmony, prefer Postfix/Transpiler patches over Prefixes to minimize conflicts. Use unique Harmony IDs. Check for existing patches before applying.
• Performance: Maintain focus on performance. Use targeted XML patches. If C# is used, write efficient code, avoid frequent `OnTick` operations, cache frequently accessed data, and profile using tools like Dubs Performance Analyzer, especially for AI, Hediff logic, or fluid tracking. Benchmark critical code paths.
• Error Handling & Logging: Implement robust error checking (e.g., null checks, type checks in C#). Provide clear, identifiable logging messages (prefixed with the mod name) for patch application success/failure and runtime issues to aid user troubleshooting. Use Verse.Log.Warning for non-critical issues and Verse.Log.Error for critical failures. Avoid log spam in release builds.
• Graceful Degradation: Ensure the patch handles missing dependencies (required or optional) cleanly, disabling relevant functions or logging informative errors rather than causing critical game failures (red errors).
• Update Strategy: Define a process for promptly reviewing and updating the patch in response to updates in RimWorld or dependency mods. Monitor dependency mod changelogs, GitHub repositories, and community reports.
• Save Game Compatibility: Strive to maintain save compatibility between patch versions whenever possible. Clearly document any unavoidable breaking changes in the CHANGELOG and potentially via in-game notifications on load. Avoid storing complex custom data in save files unless absolutely necessary; prefer deriving state from existing game data or Hediffs.
• Testing Strategy: Implement rigorous testing covering diverse scenarios: different combinations of settings (patch and parent mods), various traits, genes, races, other common mods (especially UI, AI, medical, psychology, and other RJW add-ons), and edge cases (e.g., starting scenarios, caravan travel, pawn death/resurrection, mid-save addition/removal if feasible). Utilize developer mode tools for spawning items, triggering events, and manipulating pawn states. Consider simple automated checks (e.g., XML validation scripts, basic Harmony patch verification).
• Code Structure (If C#): Adhere to C# best practices: use clear namespaces, follow consistent style guides (e.g., .NET conventions), write explanatory comments for complex logic, implement proper error handling (try-catch blocks where appropriate). Use Harmony safely and defensively. Avoid static constructors for initialization that might run too early; use StaticConstructorOnStartup or appropriate game initialization hooks.

Community & Feedback

• Feedback Channels: Establish and actively monitor clear channels (e.g., GitHub Issues, Steam Workshop comments, dedicated Discord channel/forum thread) for bug reports, suggestions, and balance feedback. Use templates for bug reports if possible.
• Contribution: Encourage community contributions via pull requests (with clear guidelines on code style, testing, and scope) or detailed issue reporting. Be responsive to contributions and feedback.
• Transparency: Communicate development progress, known issues, and future plans openly (e.g., via GitHub Projects/Milestones, regular updates on Steam/forums).

Future Plans

• Address any reported compatibility issues promptly.
• Investigate potential integrations with other relevant RJW add-ons or popular mods (e.g., Dubs Bad Hygiene, Children School and Learning, Psychology, HAR races, potentially animation frameworks) based on user feedback and observed interactions, potentially as optional modules or configuration toggles.
• Refine existing patches for better balance, performance, or smoother interaction based on ongoing testing and feedback.
• Expand Mod Settings options based on user requests and feasibility, prioritizing high-impact or frequently requested features that align with the patch's scope.
• Keep compatibility updated with new versions of RimWorld and required mods in a timely manner.
• Improve localization support and encourage community translations.

Contributing

Contributions are welcome! Please feel free to fork the repository, make changes, and submit a pull request adhering to the project's coding style and contribution guidelines (if available). You can also report issues or suggest features via the GitHub issue tracker or designated community channels. Consider joining any associated community Discord or forum for discussion.

License

[Specify License - e.g., MIT, Creative Commons Attribution-ShareAlike 4.0 International]